OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

marge: 合并11.2版本

Browse Source
This commit is contained in:
TsMask
2024-11-22 10:16:12 +08:00
parent 1bdb13a2ab
commit 7bcb439d57
248 changed files with 18401 additions and 11120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/modules/monitor/controller/monitor.go
View File

@@ -11,15 +11,14 @@ import (
// 实例化控制层 MonitorInfoController 结构体
var NewMonitor = &MonitorController{
monitorService: service.NewMonitorImpl,
monitorService: service.NewMonitor,
}
// 服务器资源监控信息
//
// PATH /monitor
type MonitorController struct {
// 服务器系统相关信息服务
monitorService service.IMonitor
monitorService *service.Monitor // 服务器系统相关信息服务
}
// 资源监控信息加载
@@ -28,21 +27,14 @@ type MonitorController struct {
func (s *MonitorController) Load(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys struct {
// 数据类型all/load/cpu/memory/io/network
Type string `form:"type" binding:"required,oneof=all load cpu memory io network"`
// 开始时间
StartTime int64 `form:"startTime" binding:"required"`
// 结束时间
EndTime int64 `form:"endTime" binding:"required"`
// 网元类型
NeType string `form:"neType"`
// 网元ID
NeID string `form:"neId"`
// 名称，networ和iok时有效
Name string `form:"name"`
Type string `form:"type" binding:"required,oneof=all load cpu memory io network"` // 数据类型all/load/cpu/memory/io/network
StartTime int64 `form:"startTime" binding:"required"` // 开始时间
EndTime int64 `form:"endTime" binding:"required"` // 结束时间
NeType string `form:"neType"` // 网元类型
NeID string `form:"neId"` // 网元ID
Name string `form:"name"` // 名称，networ和io时有效
}
err := c.ShouldBindQuery(&querys)
if err != nil {
if err := c.ShouldBindQuery(&querys); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}

2
src/modules/monitor/controller/sys_cache.go
View File

@@ -141,10 +141,8 @@ func (s *SysCacheController) ClearCacheKey(c *gin.Context) {
func (s *SysCacheController) ClearCacheSafe(c *gin.Context) {
language := ctx.AcceptLanguage(c)
caches := []model.SysCache{
model.NewSysCacheNames(i18n.TKey(language, "cache.name.user"), cachekey.LOGIN_TOKEN_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_config"), cachekey.SYS_CONFIG_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.sys_dict"), cachekey.SYS_DICT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.captcha_codes"), cachekey.CAPTCHA_CODE_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.repeat_submit"), cachekey.REPEAT_SUBMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.rate_limit"), cachekey.RATE_LIMIT_KEY),
model.NewSysCacheNames(i18n.TKey(language, "cache.name.pwd_err_cnt"), cachekey.PWD_ERR_CNT_KEY),

10
src/modules/monitor/controller/sys_job.go
View File

@@ -22,18 +22,16 @@ import (
// 实例化控制层 SysJobLogController 结构体
var NewSysJob = &SysJobController{
sysJobService: service.NewSysJobImpl,
sysDictDataService: systemService.NewSysDictDataImpl,
sysJobService: service.NewSysJob,
sysDictDataService: systemService.NewSysDictData,
}
// 调度任务信息
//
// PATH /monitor/job
type SysJobController struct {
// 调度任务服务
sysJobService service.ISysJob
// 字典数据服务
sysDictDataService systemService.ISysDictData
sysJobService *service.SysJob // 调度任务服务
sysDictDataService *systemService.SysDictData // 字典数据服务
}
// 调度任务列表

12
src/modules/monitor/controller/sys_job_log.go
View File

@@ -21,18 +21,16 @@ import (
// 实例化控制层 SysJobLogController 结构体
var NewSysJobLog = &SysJobLogController{
sysJobLogService: service.NewSysJobLogImpl,
sysDictDataService: systemService.NewSysDictDataImpl,
sysJobLogService: service.NewSysJobLog,
sysDictDataService: systemService.NewSysDictData,
}
// 调度任务日志信息
//
// PATH /monitor/jobLog
type SysJobLogController struct {
// 调度任务日志服务
sysJobLogService service.ISysJobLog
// 字典数据服务
sysDictDataService systemService.ISysDictData
sysJobLogService *service.SysJobLog // 调度任务日志服务
sysDictDataService *systemService.SysDictData // 字典数据服务
}
// 调度任务日志列表
@@ -44,7 +42,7 @@ func (s *SysJobLogController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
// 任务ID优先级更高
if v, ok := querys["jobId"]; ok && v != nil {
jobInfo := service.NewSysJobImpl.SelectJobById(v.(string))
jobInfo := service.NewSysJob.SelectJobById(v.(string))
querys["jobName"] = jobInfo.JobName
querys["jobGroup"] = jobInfo.JobGroup
}

54
src/modules/monitor/controller/sys_user_online.go
View File

@@ -6,7 +6,6 @@ import (
"strings"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/constants/roledatascope"
"be.ems/src/framework/i18n"
"be.ems/src/framework/redis"
"be.ems/src/framework/utils/ctx"
@@ -20,15 +19,14 @@ import (
// 实例化控制层 SysUserOnlineController 结构体
var NewSysUserOnline = &SysUserOnlineController{
sysUserOnlineService: service.NewSysUserOnlineImpl,
sysUserOnlineService: service.NewSysUserOnline,
}
// 在线用户监控
//
// PATH /monitor/online
type SysUserOnlineController struct {
// 在线用户服务
sysUserOnlineService service.ISysUserOnline
sysUserOnlineService *service.SysUserOnline // 在线用户服务
}
// 在线用户列表
@@ -38,43 +36,6 @@ func (s *SysUserOnlineController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
ipaddr := c.Query("ipaddr")
userName := c.Query("userName")
data := map[string]any{
"total": 0,
"rows": []model.SysUserOnline{},
}
// 当前登录用户
currentUser, _ := ctx.LoginUser(c)
currentRoleKey := ""
currentRoleDataScope := ""
if len(currentUser.User.Roles) > 0 {
role := currentUser.User.Roles[0]
currentRoleKey = role.RoleKey
currentRoleDataScope = role.DataScope
}
if currentRoleKey == "" {
c.JSON(200, result.Ok(data))
return
}
hasRoleDataScope := func(loginUser vo.LoginUser) bool {
if currentRoleDataScope == roledatascope.ALL {
return true
}
if currentRoleDataScope == roledatascope.CUSTOM {
return false
}
if currentRoleDataScope == roledatascope.DEPT && loginUser.DeptID == currentUser.DeptID {
return true
}
if currentRoleDataScope == roledatascope.DEPT_AND_CHILD && (strings.Contains(loginUser.User.Dept.Ancestors, currentUser.DeptID) || currentUser.DeptID == loginUser.DeptID) {
return true
}
if currentRoleDataScope == roledatascope.SELF && loginUser.UserID == currentUser.UserID {
return true
}
return false
}
// 获取所有在线用户key
keys, _ := redis.GetKeys("", cachekey.LOGIN_TOKEN_KEY+"*")
@@ -106,10 +67,6 @@ func (s *SysUserOnlineController) List(c *gin.Context) {
continue
}
if !hasRoleDataScope(loginUser) {
continue
}
onlineUser := s.sysUserOnlineService.LoginUserToUserOnline(loginUser)
if onlineUser.TokenID != "" {
onlineUser.LoginLocation = i18n.TKey(language, onlineUser.LoginLocation)
@@ -146,9 +103,10 @@ func (s *SysUserOnlineController) List(c *gin.Context) {
return filteredUserOnlines[j].LoginTime > filteredUserOnlines[i].LoginTime
})
data["total"] = len(filteredUserOnlines)
data["rows"] = filteredUserOnlines
c.JSON(200, result.Ok(data))
c.JSON(200, result.Ok(map[string]any{
"total": len(filteredUserOnlines),
"rows": filteredUserOnlines,
}))
}
// 在线用户强制退出

10
src/modules/monitor/controller/system_info.go
View File

@@ -9,27 +9,27 @@ import (
// 实例化控制层 SystemInfoController 结构体
var NewSystemInfo = &SystemInfoController{
systemInfogService: service.NewSystemInfoImpl,
systemInfogService: service.NewSystemInfo,
}
// 服务器监控信息
//
// PATH /monitor/system-info
type SystemInfoController struct {
// 服务器系统相关信息服务
systemInfogService service.ISystemInfo
systemInfogService *service.SystemInfo // 服务器系统相关信息服务
}
// 服务器信息
//
// GET /
func (s *SystemInfoController) Info(c *gin.Context) {
c.JSON(200, result.OkData(map[string]any{
data := map[string]any{
"cpu": s.systemInfogService.CPUInfo(),
"memory": s.systemInfogService.MemoryInfo(),
"network": s.systemInfogService.NetworkInfo(),
"time": s.systemInfogService.TimeInfo(),
"system": s.systemInfogService.SystemInfo(),
"disk": s.systemInfogService.DiskInfo(),
}))
}
c.JSON(200, result.OkData(data))
}

33
src/modules/monitor/model/monitor_base.go
View File

@@ -2,28 +2,19 @@ package model
// MonitorBase 监控_基本信息 monitor_base
type MonitorBase struct {
// id
ID int64 `json:"id" gorm:"primaryKey"`
// 创建时间
CreateTime int64 `json:"createTime"`
// cpu使用率
CPU float64 `json:"cpu"`
// cpu平均使用率
LoadUsage float64 `json:"loadUsage"`
// cpu使用1分钟
CPULoad1 float64 `json:"cpuLoad1"`
// cpu使用5分钟
CPULoad5 float64 `json:"cpuLoad5"`
// cpu使用15分钟
CPULoad15 float64 `json:"cpuLoad15"`
// 内存使用率
Memory float64 `json:"memory"`
// 网元ID
NeType string `json:"neType"`
// 网元类型
NeID string `json:"neId"`
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
CPU float64 `json:"cpu" gorm:"cpu"` // cpu使用率
LoadUsage float64 `json:"loadUsage" gorm:"load_usage"` // cpu平均使用率
CPULoad1 float64 `json:"cpuLoad1" gorm:"cpu_load1"` // cpu使用1分钟
CPULoad5 float64 `json:"cpuLoad5" gorm:"cpu_load5"` // cpu使用5分钟
CPULoad15 float64 `json:"cpuLoad15" gorm:"cpu_load15"` // cpu使用15分钟
Memory float64 `json:"memory" gorm:"memory"` // 内存使用率
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
}
func (MonitorBase) TableName() string {
// TableName 表名称
func (*MonitorBase) TableName() string {
return "monitor_base"
}

30
src/modules/monitor/model/monitor_io.go
View File

@@ -2,26 +2,18 @@ package model
// MonitorIO 监控_磁盘IO monitor_io
type MonitorIO struct {
// id
ID int64 `json:"id" gorm:"primaryKey"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 磁盘名
Name string `json:"name"`
// 读取K
Read int64 `json:"read"`
// 写入K
Write int64 `json:"write"`
// 次数
Count int64 `json:"count"`
// 耗时
Time int64 `json:"time"`
// 网元ID
NeType string `json:"neType"`
// 网元类型
NeID string `json:"neId"`
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
Name string `json:"name" gorm:"name"` // 磁盘名
Read int64 `json:"read" gorm:"read"` // 读取K
Write int64 `json:"write" gorm:"write"` // 写入K
Count int64 `json:"count" gorm:"count"` // 读写次数
Time int64 `json:"time" gorm:"time"` // 读写延迟
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
}
func (MonitorIO) TableName() string {
// TableName 表名称
func (*MonitorIO) TableName() string {
return "monitor_io"
}

24
src/modules/monitor/model/monitor_network.go
View File

@@ -2,22 +2,16 @@ package model
// MonitorNetwork 监控_网络IO monitor_network
type MonitorNetwork struct {
// id
ID int64 `json:"id" gorm:"primaryKey"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 网卡名
Name string `json:"name"`
// 上行
Up float64 `json:"up"`
// 下行
Down float64 `json:"down"`
// 网元ID 本机#号
NeType string `json:"neType"`
// 网元类型 本机#号
NeID string `json:"neId"`
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"`
CreateTime int64 `json:"createTime" gorm:"create_time"` // 创建时间
Name string `json:"name" gorm:"name"` // 网卡名
Up float64 `json:"up" gorm:"up"` // 上行
Down float64 `json:"down" gorm:"down"` // 下行
NeType string `json:"neType" gorm:"ne_type"` // 网元类型
NeID string `json:"neId" gorm:"ne_id"` // 网元ID
}
func (MonitorNetwork) TableName() string {
// TableName 表名称
func (*MonitorNetwork) TableName() string {
return "monitor_network"
}

2
src/modules/monitor/monitor.go
View File

@@ -165,5 +165,5 @@ func InitLoad() {
// 初始化定时任务处理
processor.InitCronQueue()
// 启动时，初始化调度任务
service.NewSysJobImpl.ResetQueueJob()
service.NewSysJob.ResetQueueJob()
}

278
src/modules/monitor/service/monitor.go
View File

@@ -1,14 +1,274 @@
package service
// IMonitor 服务器系统相关信息 服务层接口
type IMonitor interface {
// RunMonitor 执行资源监控
RunMonitor()
import (
"context"
"strconv"
"time"
// RunMonitorDataCancel 启动资源监控数据存储io/network通道 移除之前的chan上下文后在设置新的均值
// interval 采集的平均值（分钟）
RunMonitorDataCancel(removeBefore bool, interval float64)
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
systemService "be.ems/src/modules/system/service"
"github.com/shirou/gopsutil/v4/cpu"
"github.com/shirou/gopsutil/v4/disk"
"github.com/shirou/gopsutil/v4/load"
"github.com/shirou/gopsutil/v4/mem"
"github.com/shirou/gopsutil/v4/net"
)
// SelectMonitorInfo 查询监控资源信息
SelectMonitorInfo(query map[string]any) map[string]any
// 实例化服务层 Monitor 结构体
var NewMonitor = &Monitor{
sysConfigService: systemService.NewSysConfigImpl,
monitorRepository: repository.NewMonitorImpl,
diskIO: make(chan []disk.IOCountersStat, 2),
netIO: make(chan []net.IOCountersStat, 2),
}
// Monitor 服务器系统相关信息 服务层处理
type Monitor struct {
// 参数配置服务
sysConfigService systemService.ISysConfig
// 监控服务资源数据信息
monitorRepository repository.IMonitor
// 磁盘网络IO 数据通道
diskIO chan ([]disk.IOCountersStat)
netIO chan ([]net.IOCountersStat)
}
// RunMonitor 执行资源监控
func (s *Monitor) RunMonitor() {
var itemBase model.MonitorBase
itemBase.CreateTime = time.Now().UnixMilli()
itemBase.NeType = "#"
itemBase.NeID = "#"
loadInfo, _ := load.Avg()
itemBase.CPULoad1 = loadInfo.Load1
itemBase.CPULoad5 = loadInfo.Load5
itemBase.CPULoad15 = loadInfo.Load15
totalPercent, _ := cpu.Percent(3*time.Second, false)
if len(totalPercent) > 0 {
itemBase.CPU = totalPercent[0]
}
cpuCount, _ := cpu.Counts(false)
cpuAvg := (float64(cpuCount*2) * 0.75) * 100
itemBase.LoadUsage = 0
if cpuAvg > 0 {
itemBase.LoadUsage = loadInfo.Load1 / cpuAvg
}
memoryInfo, _ := mem.VirtualMemory()
itemBase.Memory = memoryInfo.UsedPercent
if err := s.monitorRepository.CreateMonitorBase(itemBase); err != nil {
logger.Errorf("CreateMonitorBase err: %v", err)
}
// 将当前资源发送到chan中处理保存
s.loadDiskIO()
s.loadNetIO()
// 监控系统资源-保留天数
storeDays := s.sysConfigService.SelectConfigValueByKey("monitor.sysResource.storeDays")
if storeDays != "" {
storeDays, _ := strconv.Atoi(storeDays)
ltTime := time.Now().AddDate(0, 0, -storeDays).UnixMilli()
_ = s.monitorRepository.DelMonitorBase(ltTime)
_ = s.monitorRepository.DelMonitorIO(ltTime)
_ = s.monitorRepository.DelMonitorNet(ltTime)
}
}
func (s *Monitor) loadDiskIO() {
ioStat, _ := disk.IOCounters()
var diskIOList []disk.IOCountersStat
for _, io := range ioStat {
diskIOList = append(diskIOList, io)
}
s.diskIO <- diskIOList
}
func (s *Monitor) loadNetIO() {
netStat, _ := net.IOCounters(true)
netStatAll, _ := net.IOCounters(false)
var netList []net.IOCountersStat
netList = append(netList, netStat...)
netList = append(netList, netStatAll...)
s.netIO <- netList
}
// monitorCancel 监控搜集IO/Network上下文
var monitorCancel context.CancelFunc
// RunMonitorDataCancel 启动资源监控数据存储io/network通道 移除之前的chan上下文后在设置新的均值
// interval 采集的平均值（分钟）
func (s *Monitor) RunMonitorDataCancel(removeBefore bool, interval float64) {
// 是否取消之前的
if removeBefore {
monitorCancel()
}
// 上下文控制
ctx, cancel := context.WithCancel(context.Background())
monitorCancel = cancel
// chanl 通道进行存储数据
go s.saveIODataToDB(ctx, interval)
go s.saveNetDataToDB(ctx, interval)
}
func (s *Monitor) saveIODataToDB(ctx context.Context, interval float64) {
defer close(s.diskIO)
for {
select {
case <-ctx.Done():
return
case ioStat := <-s.diskIO:
select {
case <-ctx.Done():
return
case ioStat2 := <-s.diskIO:
var ioList []model.MonitorIO
timeMilli := time.Now().UnixMilli()
for _, io2 := range ioStat2 {
for _, io1 := range ioStat {
if io2.Name == io1.Name {
var itemIO model.MonitorIO
itemIO.CreateTime = timeMilli
itemIO.NeType = "#"
itemIO.NeID = "#"
itemIO.Name = io1.Name
if io2.ReadBytes != 0 && io1.ReadBytes != 0 && io2.ReadBytes > io1.ReadBytes {
itemIO.Read = int64(float64(io2.ReadBytes-io1.ReadBytes) / interval / 60)
}
if io2.WriteBytes != 0 && io1.WriteBytes != 0 && io2.WriteBytes > io1.WriteBytes {
itemIO.Write = int64(float64(io2.WriteBytes-io1.WriteBytes) / interval / 60)
}
if io2.ReadCount != 0 && io1.ReadCount != 0 && io2.ReadCount > io1.ReadCount {
itemIO.Count = int64(float64(io2.ReadCount-io1.ReadCount) / interval / 60)
}
writeCount := int64(0)
if io2.WriteCount != 0 && io1.WriteCount != 0 && io2.WriteCount > io1.WriteCount {
writeCount = int64(float64(io2.WriteCount-io1.WriteCount) / interval * 60)
}
if writeCount > itemIO.Count {
itemIO.Count = writeCount
}
if io2.ReadTime != 0 && io1.ReadTime != 0 && io2.ReadTime > io1.ReadTime {
itemIO.Time = int64(float64(io2.ReadTime-io1.ReadTime) / interval / 60)
}
writeTime := int64(0)
if io2.WriteTime != 0 && io1.WriteTime != 0 && io2.WriteTime > io1.WriteTime {
writeTime = int64(float64(io2.WriteTime-io1.WriteTime) / interval / 60)
}
if writeTime > itemIO.Time {
itemIO.Time = writeTime
}
ioList = append(ioList, itemIO)
break
}
}
}
if err := s.monitorRepository.BatchCreateMonitorIO(ioList); err != nil {
logger.Errorf("BatchCreateMonitorIO err: %v", err)
}
s.diskIO <- ioStat2
}
}
}
}
func (s *Monitor) saveNetDataToDB(ctx context.Context, interval float64) {
defer close(s.netIO)
for {
select {
case <-ctx.Done():
return
case netStat := <-s.netIO:
select {
case <-ctx.Done():
return
case netStat2 := <-s.netIO:
var netList []model.MonitorNetwork
timeMilli := time.Now().UnixMilli()
for _, net2 := range netStat2 {
for _, net1 := range netStat {
if net2.Name == net1.Name {
var itemNet model.MonitorNetwork
itemNet.CreateTime = timeMilli
itemNet.NeType = "#"
itemNet.NeID = "#"
itemNet.Name = net1.Name
if net2.BytesSent != 0 && net1.BytesSent != 0 && net2.BytesSent > net1.BytesSent {
itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / interval / 60
}
if net2.BytesRecv != 0 && net1.BytesRecv != 0 && net2.BytesRecv > net1.BytesRecv {
itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / interval / 60
}
netList = append(netList, itemNet)
break
}
}
}
if err := s.monitorRepository.BatchCreateMonitorNet(netList); err != nil {
logger.Errorf("BatchCreateMonitorNet err: %v", err)
}
s.netIO <- netStat2
}
}
}
}
// SelectMonitorInfo 查询监控资源信息
func (s *Monitor) SelectMonitorInfo(query map[string]any) map[string]any {
infoType := query["type"]
startTimeMilli := query["startTime"]
endTimeMilli := query["endTime"]
neType := query["neType"]
neId := query["neId"]
name := query["name"]
// 返回数据
backDatas := map[string]any{}
// 基本信息
if infoType == "all" || infoType == "load" || infoType == "cpu" || infoType == "memory" {
rows := s.monitorRepository.SelectMonitorBase(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
})
backDatas["base"] = rows
}
// 磁盘IO
if infoType == "all" || infoType == "io" {
rows := s.monitorRepository.SelectMonitorIO(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
"name": name,
})
backDatas["io"] = rows
}
// 网络
if infoType == "all" || infoType == "network" {
rows := s.monitorRepository.SelectMonitorNetwork(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
"name": name,
})
backDatas["network"] = rows
}
return backDatas
}

271
src/modules/monitor/service/monitor.impl.go
View File

@@ -1,271 +0,0 @@
package service
import (
"context"
"strconv"
"time"
"be.ems/src/framework/logger"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
systemService "be.ems/src/modules/system/service"
"github.com/shirou/gopsutil/v3/cpu"
"github.com/shirou/gopsutil/v3/disk"
"github.com/shirou/gopsutil/v3/load"
"github.com/shirou/gopsutil/v3/mem"
"github.com/shirou/gopsutil/v3/net"
)
// 实例化服务层 MonitorImpl 结构体
var NewMonitorImpl = &MonitorImpl{
sysConfigService: systemService.NewSysConfigImpl,
monitorRepository: repository.NewMonitorImpl,
diskIO: make(chan []disk.IOCountersStat, 2),
netIO: make(chan []net.IOCountersStat, 2),
}
// MonitorImpl 服务器系统相关信息 服务层处理
type MonitorImpl struct {
// 参数配置服务
sysConfigService systemService.ISysConfig
// 监控服务资源数据信息
monitorRepository repository.IMonitor
// 磁盘网络IO 数据通道
diskIO chan ([]disk.IOCountersStat)
netIO chan ([]net.IOCountersStat)
}
// RunMonitor 执行资源监控
func (s *MonitorImpl) RunMonitor() {
var itemBase model.MonitorBase
itemBase.CreateTime = time.Now().UnixMilli()
itemBase.NeType = "#"
itemBase.NeID = "#"
totalPercent, _ := cpu.Percent(3*time.Second, false)
if len(totalPercent) == 1 {
itemBase.CPU = totalPercent[0]
}
cpuCount, _ := cpu.Counts(false)
loadInfo, _ := load.Avg()
itemBase.CPULoad1 = loadInfo.Load1
itemBase.CPULoad5 = loadInfo.Load5
itemBase.CPULoad15 = loadInfo.Load15
itemBase.LoadUsage = loadInfo.Load1 / (float64(cpuCount*2) * 0.75) * 100
memoryInfo, _ := mem.VirtualMemory()
itemBase.Memory = memoryInfo.UsedPercent
if err := s.monitorRepository.CreateMonitorBase(itemBase); err != nil {
logger.Errorf("CreateMonitorBase err: %v", err)
}
// 将当前资源发送到chan中处理保存
s.loadDiskIO()
s.loadNetIO()
// 监控系统资源-保留天数
storeDays := s.sysConfigService.SelectConfigValueByKey("monitor.sysResource.storeDays")
if storeDays != "" {
storeDays, _ := strconv.Atoi(storeDays)
ltTime := time.Now().AddDate(0, 0, -storeDays).UnixMilli()
_ = s.monitorRepository.DelMonitorBase(ltTime)
_ = s.monitorRepository.DelMonitorIO(ltTime)
_ = s.monitorRepository.DelMonitorNet(ltTime)
}
}
func (s *MonitorImpl) loadDiskIO() {
ioStat, _ := disk.IOCounters()
var diskIOList []disk.IOCountersStat
for _, io := range ioStat {
diskIOList = append(diskIOList, io)
}
s.diskIO <- diskIOList
}
func (s *MonitorImpl) loadNetIO() {
netStat, _ := net.IOCounters(true)
netStatAll, _ := net.IOCounters(false)
var netList []net.IOCountersStat
netList = append(netList, netStat...)
netList = append(netList, netStatAll...)
s.netIO <- netList
}
// monitorCancel 监控搜集IO/Network上下文
var monitorCancel context.CancelFunc
// RunMonitorDataCancel 启动资源监控数据存储io/network通道 移除之前的chan上下文后在设置新的均值
// interval 采集的平均值（分钟）
func (s *MonitorImpl) RunMonitorDataCancel(removeBefore bool, interval float64) {
// 是否取消之前的
if removeBefore {
monitorCancel()
}
// 上下文控制
ctx, cancel := context.WithCancel(context.Background())
monitorCancel = cancel
// chanl 通道进行存储数据
go s.saveIODataToDB(ctx, interval)
go s.saveNetDataToDB(ctx, interval)
}
func (s *MonitorImpl) saveIODataToDB(ctx context.Context, interval float64) {
defer close(s.diskIO)
for {
select {
case <-ctx.Done():
return
case ioStat := <-s.diskIO:
select {
case <-ctx.Done():
return
case ioStat2 := <-s.diskIO:
var ioList []model.MonitorIO
timeMilli := time.Now().UnixMilli()
for _, io2 := range ioStat2 {
for _, io1 := range ioStat {
if io2.Name == io1.Name {
var itemIO model.MonitorIO
itemIO.CreateTime = timeMilli
itemIO.NeType = "#"
itemIO.NeID = "#"
itemIO.Name = io1.Name
if io2.ReadBytes != 0 && io1.ReadBytes != 0 && io2.ReadBytes > io1.ReadBytes {
itemIO.Read = int64(float64(io2.ReadBytes-io1.ReadBytes) / interval / 60)
}
if io2.WriteBytes != 0 && io1.WriteBytes != 0 && io2.WriteBytes > io1.WriteBytes {
itemIO.Write = int64(float64(io2.WriteBytes-io1.WriteBytes) / interval / 60)
}
if io2.ReadCount != 0 && io1.ReadCount != 0 && io2.ReadCount > io1.ReadCount {
itemIO.Count = int64(float64(io2.ReadCount-io1.ReadCount) / interval / 60)
}
writeCount := int64(0)
if io2.WriteCount != 0 && io1.WriteCount != 0 && io2.WriteCount > io1.WriteCount {
writeCount = int64(float64(io2.WriteCount-io1.WriteCount) / interval * 60)
}
if writeCount > itemIO.Count {
itemIO.Count = writeCount
}
if io2.ReadTime != 0 && io1.ReadTime != 0 && io2.ReadTime > io1.ReadTime {
itemIO.Time = int64(float64(io2.ReadTime-io1.ReadTime) / interval / 60)
}
writeTime := int64(0)
if io2.WriteTime != 0 && io1.WriteTime != 0 && io2.WriteTime > io1.WriteTime {
writeTime = int64(float64(io2.WriteTime-io1.WriteTime) / interval / 60)
}
if writeTime > itemIO.Time {
itemIO.Time = writeTime
}
ioList = append(ioList, itemIO)
break
}
}
}
if err := s.monitorRepository.BatchCreateMonitorIO(ioList); err != nil {
logger.Errorf("BatchCreateMonitorIO err: %v", err)
}
s.diskIO <- ioStat2
}
}
}
}
func (s *MonitorImpl) saveNetDataToDB(ctx context.Context, interval float64) {
defer close(s.netIO)
for {
select {
case <-ctx.Done():
return
case netStat := <-s.netIO:
select {
case <-ctx.Done():
return
case netStat2 := <-s.netIO:
var netList []model.MonitorNetwork
timeMilli := time.Now().UnixMilli()
for _, net2 := range netStat2 {
for _, net1 := range netStat {
if net2.Name == net1.Name {
var itemNet model.MonitorNetwork
itemNet.CreateTime = timeMilli
itemNet.NeType = "#"
itemNet.NeID = "#"
itemNet.Name = net1.Name
if net2.BytesSent != 0 && net1.BytesSent != 0 && net2.BytesSent > net1.BytesSent {
itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / interval / 60
}
if net2.BytesRecv != 0 && net1.BytesRecv != 0 && net2.BytesRecv > net1.BytesRecv {
itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / interval / 60
}
netList = append(netList, itemNet)
break
}
}
}
if err := s.monitorRepository.BatchCreateMonitorNet(netList); err != nil {
logger.Errorf("BatchCreateMonitorNet err: %v", err)
}
s.netIO <- netStat2
}
}
}
}
// SelectMonitorInfo 查询监控资源信息
func (s *MonitorImpl) SelectMonitorInfo(query map[string]any) map[string]any {
infoType := query["type"]
startTimeMilli := query["startTime"]
endTimeMilli := query["endTime"]
neType := query["neType"]
neId := query["neId"]
name := query["name"]
// 返回数据
backDatas := map[string]any{}
// 基本信息
if infoType == "all" || infoType == "load" || infoType == "cpu" || infoType == "memory" {
rows := s.monitorRepository.SelectMonitorBase(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
})
backDatas["base"] = rows
}
// 磁盘IO
if infoType == "all" || infoType == "io" {
rows := s.monitorRepository.SelectMonitorIO(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
"name": name,
})
backDatas["io"] = rows
}
// 网络
if infoType == "all" || infoType == "network" {
rows := s.monitorRepository.SelectMonitorNetwork(map[string]any{
"startTime": startTimeMilli,
"endTime": endTimeMilli,
"neType": neType,
"neId": neId,
"name": name,
})
backDatas["network"] = rows
}
return backDatas
}

32
src/modules/monitor/service/monitor_test.go
View File

@@ -5,17 +5,13 @@ import (
"testing"
"time"
"github.com/shirou/gopsutil/v3/cpu"
"github.com/shirou/gopsutil/v3/disk"
"github.com/shirou/gopsutil/v3/load"
"github.com/shirou/gopsutil/v3/mem"
"github.com/shirou/gopsutil/v3/net"
"github.com/shirou/gopsutil/v4/cpu"
"github.com/shirou/gopsutil/v4/disk"
"github.com/shirou/gopsutil/v4/load"
"github.com/shirou/gopsutil/v4/mem"
"github.com/shirou/gopsutil/v4/net"
)
func init() {
}
func TestInfo(t *testing.T) {
s := MonitorInfo{}
s.load(0.5) // 0.5 半分钟
@@ -36,17 +32,21 @@ func (m *MonitorInfo) load(interval float64) {
var itemBase MonitorBase
itemBase.CreateTime = time.Now().UnixMilli()
totalPercent, _ := cpu.Percent(3*time.Second, false)
if len(totalPercent) == 1 {
itemBase.CPU = totalPercent[0]
}
cpuCount, _ := cpu.Counts(false)
loadInfo, _ := load.Avg()
itemBase.CPULoad1 = loadInfo.Load1
itemBase.CPULoad5 = loadInfo.Load5
itemBase.CPULoad15 = loadInfo.Load15
itemBase.LoadUsage = loadInfo.Load1 / (float64(cpuCount*2) * 0.75) * 100
totalPercent, _ := cpu.Percent(3*time.Second, false)
if len(totalPercent) > 0 {
itemBase.CPU = totalPercent[0]
}
cpuCount, _ := cpu.Counts(false)
cpuAvg := (float64(cpuCount*2) * 0.75) * 100
itemBase.LoadUsage = 0
if cpuAvg > 0 {
itemBase.LoadUsage = loadInfo.Load1 / cpuAvg
}
memoryInfo, _ := mem.VirtualMemory()
itemBase.Memory = memoryInfo.UsedPercent

190
src/modules/monitor/service/sys_job.go
View File

@@ -1,35 +1,169 @@
package service
import (
"fmt"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/cron"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
)
// ISysJob 调度任务信息 服务层接口
type ISysJob interface {
// SelectJobPage 分页查询调度任务集合
SelectJobPage(query map[string]any) map[string]any
// SelectJobList 查询调度任务集合
SelectJobList(sysJob model.SysJob) []model.SysJob
// SelectJobById 通过调度ID查询调度任务信息
SelectJobById(jobId string) model.SysJob
// CheckUniqueJobName 校验调度任务名称和组是否唯一
CheckUniqueJobName(jobName, jobGroup, jobId string) bool
// InsertJob 新增调度任务信息
InsertJob(sysJob model.SysJob) string
// UpdateJob 修改调度任务信息
UpdateJob(sysJob model.SysJob) int64
// DeleteJobByIds 批量删除调度任务信息
DeleteJobByIds(jobIds []string) (int64, error)
// RunQueueJob 立即运行一次调度任务
RunQueueJob(sysJob model.SysJob) bool
// ResetQueueJob 重置初始调度任务
ResetQueueJob()
// 实例化服务层 SysJob 结构体
var NewSysJob = &SysJob{
sysJobRepository: repository.NewSysJobImpl,
}
// SysJob 调度任务 服务层处理
type SysJob struct {
// 调度任务数据信息
sysJobRepository repository.ISysJob
}
// SelectJobPage 分页查询调度任务集合
func (r *SysJob) SelectJobPage(query map[string]any) map[string]any {
return r.sysJobRepository.SelectJobPage(query)
}
// SelectJobList 查询调度任务集合
func (r *SysJob) SelectJobList(sysJob model.SysJob) []model.SysJob {
return r.sysJobRepository.SelectJobList(sysJob)
}
// SelectJobById 通过调度ID查询调度任务信息
func (r *SysJob) SelectJobById(jobId string) model.SysJob {
if jobId == "" {
return model.SysJob{}
}
jobs := r.sysJobRepository.SelectJobByIds([]string{jobId})
if len(jobs) > 0 {
return jobs[0]
}
return model.SysJob{}
}
// CheckUniqueJobName 校验调度任务名称和组是否唯一
func (r *SysJob) CheckUniqueJobName(jobName, jobGroup, jobId string) bool {
uniqueId := r.sysJobRepository.CheckUniqueJob(model.SysJob{
JobName: jobName,
JobGroup: jobGroup,
})
if uniqueId == jobId {
return true
}
return uniqueId == ""
}
// InsertJob 新增调度任务信息
func (r *SysJob) InsertJob(sysJob model.SysJob) string {
insertId := r.sysJobRepository.InsertJob(sysJob)
if insertId == "" && sysJob.Status == common.STATUS_YES {
sysJob.JobID = insertId
r.insertQueueJob(sysJob, true)
}
return insertId
}
// UpdateJob 修改调度任务信息
func (r *SysJob) UpdateJob(sysJob model.SysJob) int64 {
rows := r.sysJobRepository.UpdateJob(sysJob)
if rows > 0 {
//状态正常添加队列任务
if sysJob.Status == common.STATUS_YES {
r.insertQueueJob(sysJob, true)
}
// 状态禁用删除队列任务
if sysJob.Status == common.STATUS_NO {
r.deleteQueueJob(sysJob)
}
}
return rows
}
// DeleteJobByIds 批量删除调度任务信息
func (r *SysJob) DeleteJobByIds(jobIds []string) (int64, error) {
// 检查是否存在
jobs := r.sysJobRepository.SelectJobByIds(jobIds)
if len(jobs) <= 0 {
// 没有可访问调度任务数据！
return 0, fmt.Errorf("there is no accessible scheduling task data")
}
if len(jobs) == len(jobIds) {
// 清除任务
for _, job := range jobs {
r.deleteQueueJob(job)
}
rows := r.sysJobRepository.DeleteJobByIds(jobIds)
return rows, nil
}
// 删除调度任务信息失败！
return 0, fmt.Errorf("failed to delete scheduling task information")
}
// ResetQueueJob 重置初始调度任务
func (r *SysJob) ResetQueueJob() {
// 获取注册的队列名称
queueNames := cron.QueueNames()
if len(queueNames) == 0 {
return
}
// 查询系统中定义状态为正常启用的任务
sysJobs := r.sysJobRepository.SelectJobList(model.SysJob{
Status: common.STATUS_YES,
})
for _, sysJob := range sysJobs {
for _, name := range queueNames {
if name == sysJob.InvokeTarget {
r.insertQueueJob(sysJob, true)
}
}
}
}
// RunQueueJob 立即运行一次调度任务
func (r *SysJob) RunQueueJob(sysJob model.SysJob) bool {
return r.insertQueueJob(sysJob, false)
}
// insertQueueJob 添加调度任务
func (r *SysJob) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
return false
}
// 给执行任务数据参数
options := cron.JobData{
Repeat: repeat,
SysJob: sysJob,
}
// 不是重复任务的情况，立即执行一次
if !repeat {
// 执行单次任务
status := queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
})
// 执行中或等待中的都返回正常
return status == cron.Active || status == cron.Waiting
}
// 执行重复任务
queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
Cron: sysJob.CronExpression,
})
return true
}
// deleteQueueJob 删除调度任务
func (r *SysJob) deleteQueueJob(sysJob model.SysJob) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
return false
}
return queue.RemoveJob(sysJob.JobID)
}

169
src/modules/monitor/service/sys_job.impl.go
View File

@@ -1,169 +0,0 @@
package service
import (
"fmt"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/cron"
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
)
// 实例化服务层 SysJobImpl 结构体
var NewSysJobImpl = &SysJobImpl{
sysJobRepository: repository.NewSysJobImpl,
}
// SysJobImpl 调度任务 服务层处理
type SysJobImpl struct {
// 调度任务数据信息
sysJobRepository repository.ISysJob
}
// SelectJobPage 分页查询调度任务集合
func (r *SysJobImpl) SelectJobPage(query map[string]any) map[string]any {
return r.sysJobRepository.SelectJobPage(query)
}
// SelectJobList 查询调度任务集合
func (r *SysJobImpl) SelectJobList(sysJob model.SysJob) []model.SysJob {
return r.sysJobRepository.SelectJobList(sysJob)
}
// SelectJobById 通过调度ID查询调度任务信息
func (r *SysJobImpl) SelectJobById(jobId string) model.SysJob {
if jobId == "" {
return model.SysJob{}
}
jobs := r.sysJobRepository.SelectJobByIds([]string{jobId})
if len(jobs) > 0 {
return jobs[0]
}
return model.SysJob{}
}
// CheckUniqueJobName 校验调度任务名称和组是否唯一
func (r *SysJobImpl) CheckUniqueJobName(jobName, jobGroup, jobId string) bool {
uniqueId := r.sysJobRepository.CheckUniqueJob(model.SysJob{
JobName: jobName,
JobGroup: jobGroup,
})
if uniqueId == jobId {
return true
}
return uniqueId == ""
}
// InsertJob 新增调度任务信息
func (r *SysJobImpl) InsertJob(sysJob model.SysJob) string {
insertId := r.sysJobRepository.InsertJob(sysJob)
if insertId == "" && sysJob.Status == common.STATUS_YES {
sysJob.JobID = insertId
r.insertQueueJob(sysJob, true)
}
return insertId
}
// UpdateJob 修改调度任务信息
func (r *SysJobImpl) UpdateJob(sysJob model.SysJob) int64 {
rows := r.sysJobRepository.UpdateJob(sysJob)
if rows > 0 {
//状态正常添加队列任务
if sysJob.Status == common.STATUS_YES {
r.insertQueueJob(sysJob, true)
}
// 状态禁用删除队列任务
if sysJob.Status == common.STATUS_NO {
r.deleteQueueJob(sysJob)
}
}
return rows
}
// DeleteJobByIds 批量删除调度任务信息
func (r *SysJobImpl) DeleteJobByIds(jobIds []string) (int64, error) {
// 检查是否存在
jobs := r.sysJobRepository.SelectJobByIds(jobIds)
if len(jobs) <= 0 {
// 没有可访问调度任务数据！
return 0, fmt.Errorf("there is no accessible scheduling task data")
}
if len(jobs) == len(jobIds) {
// 清除任务
for _, job := range jobs {
r.deleteQueueJob(job)
}
rows := r.sysJobRepository.DeleteJobByIds(jobIds)
return rows, nil
}
// 删除调度任务信息失败！
return 0, fmt.Errorf("failed to delete scheduling task information")
}
// ResetQueueJob 重置初始调度任务
func (r *SysJobImpl) ResetQueueJob() {
// 获取注册的队列名称
queueNames := cron.QueueNames()
if len(queueNames) == 0 {
return
}
// 查询系统中定义状态为正常启用的任务
sysJobs := r.sysJobRepository.SelectJobList(model.SysJob{
Status: common.STATUS_YES,
})
for _, sysJob := range sysJobs {
for _, name := range queueNames {
if name == sysJob.InvokeTarget {
r.insertQueueJob(sysJob, true)
}
}
}
}
// RunQueueJob 立即运行一次调度任务
func (r *SysJobImpl) RunQueueJob(sysJob model.SysJob) bool {
return r.insertQueueJob(sysJob, false)
}
// insertQueueJob 添加调度任务
func (r *SysJobImpl) insertQueueJob(sysJob model.SysJob, repeat bool) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
return false
}
// 给执行任务数据参数
options := cron.JobData{
Repeat: repeat,
SysJob: sysJob,
}
// 不是重复任务的情况，立即执行一次
if !repeat {
// 执行单次任务
status := queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
})
// 执行中或等待中的都返回正常
return status == cron.Active || status == cron.Waiting
}
// 执行重复任务
queue.RunJob(options, cron.JobOptions{
JobId: sysJob.JobID,
Cron: sysJob.CronExpression,
})
return true
}
// deleteQueueJob 删除调度任务
func (r *SysJobImpl) deleteQueueJob(sysJob model.SysJob) bool {
// 获取队列 Processor
queue := cron.GetQueue(sysJob.InvokeTarget)
if queue.Name != sysJob.InvokeTarget {
return false
}
return queue.RemoveJob(sysJob.JobID)
}

