Hass/Message-Push-Nest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: update startup tasks

Browse Source
This commit is contained in:
engigu
2025-12-09 21:44:14 +08:00
parent 0a70c15e5e
commit 2125ddc853
18 changed files with 655 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files
service/cron_msg_service/startup_cron_msg.go
+5 -3
View File
@@ -2,12 +2,13 @@ package cron_msg_service
import (
"fmt"
"strings"
"github.com/sirupsen/logrus"
"message-nest/models"
"message-nest/pkg/constant"
"message-nest/service/cron_service"
"message-nest/service/send_message_service"
"strings"
"github.com/sirupsen/logrus"
)
type MsgCronTask struct {
@@ -62,6 +63,7 @@ func CronMsgSendF(msg models.CronMessages) {
}
sender := send_message_service.SendMessageService{
TaskID: task.ID,
SendMode: "task",
Title: msg.Title,
Text: msg.Content,
URL: msg.Url,
@@ -104,7 +106,7 @@ func RemoveCronMsgToCronServer(msg models.CronMessages) {
}
// StartUpMsgCronTask 启动注册定时任务
func StartUpMsgCronTask() {
func StartUpUserSetupMsgCronTask() {
MsgCronTask{}.Register()
}
service/cron_service/cron_service.go
-86
View File
@@ -1,86 +0,0 @@
package cron_service
import (
"fmt"
"github.com/robfig/cron/v3"
"github.com/sirupsen/logrus"
"github.com/unknwon/com"
"message-nest/models"
"message-nest/pkg/constant"
"message-nest/service/send_message_service"
)
var ClearLogsTaskId cron.EntryID
// ClearLogs 清除日志的定时任务
func ClearLogs() {
var errStr string
sm := send_message_service.SendMessageService{
TaskID: constant.CleanLogsTaskId,
DefaultLogger: logrus.WithFields(logrus.Fields{
"prefix": "[Cron Clear Logs]",
}),
}
sm.Status = send_message_service.SendSuccess
sm.LogsAndStatusMark("开始清除日志", sm.Status)
setting, err := models.GetSettingByKey(constant.LogsCleanSectionName, constant.LogsCleanKeepKeyName)
if err != nil {
errStr = fmt.Sprintf("获取日志的保留数失败，原因：%s", err)
sm.LogsAndStatusMark(errStr, send_message_service.SendFail)
}
keepNum := com.StrTo(setting.Value).MustInt()
affectedRows, err := models.DeleteOutDateLogs(keepNum)
if err != nil {
errStr = fmt.Sprintf("删除日志失败，原因：%s", err)
sm.LogsAndStatusMark(errStr, send_message_service.SendFail)
} else {
errStr = fmt.Sprintf("删除日志成功，删除条数：%d，保留数目：%d", affectedRows, keepNum)
sm.LogsAndStatusMark(errStr, sm.Status)
}
sm.RecordSendLog()
}
type CronService struct {
}
// StartLogsCronRun 启动注册清除任务定时任务
func (cs *CronService) StartLogsCronRun() {
// 注册任务
setting, err := models.GetSettingByKey(constant.LogsCleanSectionName, constant.LogsCleanCronKeyName)
if err != nil {
logrus.Error(fmt.Sprintf("获取日志的cron失败，原因：%s", err))
}
ClearLogsTaskId = AddTask(ScheduledTask{
Schedule: setting.Value,
Job: ClearLogs,
})
// 添加任务
err = models.AddSendTaskWithID("日志定时清除", constant.CleanLogsTaskId, "admin")
if err != nil {
logrus.Error(fmt.Sprintf("添加日志定时清除任务失败，原因：%s", err))
}
}
// UpdateLogsCronRun 更新清除任务定时任务
func (cs *CronService) UpdateLogsCronRun(cron string) {
RemoveTask(ClearLogsTaskId)
ClearLogsTaskId = AddTask(ScheduledTask{
Schedule: cron,
Job: ClearLogs,
})
logrus.Error(fmt.Sprintf("更新日志的cron成功，%s", cron))
logrus.Error(fmt.Sprintf("所有的定时任务： %s", TaskList))
}
// StartLogsCronRun 启动的时候开启定时任务
func StartLogsCronRun() {
logrus.Infof("开始注册定时清除日志任务...")
cs := CronService{}
cs.StartLogsCronRun()
}
service/cron_service/startup_tasks.go
+207
View File
@@ -0,0 +1,207 @@
package cron_service
import (
"fmt"
"message-nest/models"
"message-nest/pkg/constant"
"message-nest/service/send_message_service"
"github.com/robfig/cron/v3"
"github.com/sirupsen/logrus"
"github.com/unknwon/com"
)
var ClearLogsTaskId cron.EntryID
var ClearHostedMsgTaskId cron.EntryID
// CleanConfig 清理任务配置
type CleanConfig struct {
TaskID string
TaskName string
LogPrefix string
SectionName string
EnabledKey string
KeepNumKey string
DeleteFunc func(int) (int, error)
ResourceName string // 资源名称，如"日志"、"托管消息"
}
// executeCleanTask 执行清理任务的通用逻辑
func executeCleanTask(config CleanConfig) {
var errStr string
sm := send_message_service.SendMessageService{
TaskID: config.TaskID,
Name: config.TaskName,
DefaultLogger: logrus.WithFields(logrus.Fields{
"prefix": config.LogPrefix,
}),
}
sm.Status = send_message_service.SendSuccess
// 检查是否启用
enabledSetting, err := models.GetSettingByKey(config.SectionName, config.EnabledKey)
if err != nil {
errStr = fmt.Sprintf("获取%s清理开关失败，原因：%s", config.ResourceName, err)
sm.LogsAndStatusMark(errStr, send_message_service.SendFail)
sm.RecordSendLog()
return
}
if enabledSetting.Value != "true" {
sm.LogsAndStatusMark(fmt.Sprintf("%s清理功能未启用，跳过执行", config.ResourceName), sm.Status)
sm.RecordSendLog()
return
}
sm.LogsAndStatusMark(fmt.Sprintf("开始清除%s", config.ResourceName), sm.Status)
setting, err := models.GetSettingByKey(config.SectionName, config.KeepNumKey)
if err != nil {
errStr = fmt.Sprintf("获取%s的保留数失败，原因：%s", config.ResourceName, err)
sm.LogsAndStatusMark(errStr, send_message_service.SendFail)
}
keepNum := com.StrTo(setting.Value).MustInt()
affectedRows, err := config.DeleteFunc(keepNum)
if err != nil {
errStr = fmt.Sprintf("删除%s失败，原因：%s", config.ResourceName, err)
sm.LogsAndStatusMark(errStr, send_message_service.SendFail)
} else {
errStr = fmt.Sprintf("删除%s成功，删除条数：%d，保留数目：%d", config.ResourceName, affectedRows, keepNum)
sm.LogsAndStatusMark(errStr, sm.Status)
}
sm.RecordSendLog()
}
// ClearLogs 清除日志的定时任务
func ClearLogs() {
executeCleanTask(CleanConfig{
TaskID: constant.CleanLogsTaskId,
TaskName: "日志定时清除",
LogPrefix: "[Cron Clear Logs]",
SectionName: constant.LogsCleanSectionName,
EnabledKey: constant.LogsCleanEnabledKeyName,
KeepNumKey: constant.LogsCleanKeepKeyName,
DeleteFunc: models.DeleteOutDateLogs,
ResourceName: "日志",
})
}
type CronService struct {
}
// startCleanCronTask 启动清理任务的通用逻辑
func startCleanCronTask(sectionName, enabledKey, cronKey, resourceName string, job func(), taskId *cron.EntryID) {
// 检查是否启用
enabledSetting, err := models.GetSettingByKey(sectionName, enabledKey)
if err != nil {
logrus.Error(fmt.Sprintf("获取[%s]清理开关失败，原因：%s", resourceName, err))
return
}
if enabledSetting.Value != "true" {
logrus.Info(fmt.Sprintf("[%s]清理功能未启用", resourceName))
return
}
// 注册任务
setting, err := models.GetSettingByKey(sectionName, cronKey)
if err != nil {
logrus.Error(fmt.Sprintf("获取[%s]的cron失败，原因：%s", resourceName, err))
return
}
*taskId = AddTask(ScheduledTask{
Schedule: setting.Value,
Job: job,
})
logrus.Info(fmt.Sprintf("[%s]清理任务已启动", resourceName))
}
// updateCleanCronTask 更新清理任务的通用逻辑
func updateCleanCronTask(cron string, enabled bool, resourceName string, job func(), taskId *cron.EntryID) {
// 先移除旧任务
if *taskId > 0 {
RemoveTask(*taskId)
*taskId = 0
}
// 如果启用，则添加新任务
if enabled {
*taskId = AddTask(ScheduledTask{
Schedule: cron,
Job: job,
})
logrus.Info(fmt.Sprintf("更新%s的cron成功，%s", resourceName, cron))
} else {
logrus.Info(fmt.Sprintf("%s清理任务已停止", resourceName))
}
logrus.Info(fmt.Sprintf("所有的定时任务总数： %d", len(TaskList)))
}
// StartLogsCronRun 启动注册清除任务定时任务
func (cs *CronService) StartLogsCronRun() {
startCleanCronTask(
constant.LogsCleanSectionName,
constant.LogsCleanEnabledKeyName,
constant.LogsCleanCronKeyName,
"日志",
ClearLogs,
&ClearLogsTaskId,
)
}
// UpdateLogsCronRun 更新清除任务定时任务
func (cs *CronService) UpdateLogsCronRun(cron string, enabled bool) {
updateCleanCronTask(cron, enabled, "日志", ClearLogs, &ClearLogsTaskId)
}
// ClearHostedMessages 清除托管消息的定时任务
func ClearHostedMessages() {
executeCleanTask(CleanConfig{
TaskID: constant.CleanHostedMsgTaskId,
TaskName: "托管消息定时清除",
LogPrefix: "[Cron Clear Hosted Messages]",
SectionName: constant.HostedMsgCleanSectionName,
EnabledKey: constant.HostedMsgCleanEnabledKeyName,
KeepNumKey: constant.HostedMsgCleanKeepKeyName,
DeleteFunc: models.DeleteOutDateHostedMessages,
ResourceName: "托管消息",
})
}
// StartHostedMsgCronRun 启动注册托管消息清除任务定时任务
func (cs *CronService) StartHostedMsgCronRun() {
startCleanCronTask(
constant.HostedMsgCleanSectionName,
constant.HostedMsgCleanEnabledKeyName,
constant.HostedMsgCleanCronKeyName,
"托管消息",
ClearHostedMessages,
&ClearHostedMsgTaskId,
)
}
// UpdateHostedMsgCronRun 更新托管消息清除任务定时任务
func (cs *CronService) UpdateHostedMsgCronRun(cron string, enabled bool) {
updateCleanCronTask(cron, enabled, "托管消息", ClearHostedMessages, &ClearHostedMsgTaskId)
}
// StartLogsCronRunOnStartup 启动的时候开启定时任务
func StartLogsCronRunOnStartup() {
logrus.Infof("开始注册定时清除日志任务...")
cs := CronService{}
cs.StartLogsCronRun()
}
// StartHostedMsgCronRunOnStartup 启动的时候开启托管消息清理定时任务
func StartHostedMsgCronRunOnStartup() {
logrus.Infof("开始注册定时清除托管消息任务...")
cs := CronService{}
cs.StartHostedMsgCronRun()
}
func StartTasksRunOnStartup() {
StartLogsCronRunOnStartup()
StartHostedMsgCronRunOnStartup()
}
service/settings_service/init_site.go
+8
View File
@@ -41,3 +41,11 @@ func (es *InitSettingService) InitLogConfig() {
es.CommonAddSetting(section, key, value)
}
}
// InitHostedMsgConfig 初始化托管消息清理设置
func (es *InitSettingService) InitHostedMsgConfig() {
section := constant.HostedMsgCleanSectionName
for key, value := range constant.HostedMsgCleanDefaultValueMap {
es.CommonAddSetting(section, key, value)
}
}
service/settings_service/settings.go
+39 -3
View File
@@ -93,9 +93,25 @@ func (us *UserSettings) EditSettings(section string, key string, value string, c
data["value"] = value
data["modified_by"] = currentUser
err := models.EditSetting(setting.ID, data)
if key == constant.LogsCleanCronKeyName {
cronService := cron_service.CronService{}
cronService.UpdateLogsCronRun(value)
// 更新日志清理配置
if section == constant.LogsCleanSectionName {
if key == constant.LogsCleanCronKeyName || key == constant.LogsCleanEnabledKeyName {
cronService := cron_service.CronService{}
// 获取最新的cron和enabled值
cronSetting, _ := models.GetSettingByKey(constant.LogsCleanSectionName, constant.LogsCleanCronKeyName)
enabledSetting, _ := models.GetSettingByKey(constant.LogsCleanSectionName, constant.LogsCleanEnabledKeyName)
cronService.UpdateLogsCronRun(cronSetting.Value, enabledSetting.Value == "true")
}
}
// 更新托管消息清理配置
if section == constant.HostedMsgCleanSectionName {
if key == constant.HostedMsgCleanCronKeyName || key == constant.HostedMsgCleanEnabledKeyName {
cronService := cron_service.CronService{}
// 获取最新的cron和enabled值
cronSetting, _ := models.GetSettingByKey(constant.HostedMsgCleanSectionName, constant.HostedMsgCleanCronKeyName)
enabledSetting, _ := models.GetSettingByKey(constant.HostedMsgCleanSectionName, constant.HostedMsgCleanEnabledKeyName)
cronService.UpdateHostedMsgCronRun(cronSetting.Value, enabledSetting.Value == "true")
}
}
// 如果是site_config，清除缓存
if section == constant.SiteSettingSectionName {
@@ -116,6 +132,13 @@ type SiteConfig struct {
type LogConfig struct {
Cron string `json:"cron" validate:"required,cron" label:"日志定时表达式"`
KeepNum string `json:"keep_num" validate:"required,min=1,max=50" label:"日志保留数"`
Enabled string `json:"enabled" validate:"required,oneof=true false" label:"是否启用"`
}
type HostedMsgConfig struct {
Cron string `json:"cron" validate:"required,cron" label:"托管消息定时表达式"`
KeepNum string `json:"keep_num" validate:"required,min=1,max=50" label:"托管消息保留数"`
Enabled string `json:"enabled" validate:"required,oneof=true false" label:"是否启用"`
}
// GetCookieExpDays 获取 cookie 过期天数，若无配置则返回默认值 1
@@ -157,6 +180,19 @@ func (us *UserSettings) ValidateDiffSetting(section string, data map[string]stri
var config LogConfig
config.Cron = data["cron"]
config.KeepNum = data["keep_num"]
config.Enabled = data["enabled"]
_, err := cron.ParseStandard(config.Cron)
if err != nil {
return fmt.Sprintf("%s 不是合法的corn表达式", config.Cron)
}
_, errStr := app.CommonPlaygroundValid(config)
return errStr
}
if section == constant.HostedMsgCleanSectionName {
var config HostedMsgConfig
config.Cron = data["cron"]
config.KeepNum = data["keep_num"]
config.Enabled = data["enabled"]
_, err := cron.ParseStandard(config.Cron)
if err != nil {
return fmt.Sprintf("%s 不是合法的corn表达式", config.Cron)