51
src/modules/monitor/service/sys_job_log.go
View File

@@ -2,22 +2,41 @@ package service
import (
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
)
// ISysJobLog 调度任务日志 服务层接口
type ISysJobLog interface {
// SelectJobLogPage 分页查询调度任务日志集合
SelectJobLogPage(query map[string]any) map[string]any
// SelectJobLogList 查询调度任务日志集合
SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog
// SelectJobLogById 通过调度ID查询调度任务日志信息
SelectJobLogById(jobLogId string) model.SysJobLog
// DeleteJobLogByIds 批量删除调度任务日志信息
DeleteJobLogByIds(jobLogIds []string) int64
// CleanJobLog 清空调度任务日志
CleanJobLog() error
// 实例化服务层 SysJobLog 结构体
var NewSysJobLog = &SysJobLog{
sysJobLogRepository: repository.NewSysJobLogImpl,
}
// SysJobLog 调度任务日志 服务层处理
type SysJobLog struct {
// 调度任务日志数据信息
sysJobLogRepository repository.ISysJobLog
}
// SelectJobLogPage 分页查询调度任务日志集合
func (s *SysJobLog) SelectJobLogPage(query map[string]any) map[string]any {
return s.sysJobLogRepository.SelectJobLogPage(query)
}
// SelectJobLogList 查询调度任务日志集合
func (s *SysJobLog) SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogList(sysJobLog)
}
// SelectJobLogById 通过调度ID查询调度任务日志信息
func (s *SysJobLog) SelectJobLogById(jobLogId string) model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogById(jobLogId)
}
// DeleteJobLogByIds 批量删除调度任务日志信息
func (s *SysJobLog) DeleteJobLogByIds(jobLogIds []string) int64 {
return s.sysJobLogRepository.DeleteJobLogByIds(jobLogIds)
}
// CleanJobLog 清空调度任务日志
func (s *SysJobLog) CleanJobLog() error {
return s.sysJobLogRepository.CleanJobLog()
}

42
src/modules/monitor/service/sys_job_log.impl.go
View File

@@ -1,42 +0,0 @@
package service
import (
"be.ems/src/modules/monitor/model"
"be.ems/src/modules/monitor/repository"
)
// 实例化服务层 SysJobLogImpl 结构体
var NewSysJobLogImpl = &SysJobLogImpl{
sysJobLogRepository: repository.NewSysJobLogImpl,
}
// SysJobLogImpl 调度任务日志 服务层处理
type SysJobLogImpl struct {
// 调度任务日志数据信息
sysJobLogRepository repository.ISysJobLog
}
// SelectJobLogPage 分页查询调度任务日志集合
func (s *SysJobLogImpl) SelectJobLogPage(query map[string]any) map[string]any {
return s.sysJobLogRepository.SelectJobLogPage(query)
}
// SelectJobLogList 查询调度任务日志集合
func (s *SysJobLogImpl) SelectJobLogList(sysJobLog model.SysJobLog) []model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogList(sysJobLog)
}
// SelectJobLogById 通过调度ID查询调度任务日志信息
func (s *SysJobLogImpl) SelectJobLogById(jobLogId string) model.SysJobLog {
return s.sysJobLogRepository.SelectJobLogById(jobLogId)
}
// DeleteJobLogByIds 批量删除调度任务日志信息
func (s *SysJobLogImpl) DeleteJobLogByIds(jobLogIds []string) int64 {
return s.sysJobLogRepository.DeleteJobLogByIds(jobLogIds)
}
// CleanJobLog 清空调度任务日志
func (s *SysJobLogImpl) CleanJobLog() error {
return s.sysJobLogRepository.CleanJobLog()
}

29
src/modules/monitor/service/sys_user_online.go
View File

@@ -5,8 +5,29 @@ import (
"be.ems/src/modules/monitor/model"
)
// ISysUserOnline 在线用户 服务层接口
type ISysUserOnline interface {
// LoginUserToUserOnline 设置在线用户信息
LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline
// 实例化服务层 SysUserOnline 结构体
var NewSysUserOnline = &SysUserOnline{}
// SysUserOnline 在线用户 服务层处理
type SysUserOnline struct{}
// LoginUserToUserOnline 设置在线用户信息
func (r *SysUserOnline) LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline {
if loginUser.UserID == "" {
return model.SysUserOnline{}
}
sysUserOnline := model.SysUserOnline{
TokenID: loginUser.UUID,
UserName: loginUser.User.UserName,
IPAddr: loginUser.IPAddr,
LoginLocation: loginUser.LoginLocation,
Browser: loginUser.Browser,
OS: loginUser.OS,
LoginTime: loginUser.LoginTime,
}
if loginUser.User.DeptID != "" {
sysUserOnline.DeptName = loginUser.User.Dept.DeptName
}
return sysUserOnline
}

33
src/modules/monitor/service/sys_user_online.impl.go
View File

@@ -1,33 +0,0 @@
package service
import (
"be.ems/src/framework/vo"
"be.ems/src/modules/monitor/model"
)
// 实例化服务层 SysUserOnlineImpl 结构体
var NewSysUserOnlineImpl = &SysUserOnlineImpl{}
// SysUserOnlineImpl 在线用户 服务层处理
type SysUserOnlineImpl struct{}
// LoginUserToUserOnline 设置在线用户信息
func (r *SysUserOnlineImpl) LoginUserToUserOnline(loginUser vo.LoginUser) model.SysUserOnline {
if loginUser.UserID == "" {
return model.SysUserOnline{}
}
sysUserOnline := model.SysUserOnline{
TokenID: loginUser.UUID,
UserName: loginUser.User.UserName,
IPAddr: loginUser.IPAddr,
LoginLocation: loginUser.LoginLocation,
Browser: loginUser.Browser,
OS: loginUser.OS,
LoginTime: loginUser.LoginTime,
}
if loginUser.User.DeptID != "" {
sysUserOnline.DeptName = loginUser.User.Dept.DeptName
}
return sysUserOnline
}

183
src/modules/monitor/service/system_info.go
View File

@@ -1,22 +1,177 @@
package service
// ISystemInfo 服务器系统相关信息 服务层接口
type ISystemInfo interface {
// SystemInfo 系统信息
SystemInfo() map[string]any
import (
"context"
"fmt"
"os"
"runtime"
"strings"
"time"
// TimeInfo 系统时间信息
TimeInfo() map[string]string
"be.ems/src/framework/config"
"be.ems/src/framework/utils/parse"
// MemoryInfo 内存信息
MemoryInfo() map[string]any
"github.com/shirou/gopsutil/v4/cpu"
"github.com/shirou/gopsutil/v4/disk"
"github.com/shirou/gopsutil/v4/host"
"github.com/shirou/gopsutil/v4/mem"
"github.com/shirou/gopsutil/v4/net"
)
// CPUInfo CPU信息
CPUInfo() map[string]any
// 实例化服务层 SystemInfo 结构体
var NewSystemInfo = &SystemInfo{}
// NetworkInfo 网络信息
NetworkInfo() map[string]string
// SystemInfo 服务器系统相关信息 服务层处理
type SystemInfo struct{}
// DiskInfo 磁盘信息
DiskInfo() []map[string]string
// SystemInfo 系统信息
func (s *SystemInfo) SystemInfo() map[string]any {
info, err := host.Info()
if err != nil {
info.Platform = err.Error()
}
// 获取主机运行时间
bootTime := time.Since(time.Unix(int64(info.BootTime), 0)).Seconds()
// 获取程序运行时间
runTime := time.Since(config.RunTime()).Abs().Seconds()
return map[string]any{
"platform": info.Platform,
"platformVersion": info.PlatformVersion,
"arch": info.KernelArch,
"archVersion": info.KernelVersion,
"os": info.OS,
"hostname": info.Hostname,
"bootTime": int64(bootTime),
"processId": os.Getpid(),
"runArch": runtime.GOARCH,
"runVersion": runtime.Version(),
"runTime": int64(runTime),
}
}
// TimeInfo 系统时间信息
func (s *SystemInfo) TimeInfo() map[string]string {
now := time.Now()
// 获取当前时间
current := now.Format("2006-01-02 15:04:05")
// 获取时区
timezone := now.Format("-0700 MST")
// 获取时区名称
timezoneName := now.Format("MST")
return map[string]string{
"current": current,
"timezone": timezone,
"timezoneName": timezoneName,
}
}
// MemoryInfo 内存信息
func (s *SystemInfo) MemoryInfo() map[string]any {
memInfo, err := mem.VirtualMemory()
if err != nil {
memInfo.UsedPercent = 0
memInfo.Available = 0
memInfo.Total = 0
}
var memStats runtime.MemStats
runtime.ReadMemStats(&memStats)
return map[string]any{
"usage": fmt.Sprintf("%.2f", memInfo.UsedPercent), // 内存利用率
"freemem": parse.Bit(float64(memInfo.Available)), // 可用内存大小（GB）
"totalmem": parse.Bit(float64(memInfo.Total)), // 总内存大小（GB）
"rss": parse.Bit(float64(memStats.Sys)), // 常驻内存大小（RSS）
"heapTotal": parse.Bit(float64(memStats.HeapSys)), // 堆总大小
"heapUsed": parse.Bit(float64(memStats.HeapAlloc)), // 堆已使用大小
"external": parse.Bit(float64(memStats.Sys - memStats.HeapSys)), // 外部内存大小（非堆）
}
}
// CPUInfo CPU信息
func (s *SystemInfo) CPUInfo() map[string]any {
var core int = 0
var speed string = "未知"
var model string = "未知"
cpuInfo, err := cpu.Info()
if err == nil {
core = runtime.NumCPU()
speed = fmt.Sprintf("%.0fMHz", cpuInfo[0].Mhz)
model = strings.TrimSpace(cpuInfo[0].ModelName)
}
useds := []string{}
cpuPercent, err := cpu.Percent(0, true)
if err == nil {
for _, v := range cpuPercent {
useds = append(useds, fmt.Sprintf("%.2f", v))
}
}
return map[string]any{
"model": model,
"speed": speed,
"core": core,
"coreUsed": useds,
}
}
// NetworkInfo 网络信息
func (s *SystemInfo) NetworkInfo() map[string]string {
ipAddrs := make(map[string]string)
interfaces, err := net.Interfaces()
if err == nil {
for _, iface := range interfaces {
name := iface.Name
if name[len(name)-1] == '0' {
name = name[0 : len(name)-1]
name = strings.Trim(name, "")
}
// ignore localhost
if name == "lo" {
continue
}
var addrs []string
for _, v := range iface.Addrs {
prefix := strings.Split(v.Addr, "/")[0]
if strings.Contains(prefix, "::") {
addrs = append(addrs, fmt.Sprintf("IPv6 %s", prefix))
}
if strings.Contains(prefix, ".") {
addrs = append(addrs, fmt.Sprintf("IPv4 %s", prefix))
}
}
ipAddrs[name] = strings.Join(addrs, " / ")
}
}
return ipAddrs
}
// DiskInfo 磁盘信息
func (s *SystemInfo) DiskInfo() []map[string]string {
disks := make([]map[string]string, 0)
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
partitions, err := disk.PartitionsWithContext(ctx, false)
if err != nil && err != context.DeadlineExceeded {
return disks
}
for _, partition := range partitions {
usage, err := disk.Usage(partition.Mountpoint)
if err != nil {
continue
}
disks = append(disks, map[string]string{
"size": parse.Bit(float64(usage.Total)),
"used": parse.Bit(float64(usage.Used)),
"avail": parse.Bit(float64(usage.Free)),
"pcent": fmt.Sprintf("%.1f%%", usage.UsedPercent),
"target": partition.Device,
})
}
return disks
}

173
src/modules/monitor/service/system_info.impl.go
View File

@@ -1,173 +0,0 @@
package service
import (
"fmt"
"os"
"runtime"
"strings"
"time"
"be.ems/src/framework/config"
"be.ems/src/framework/utils/parse"
"github.com/shirou/gopsutil/v3/cpu"
"github.com/shirou/gopsutil/v3/disk"
"github.com/shirou/gopsutil/v3/host"
"github.com/shirou/gopsutil/v3/mem"
"github.com/shirou/gopsutil/v3/net"
)
// 实例化服务层 SystemInfoImpl 结构体
var NewSystemInfoImpl = &SystemInfoImpl{}
// SystemInfoImpl 服务器系统相关信息 服务层处理
type SystemInfoImpl struct{}
// SystemInfo 系统信息
func (s *SystemInfoImpl) SystemInfo() map[string]any {
info, err := host.Info()
if err != nil {
info.Platform = err.Error()
}
// 获取主机运行时间
bootTime := time.Since(time.Unix(int64(info.BootTime), 0)).Seconds()
// 获取程序运行时间
runTime := time.Since(config.RunTime()).Abs().Seconds()
return map[string]any{
"platform": info.Platform,
"platformVersion": info.PlatformVersion,
"arch": info.KernelArch,
"archVersion": info.KernelVersion,
"os": info.OS,
"hostname": info.Hostname,
"bootTime": int64(bootTime),
"processId": os.Getpid(),
"runArch": runtime.GOARCH,
"runVersion": runtime.Version(),
"runTime": int64(runTime),
}
}
// TimeInfo 系统时间信息
func (s *SystemInfoImpl) TimeInfo() map[string]string {
now := time.Now()
// 获取当前时间
current := now.Format("2006-01-02 15:04:05")
// 获取时区
timezone := now.Format("-0700 MST")
// 获取时区名称
timezoneName := now.Format("MST")
return map[string]string{
"current": current,
"timezone": timezone,
"timezoneName": timezoneName,
}
}
// MemoryInfo 内存信息
func (s *SystemInfoImpl) MemoryInfo() map[string]any {
memInfo, err := mem.VirtualMemory()
if err != nil {
memInfo.UsedPercent = 0
memInfo.Available = 0
memInfo.Total = 0
}
var memStats runtime.MemStats
runtime.ReadMemStats(&memStats)
return map[string]any{
"usage": fmt.Sprintf("%.2f", memInfo.UsedPercent), // 内存利用率
"freemem": parse.Bit(float64(memInfo.Available)), // 可用内存大小（GB）
"totalmem": parse.Bit(float64(memInfo.Total)), // 总内存大小（GB）
"rss": parse.Bit(float64(memStats.Sys)), // 常驻内存大小（RSS）
"heapTotal": parse.Bit(float64(memStats.HeapSys)), // 堆总大小
"heapUsed": parse.Bit(float64(memStats.HeapAlloc)), // 堆已使用大小
"external": parse.Bit(float64(memStats.Sys - memStats.HeapSys)), // 外部内存大小（非堆）
}
}
// CPUInfo CPU信息
func (s *SystemInfoImpl) CPUInfo() map[string]any {
var core int = 0
var speed string = "未知"
var model string = "未知"
cpuInfo, err := cpu.Info()
if err == nil {
core = runtime.NumCPU()
speed = fmt.Sprintf("%.0fMHz", cpuInfo[0].Mhz)
model = strings.TrimSpace(cpuInfo[0].ModelName)
}
useds := []string{}
cpuPercent, err := cpu.Percent(0, true)
if err == nil {
for _, v := range cpuPercent {
useds = append(useds, fmt.Sprintf("%.2f", v))
}
}
return map[string]any{
"model": model,
"speed": speed,
"core": core,
"coreUsed": useds,
}
}
// NetworkInfo 网络信息
func (s *SystemInfoImpl) NetworkInfo() map[string]string {
ipAddrs := make(map[string]string)
interfaces, err := net.Interfaces()
if err == nil {
for _, iface := range interfaces {
name := iface.Name
if name[len(name)-1] == '0' {
name = name[0 : len(name)-1]
name = strings.Trim(name, "")
}
// ignore localhost
if name == "lo" {
continue
}
var addrs []string
for _, v := range iface.Addrs {
prefix := strings.Split(v.Addr, "/")[0]
if strings.Contains(prefix, "::") {
addrs = append(addrs, fmt.Sprintf("IPv6 %s", prefix))
}
if strings.Contains(prefix, ".") {
addrs = append(addrs, fmt.Sprintf("IPv4 %s", prefix))
}
}
ipAddrs[name] = strings.Join(addrs, " / ")
}
}
return ipAddrs
}
// DiskInfo 磁盘信息
func (s *SystemInfoImpl) DiskInfo() []map[string]string {
disks := make([]map[string]string, 0)
partitions, err := disk.Partitions(false)
if err != nil {
return disks
}
for _, partition := range partitions {
usage, err := disk.Usage(partition.Mountpoint)
if err != nil {
continue
}
disks = append(disks, map[string]string{
"size": parse.Bit(float64(usage.Total)),
"used": parse.Bit(float64(usage.Used)),
"avail": parse.Bit(float64(usage.Free)),
"pcent": fmt.Sprintf("%.1f%%", usage.UsedPercent),
"target": partition.Device,
})
}
return disks
}