feat: alert count limit (#9621)

<img width="633" height="304" alt="image" src="https://github.com/user-attachments/assets/b5077719-ddf8-438c-9ce4-ca6bb76d7217" />

.vscode/settings.json

@@ -1,3 +1,3 @@
 {
     "ansible.python.interpreterPath": "/opt/homebrew/bin/python3"
-}
+}

CODE_OF_CONDUCT.md

@@ -125,4 +125,4 @@ enforcement ladder](https://github.com/mozilla/diversity).
 
 For answers to common questions about this code of conduct, see the FAQ at
 https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
+https://www.contributor-covenant.org/translations.

agent/app/api/v2/alert.go

@@ -0,0 +1,200 @@
+package v2
+
+import (
+	"errors"
+	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/gin-gonic/gin"
+)
+
+func (b *BaseApi) PageAlert(c *gin.Context) {
+	var req dto.AlertSearch
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	total, alerts, err := alertService.PageAlert(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, dto.PageResult{
+		Total: total,
+		Items: alerts,
+	})
+}
+
+func (b *BaseApi) GetAlerts(c *gin.Context) {
+	alerts, err := alertService.GetAlerts()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, alerts)
+}
+
+func (b *BaseApi) CreateAlert(c *gin.Context) {
+	var req dto.AlertCreate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := alertService.CreateAlert(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) DeleteAlert(c *gin.Context) {
+	var req dto.DeleteRequest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := alertService.DeleteAlert(req.ID)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) UpdateAlert(c *gin.Context) {
+	var req dto.AlertUpdate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := alertService.UpdateAlert(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) GetAlert(c *gin.Context) {
+	id, err := helper.GetParamID(c)
+	if err != nil {
+		helper.BadRequest(c, errors.New("no such id in request param"))
+		return
+	}
+	alert, err := alertService.GetAlert(id)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, alert)
+}
+
+func (b *BaseApi) UpdateAlertStatus(c *gin.Context) {
+	var req dto.AlertUpdateStatus
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := alertService.UpdateStatus(req.ID, req.Status); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) GetDisks(c *gin.Context) {
+	alerts, err := alertService.GetDisks()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, alerts)
+}
+
+func (b *BaseApi) PageAlertLogs(c *gin.Context) {
+	var req dto.AlertLogSearch
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	total, alertLogs, err := alertService.PageAlertLogs(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, dto.PageResult{
+		Total: total,
+		Items: alertLogs,
+	})
+}
+
+func (b *BaseApi) CleanAlertLogs(c *gin.Context) {
+	if err := alertService.CleanAlertLogs(); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) GetClams(c *gin.Context) {
+	clams, err := alertService.GetClams()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, clams)
+}
+
+func (b *BaseApi) GetCronJobs(c *gin.Context) {
+	var req dto.CronJobReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	cronJobs, err := alertService.GetCronJobs(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, cronJobs)
+}
+
+func (b *BaseApi) GetAlertConfig(c *gin.Context) {
+	config, err := alertService.GetAlertConfig()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, config)
+}
+
+func (b *BaseApi) UpdateAlertConfig(c *gin.Context) {
+	var req dto.AlertConfigUpdate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := alertService.UpdateAlertConfig(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) DeleteAlertConfig(c *gin.Context) {
+	var req dto.DeleteRequest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := alertService.DeleteAlertConfig(req.ID)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+func (b *BaseApi) TestAlertConfig(c *gin.Context) {
+	var req dto.AlertConfigTest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	flag, err := alertService.TestAlertConfig(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, flag)
+}

agent/app/api/v2/app_install.go

@@ -327,3 +327,25 @@ func (b *BaseApi) UpdateAppConfig(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags App
+// @Summary Get app install info
+// @Accept json
+// @Param appInstallId path integer true "App install id"
+// @Success 200 {object} dto.AppInstallInfo
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /apps/installed/info/:appInstallId [get]
+func (b *BaseApi) GetAppInstallInfo(c *gin.Context) {
+	appInstallId, err := helper.GetIntParamByKey(c, "appInstallId")
+	if err != nil {
+		helper.BadRequest(c, err)
+		return
+	}
+	info, err := appInstallService.GetAppInstallInfo(appInstallId)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, info)
+}

agent/app/api/v2/backup.go

@@ -371,12 +371,12 @@ func (b *BaseApi) Backup(c *gin.Context) {
 			helper.InternalServer(c, err)
 			return
 		}
-	case "mysql", "mariadb":
+	case "mysql", "mariadb", constant.AppMysqlCluster:
 		if err := backupService.MysqlBackup(req); err != nil {
 			helper.InternalServer(c, err)
 			return
 		}
-	case constant.AppPostgresql:
+	case constant.AppPostgresql, constant.AppPostgresqlCluster:
 		if err := backupService.PostgresqlBackup(req); err != nil {
 			helper.InternalServer(c, err)
 			return
@@ -386,7 +386,7 @@ func (b *BaseApi) Backup(c *gin.Context) {
 			helper.InternalServer(c, err)
 			return
 		}
-	case "redis":
+	case "redis", constant.AppRedisCluster:
 		if err := backupService.RedisBackup(req); err != nil {
 			helper.InternalServer(c, err)
 			return
@@ -421,12 +421,12 @@ func (b *BaseApi) Recover(c *gin.Context) {
 	}
 	req.File = downloadPath
 	switch req.Type {
-	case "mysql", "mariadb":
+	case "mysql", "mariadb", constant.AppMysqlCluster:
 		if err := backupService.MysqlRecover(req); err != nil {
 			helper.InternalServer(c, err)
 			return
 		}
-	case constant.AppPostgresql:
+	case constant.AppPostgresql, constant.AppPostgresqlCluster:
 		if err := backupService.PostgresqlRecover(req); err != nil {
 			helper.InternalServer(c, err)
 			return
@@ -436,7 +436,7 @@ func (b *BaseApi) Recover(c *gin.Context) {
 			helper.InternalServer(c, err)
 			return
 		}
-	case "redis":
+	case "redis", constant.AppRedisCluster:
 		if err := backupService.RedisRecover(req); err != nil {
 			helper.InternalServer(c, err)
 			return

agent/app/api/v2/container.go

@@ -35,6 +35,24 @@ func (b *BaseApi) SearchContainer(c *gin.Context) {
 	})
 }
 
+// @Tags Container
+// @Summary Load container users
+// @Accept json
+// @Param request body dto.OperationWithName true "request"
+// @Produce json
+// @Success 200 {array} string
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /containers/users [post]
+func (b *BaseApi) LoadContainerUsers(c *gin.Context) {
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	helper.SuccessWithData(c, containerService.LoadUsers(req))
+}
+
 // @Tags Container
 // @Summary List containers
 // @Accept json
@@ -243,7 +261,7 @@ func (b *BaseApi) ContainerCreate(c *gin.Context) {
 		return
 	}
 
-	if err := containerService.ContainerCreate(req); err != nil {
+	if err := containerService.ContainerCreate(req, true); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}

agent/app/api/v2/database_redis.go

@@ -11,13 +11,13 @@ import (
 // @Tags Database Redis
 // @Summary Load redis status info
 // @Accept json
-// @Param request body dto.OperationWithName true "request"
+// @Param request body dto.LoadRedisStatus true "request"
 // @Success 200 {object} dto.RedisStatus
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /databases/redis/status [post]
 func (b *BaseApi) LoadRedisStatus(c *gin.Context) {
-	var req dto.OperationWithName
+	var req dto.LoadRedisStatus
 	if err := helper.CheckBind(&req, c); err != nil {
 		return
 	}
@@ -33,13 +33,13 @@ func (b *BaseApi) LoadRedisStatus(c *gin.Context) {
 // @Tags Database Redis
 // @Summary Load redis conf
 // @Accept json
-// @Param request body dto.OperationWithName true "request"
+// @Param request body dto.LoadRedisStatus true "request"
 // @Success 200 {object} dto.RedisConf
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /databases/redis/conf [post]
 func (b *BaseApi) LoadRedisConf(c *gin.Context) {
-	var req dto.OperationWithName
+	var req dto.LoadRedisStatus
 	if err := helper.CheckBind(&req, c); err != nil {
 		return
 	}
@@ -55,13 +55,13 @@ func (b *BaseApi) LoadRedisConf(c *gin.Context) {
 // @Tags Database Redis
 // @Summary Load redis persistence conf
 // @Accept json
-// @Param request body dto.OperationWithName true "request"
+// @Param request body dto.LoadRedisStatus true "request"
 // @Success 200 {object} dto.RedisPersistence
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /databases/redis/persistence/conf [post]
 func (b *BaseApi) LoadPersistenceConf(c *gin.Context) {
-	var req dto.OperationWithName
+	var req dto.LoadRedisStatus
 	if err := helper.CheckBind(&req, c); err != nil {
 		return
 	}

agent/app/api/v2/entry.go

@@ -70,4 +70,5 @@ var (
 	websiteCAService = service.NewIWebsiteCAService()
 	taskService      = service.NewITaskService()
 	groupService     = service.NewIGroupService()
+	alertService     = service.NewIAlertService()
 )

agent/app/api/v2/file.go

@@ -296,7 +296,7 @@ func (b *BaseApi) SaveContent(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /files/upload [post]
-// @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传文件 [path]","formatEN":"Upload file [path]"}
+// @x-panel-log {"bodyKeys":["path", "file"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传文件 [path]/[file]","formatEN":"Upload file [path]/[file]"}
 func (b *BaseApi) UploadFiles(c *gin.Context) {
 	form, err := c.MultipartForm()
 	if err != nil {

agent/app/api/v2/host_tool.go

@@ -13,7 +13,7 @@ import (
 // @Success 200 {object} response.HostToolRes
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool [post]
+// @Router /hosts/tool [post]
 func (b *BaseApi) GetToolStatus(c *gin.Context) {
 	var req request.HostToolReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -35,7 +35,7 @@ func (b *BaseApi) GetToolStatus(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/create [post]
+// @Router /hosts/tool/create [post]
 // @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 [type] 配置","formatEN":"create [type] config"}
 func (b *BaseApi) InitToolConfig(c *gin.Context) {
 	var req request.HostToolCreate
@@ -57,7 +57,7 @@ func (b *BaseApi) InitToolConfig(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/operate [post]
+// @Router /hosts/tool/operate [post]
 // @x-panel-log {"bodyKeys":["operate","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] [type] ","formatEN":"[operate] [type]"}
 func (b *BaseApi) OperateTool(c *gin.Context) {
 	var req request.HostToolReq
@@ -79,7 +79,7 @@ func (b *BaseApi) OperateTool(c *gin.Context) {
 // @Success 200 {object} response.HostToolConfig
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/config [post]
+// @Router /hosts/tool/config [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 主机工具配置文件 ","formatEN":"[operate] tool config"}
 func (b *BaseApi) OperateToolConfig(c *gin.Context) {
 	var req request.HostToolConfig
@@ -102,7 +102,7 @@ func (b *BaseApi) OperateToolConfig(c *gin.Context) {
 // @Success 200 {string} logContent
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/log [post]
+// @Router /hosts/tool/log [post]
 func (b *BaseApi) GetToolLog(c *gin.Context) {
 	var req request.HostToolLogReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -124,7 +124,7 @@ func (b *BaseApi) GetToolLog(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process [post]
+// @Router /hosts/tool/supervisor/process [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 守护进程 ","formatEN":"[operate] process"}
 func (b *BaseApi) OperateProcess(c *gin.Context) {
 	var req request.SupervisorProcessConfig
@@ -146,7 +146,7 @@ func (b *BaseApi) OperateProcess(c *gin.Context) {
 // @Success 200 {object} response.SupervisorProcessConfig
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process [get]
+// @Router /hosts/tool/supervisor/process [get]
 func (b *BaseApi) GetProcess(c *gin.Context) {
 	configs, err := hostToolService.GetSupervisorProcessConfig()
 	if err != nil {
@@ -163,7 +163,7 @@ func (b *BaseApi) GetProcess(c *gin.Context) {
 // @Success 200 {string} content
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process/file [post]
+// @Router /hosts/tool/supervisor/process/file [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] Supervisor 进程文件 ","formatEN":"[operate] Supervisor Process Config file"}
 func (b *BaseApi) GetProcessFile(c *gin.Context) {
 	var req request.SupervisorProcessFileReq

agent/app/api/v2/image_repo.go

@@ -98,20 +98,20 @@ func (b *BaseApi) CreateRepo(c *gin.Context) {
 // @Tags Container Image-repo
 // @Summary Delete image repo
 // @Accept json
-// @Param request body dto.ImageRepoDelete true "request"
+// @Param request body dto.OperateByID true "request"
 // @Produce json
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/repo/del [post]
-// @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"image_repos","output_column":"name","output_value":"names"}],"formatZH":"删除镜像仓库 [names]","formatEN":"delete image repo [names]"}
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"image_repos","output_column":"name","output_value":"name"}],"formatZH":"删除镜像仓库 [name]","formatEN":"delete image repo [name]"}
 func (b *BaseApi) DeleteRepo(c *gin.Context) {
-	var req dto.ImageRepoDelete
+	var req dto.OperateByID
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
 
-	if err := imageRepoService.BatchDelete(req); err != nil {
+	if err := imageRepoService.Delete(req); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}

agent/app/api/v2/runtime.go

@@ -535,3 +535,23 @@ func (b *BaseApi) GetPHPContainerConfig(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, data)
 }
+
+// @Tags Runtime
+// @Summary Update runtime remark
+// @Accept json
+// @Param request body request.RuntimeRemarkUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /runtimes/remark [post]
+func (b *BaseApi) UpdateRuntimeRemark(c *gin.Context) {
+	var req request.RuntimeRemark
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := runtimeService.UpdateRemark(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}

agent/app/api/v2/ssh.go

@@ -11,7 +11,7 @@ import (
 // @Success 200 {object} dto.SSHInfo
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/search [post]
+// @Router /hosts/ssh/search [post]
 func (b *BaseApi) GetSSHInfo(c *gin.Context) {
 	info, err := sshService.GetSSHInfo()
 	if err != nil {
@@ -28,7 +28,7 @@ func (b *BaseApi) GetSSHInfo(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/operate [post]
+// @Router /hosts/ssh/operate [post]
 // @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] SSH ","formatEN":"[operation] SSH"}
 func (b *BaseApi) OperateSSH(c *gin.Context) {
 	var req dto.Operate
@@ -50,7 +50,7 @@ func (b *BaseApi) OperateSSH(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/update [post]
+// @Router /hosts/ssh/update [post]
 // @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置 [key] => [value]","formatEN":"update SSH setting [key] => [value]"}
 func (b *BaseApi) UpdateSSH(c *gin.Context) {
 	var req dto.SSHUpdate
@@ -72,7 +72,7 @@ func (b *BaseApi) UpdateSSH(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/conffile/update [post]
+// @Router /hosts/conffile/update [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置文件","formatEN":"update SSH conf"}
 func (b *BaseApi) UpdateSSHByfile(c *gin.Context) {
 	var req dto.SSHConf
@@ -94,7 +94,7 @@ func (b *BaseApi) UpdateSSHByfile(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/generate [post]
+// @Router /hosts/ssh/generate [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"生成 SSH 密钥 ","formatEN":"generate SSH secret"}
 func (b *BaseApi) GenerateSSH(c *gin.Context) {
 	var req dto.GenerateSSH
@@ -116,7 +116,7 @@ func (b *BaseApi) GenerateSSH(c *gin.Context) {
 // @Success 200 {string} secret
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/secret [post]
+// @Router /hosts/ssh/secret [post]
 func (b *BaseApi) LoadSSHSecret(c *gin.Context) {
 	var req dto.GenerateLoad
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -138,7 +138,7 @@ func (b *BaseApi) LoadSSHSecret(c *gin.Context) {
 // @Success 200 {object} dto.SSHLog
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/log [post]
+// @Router /hosts/ssh/log [post]
 func (b *BaseApi) LoadSSHLogs(c *gin.Context) {
 	var req dto.SearchSSHLog
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -158,7 +158,7 @@ func (b *BaseApi) LoadSSHLogs(c *gin.Context) {
 // @Success 200 {string} conf
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/conf [get]
+// @Router /hosts/ssh/conf [get]
 func (b *BaseApi) LoadSSHConf(c *gin.Context) {
 	data, err := sshService.LoadSSHConf()
 	if err != nil {

agent/app/api/v2/terminal.go

@@ -89,8 +89,8 @@ func (b *BaseApi) ContainerWsSSH(c *gin.Context) {
 	var containerID string
 	var initCmd []string
 	switch source {
-	case "redis":
-		containerID, initCmd, err = loadRedisInitCmd(c)
+	case "redis", "redis-cluster":
+		containerID, initCmd, err = loadRedisInitCmd(c, source)
 	case "ollama":
 		containerID, initCmd, err = loadOllamaInitCmd(c)
 	case "container":
@@ -127,7 +127,7 @@ func (b *BaseApi) ContainerWsSSH(c *gin.Context) {
 	_ = wsConn.WriteControl(websocket.CloseMessage, nil, dt)
 }
 
-func loadRedisInitCmd(c *gin.Context) (string, []string, error) {
+func loadRedisInitCmd(c *gin.Context, redisType string) (string, []string, error) {
 	name := c.Query("name")
 	from := c.Query("from")
 	commands := []string{"exec", "-it"}
@@ -136,7 +136,7 @@ func loadRedisInitCmd(c *gin.Context) (string, []string, error) {
 		return "", nil, fmt.Errorf("no such database in db, err: %v", err)
 	}
 	if from == "local" {
-		redisInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: name, Type: "redis"})
+		redisInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: name, Type: redisType})
 		if err != nil {
 			return "", nil, fmt.Errorf("no such app in db, err: %v", err)
 		}

agent/app/dto/alert.go

@@ -1,10 +1,17 @@
 package dto
 
+import (
+	"encoding/json"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"time"
+)
+
 type CreateOrUpdateAlert struct {
-	AlertTitle string `json:"alertTitle"`
-	AlertType  string `json:"alertType"`
-	AlertCount uint   `json:"alertCount"`
-	EntryID    uint   `json:"entryID"`
+	AlertTitle  string `json:"alertTitle"`
+	AlertType   string `json:"alertType"`
+	AlertMethod string `json:"alertMethod"`
+	AlertCount  uint   `json:"alertCount"`
+	EntryID     uint   `json:"entryID"`
 }
 
 type AlertBase struct {
@@ -18,3 +25,303 @@ type PushAlert struct {
 	EntryID   uint   `json:"entryID"`
 	Param     string `json:"param"`
 }
+
+type AlertSearch struct {
+	PageInfo
+	OrderBy string `json:"orderBy" validate:"required,oneof=created_at"`
+	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
+	Type    string `json:"type"`
+	Status  string `json:"status"`
+	Method  string `json:"method"`
+}
+
+type AlertDTO struct {
+	ID        uint      `json:"id"`
+	Type      string    `json:"type"`
+	Cycle     uint      `json:"cycle"`
+	Count     uint      `json:"count"`
+	Method    string    `json:"method"`
+	Title     string    `json:"title"`
+	Project   string    `json:"project"`
+	Status    string    `json:"status"`
+	SendCount uint      `json:"sendCount"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+}
+
+type AlertCreate struct {
+	Type      string `json:"type" validate:"required"`
+	Cycle     uint   `json:"cycle"`
+	Count     uint   `json:"count"`
+	Method    string `json:"method" validate:"required"`
+	Title     string `json:"title"`
+	Project   string `json:"project"`
+	Status    string `json:"status"`
+	SendCount uint   `json:"sendCount"`
+}
+
+type AlertUpdate struct {
+	ID        uint   `json:"id" validate:"required"`
+	Type      string `json:"type"`
+	Cycle     uint   `json:"cycle"`
+	Count     uint   `json:"count"`
+	Method    string `json:"method"`
+	Title     string `json:"title"`
+	Project   string `json:"project"`
+	Status    string `json:"status"`
+	SendCount uint   `json:"sendCount"`
+}
+
+type DeleteRequest struct {
+	ID uint `json:"id" validate:"required"`
+}
+
+type AlertUpdateStatus struct {
+	ID     uint   `json:"id" validate:"required"`
+	Status string `json:"status" validate:"required"`
+}
+
+type DiskDTO struct {
+	Path        string  `json:"path"`
+	Type        string  `json:"type"`
+	Device      string  `json:"device"`
+	Total       uint64  `json:"total"`
+	Free        uint64  `json:"free"`
+	Used        uint64  `json:"used"`
+	UsedPercent float64 `json:"usedPercent"`
+
+	InodesTotal       uint64  `json:"inodesTotal"`
+	InodesUsed        uint64  `json:"inodesUsed"`
+	InodesFree        uint64  `json:"inodesFree"`
+	InodesUsedPercent float64 `json:"inodesUsedPercent"`
+}
+
+type AlertLogSearch struct {
+	PageInfo
+	Count  uint   `json:"count"`
+	Status string `json:"status"`
+}
+
+type AlertLogDTO struct {
+	ID          uint        `json:"id"`
+	Type        string      `json:"type"`
+	Count       uint        `json:"count"`
+	AlertId     uint        `json:"alertId"`
+	AlertDetail AlertDetail `json:"alertDetail"`
+	AlertRule   AlertRule   `json:"alertRule"`
+	Status      string      `json:"status"`
+	Method      string      `json:"method"`
+	Message     string      `json:"message"`
+	CreatedAt   time.Time   `json:"createdAt"`
+	UpdatedAt   time.Time   `json:"updatedAt"`
+}
+
+type AlertLogCreate struct {
+	Type        string `json:"type" validate:"required"`
+	Count       uint   `json:"count" validate:"required"`
+	AlertId     uint   `json:"alertId" validate:"required"`
+	AlertDetail string `json:"alertDetail" validate:"required"`
+	AlertRule   string `json:"alertRule" validate:"required"`
+	Status      string `json:"status" validate:"required"`
+	Method      string `json:"method" validate:"required"`
+	Message     string `json:"message"`
+	RecordId    uint   `json:"recordId"`
+	LicenseId   string `json:"licenseId" validate:"required"`
+}
+
+type AlertLog struct {
+	ID uint `json:"id" validate:"required"`
+}
+
+type AlertDetail struct {
+	LicenseId   string  `json:"licenseId"`
+	Type        string  `json:"type"`
+	SubType     string  `json:"subType"`
+	Title       string  `json:"title"`
+	Method      string  `json:"method"`
+	LicenseCode string  `json:"licenseCode"`
+	DeviceId    string  `json:"deviceId"`
+	Project     string  `json:"project"`
+	Params      []Param `json:"params"`
+	Phone       string  `json:"phone"`
+}
+
+type AlertRule struct {
+	ID        uint      `json:"id"`
+	Type      string    `json:"type"`
+	Cycle     uint      `json:"cycle"`
+	Count     uint      `json:"count"`
+	Method    string    `json:"method"`
+	Title     string    `json:"title"`
+	Project   string    `json:"project"`
+	Status    string    `json:"status"`
+	SendCount uint      `json:"sendCount"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+}
+
+type Param struct {
+	Index string `json:"index"`
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+type ClamDTO struct {
+	ID        uint      `json:"id"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+	Name      string    `json:"name"`
+	Status    string    `json:"status"`
+	Path      string    `json:"path"`
+}
+
+type CronJobDTO struct {
+	ID        uint      `json:"id"`
+	CreatedAt time.Time `json:"createdAt"`
+	UpdatedAt time.Time `json:"updatedAt"`
+	Name      string    `json:"name"`
+	Status    string    `json:"status"`
+	Type      string    `json:"type"`
+}
+
+type CronJobReq struct {
+	Name   string `json:"name"`
+	Status string `json:"status"`
+	Type   string `json:"type"`
+}
+
+type UpgradeInfo struct {
+	TestVersion   string `json:"testVersion"`
+	NewVersion    string `json:"newVersion"`
+	LatestVersion string `json:"latestVersion"`
+	ReleaseNote   string `json:"releaseNote"`
+}
+
+type AlertDiskInfo struct {
+	Type   string
+	Mount  string
+	Device string
+}
+
+type SyncResult struct {
+	ID          uint   `json:"id"`
+	LicenseID   string `json:"licenseId"`
+	SendStatus  string `json:"sendStatus"`
+	CreateTime  string `json:"createTime"`
+	UpdateTime  string `json:"updateTime"`
+	Remarks     string `json:"remarks"`
+	MsgCount    int    `json:"msgCount"`
+	MsgCountMax int    `json:"msgCountMax"`
+}
+
+type QueryRequest struct {
+	QueryIds  []uint `json:"queryIds"`
+	LicenseId string `json:"licenseId"`
+}
+
+type AlertResponse struct {
+	Result  bool            `json:"result"`
+	Data    json.RawMessage `json:"data"`
+	Message string          `json:"message"`
+}
+
+type PushResult struct {
+	RecordId  uint   `json:"recordId"`
+	LicenseId string `json:"licenseId"`
+}
+
+type UpdateOfflineAlertLog struct {
+	ID        uint   `json:"id"`
+	Status    string `json:"status"`
+	Message   string `json:"message"`
+	RecordId  uint   `json:"recordId"`
+	LicenseId string `json:"licenseId"`
+}
+
+type SyncOfflineAlertLogDTO struct {
+	QueryRequest string           `json:"queryRequest"`
+	Ids          []uint           `json:"ids"`
+	AlertLogs    []model.AlertLog `json:"alertLogs"`
+	LicenseId    string           `json:"licenseId"`
+}
+
+type OfflineAlertResponse struct {
+	ID             uint             `json:"id"`
+	Type           string           `json:"type"`
+	RemoteErr      error            `json:"remoteErr"`
+	ResponseStruct AlertResponse    `json:"responseStruct"`
+	AlertLogs      []model.AlertLog `json:"alertLogs"`
+	Ids            []uint           `json:"ids"`
+	LicenseId      string           `json:"licenseId"`
+}
+
+type OfflineAlertLogDTO struct {
+	ID          uint      `json:"id"`
+	Type        string    `json:"type"`
+	Count       uint      `json:"count"`
+	AlertId     uint      `json:"alertId"`
+	AlertDetail string    `json:"alertDetail"`
+	AlertRule   string    `json:"alertRule"`
+	Status      string    `json:"status"`
+	Method      string    `json:"method"`
+	Message     string    `json:"message"`
+	RecordId    uint      `json:"recordId"`
+	LicenseId   string    `json:"licenseId"`
+	CreatedAt   time.Time `json:"createdAt"`
+	UpdatedAt   time.Time `json:"updatedAt"`
+}
+
+type OfflineQueryRequest struct {
+	Ids       []uint `json:"ids"`
+	QueryIds  []uint `json:"queryIds"`
+	LicenseId string `json:"licenseId"`
+}
+
+type AlertConfigUpdate struct {
+	ID     uint   `json:"id"`
+	Type   string `json:"type"`
+	Title  string `json:"title"`
+	Status string `json:"status"`
+	Config string `json:"config"`
+}
+
+type AlertConfigTest struct {
+	Host        string `json:"host"`
+	Port        int    `json:"port"`
+	Sender      string `json:"sender"`
+	Password    string `json:"password"`
+	DisplayName string `json:"displayName"`
+	Encryption  string `json:"encryption"` // "ssl" / "tls" / "none"
+	Recipient   string `json:"recipient"`
+}
+
+type AlertSendTimeRange struct {
+	NoticeAlert struct {
+		SendTimeRange string   `json:"sendTimeRange"`
+		Type          []string `json:"type"`
+	} `json:"noticeAlert"`
+	ResourceAlert struct {
+		SendTimeRange string   `json:"sendTimeRange"`
+		Type          []string `json:"type"`
+	} `json:"resourceAlert"`
+}
+
+type AlertCommonConfig struct {
+	IsOffline          string             `json:"isOffline"`
+	AlertSendTimeRange AlertSendTimeRange `json:"alertSendTimeRange"`
+}
+
+type AlertSmsConfig struct {
+	Phone         string `json:"phone"`
+	AlertDailyNum uint   `json:"alertDailyNum"`
+}
+
+type AlertEmailConfig struct {
+	Host        string `json:"host"`
+	Port        int    `json:"port"`
+	Sender      string `json:"sender"`
+	Password    string `json:"password"`
+	DisplayName string `json:"displayName"`
+	Encryption  string `json:"encryption"` // "ssl" / "tls" / "none"
+	Recipient   string `json:"recipient"`
+}

agent/app/dto/app.go

@@ -7,10 +7,11 @@ import (
 )
 
 type AppDatabase struct {
-	ServiceName string `json:"PANEL_DB_HOST"`
-	DbName      string `json:"PANEL_DB_NAME"`
-	DbUser      string `json:"PANEL_DB_USER"`
-	Password    string `json:"PANEL_DB_USER_PASSWORD"`
+	ServiceName  string `json:"PANEL_DB_HOST"`
+	DbName       string `json:"PANEL_DB_NAME"`
+	DbUser       string `json:"PANEL_DB_USER"`
+	Password     string `json:"PANEL_DB_USER_PASSWORD"`
+	DatabaseName string `json:"DATABASE_NAME"`
 }
 
 type AuthParam struct {
@@ -126,6 +127,7 @@ type Locale struct {
 	ZhHant string `json:"zh-hant" yaml:"zh-hant"`
 	Zh     string `json:"zh"`
 	Ko     string `json:"ko"`
+	Tr     string `json:"tr"`
 }
 
 type AppForm struct {

agent/app/dto/backup.go

@@ -54,7 +54,7 @@ type BackupOption struct {
 }
 
 type CommonBackup struct {
-	Type       string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql"`
+	Type       string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql mysql-cluster postgresql-cluster redis-cluster"`
 	Name       string `json:"name"`
 	DetailName string `json:"detailName"`
 	Secret     string `json:"secret"`
@@ -65,7 +65,7 @@ type CommonBackup struct {
 }
 type CommonRecover struct {
 	DownloadAccountID uint   `json:"downloadAccountID" validate:"required"`
-	Type              string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql"`
+	Type              string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql mysql-cluster postgresql-cluster redis-cluster"`
 	Name              string `json:"name"`
 	DetailName        string `json:"detailName"`
 	File              string `json:"file"`

agent/app/dto/clam.go

@@ -34,6 +34,7 @@ type ClamInfo struct {
 	Spec             string `json:"spec"`
 	Description      string `json:"description"`
 	AlertCount       uint   `json:"alertCount"`
+	AlertMethod      string `json:"alertMethod"`
 }
 
 type ClamLogSearch struct {
@@ -74,6 +75,7 @@ type ClamCreate struct {
 	Description      string `json:"description"`
 	AlertCount       uint   `json:"alertCount"`
 	AlertTitle       string `json:"alertTitle"`
+	AlertMethod      string `json:"alertMethod"`
 }
 
 type ClamUpdate struct {
@@ -87,6 +89,7 @@ type ClamUpdate struct {
 	Description      string `json:"description"`
 	AlertCount       uint   `json:"alertCount"`
 	AlertTitle       string `json:"alertTitle"`
+	AlertMethod      string `json:"alertMethod"`
 }
 
 type ClamUpdateStatus struct {

agent/app/dto/container.go

@@ -39,6 +39,11 @@ type ContainerInfo struct {
 	Websites       []string `json:"websites"`
 }
 
+type ContainerOptions struct {
+	Name  string `json:"name"`
+	State string `json:"state"`
+}
+
 type ContainerStatus struct {
 	All        uint `json:"all"`
 	Created    uint `json:"created"`
@@ -164,6 +169,8 @@ type ContainerCommit struct {
 	Comment       string `json:"comment"`
 	Author        string `json:"author"`
 	Pause         bool   `json:"pause"`
+
+	TaskID string `json:"taskID"`
 }
 
 type ContainerPrune struct {

agent/app/dto/cronjob.go

@@ -29,25 +29,33 @@ type CronjobOperate struct {
 	ContainerName string `json:"containerName"`
 	User          string `json:"user"`
 
-	ScriptID       uint   `json:"scriptID"`
-	AppID          string `json:"appID"`
-	Website        string `json:"website"`
-	ExclusionRules string `json:"exclusionRules"`
-	DBType         string `json:"dbType"`
-	DBName         string `json:"dbName"`
-	URL            string `json:"url"`
-	IsDir          bool   `json:"isDir"`
-	SourceDir      string `json:"sourceDir"`
+	ScriptID       uint         `json:"scriptID"`
+	AppID          string       `json:"appID"`
+	Website        string       `json:"website"`
+	ExclusionRules string       `json:"exclusionRules"`
+	DBType         string       `json:"dbType"`
+	DBName         string       `json:"dbName"`
+	URL            string       `json:"url"`
+	IsDir          bool         `json:"isDir"`
+	SourceDir      string       `json:"sourceDir"`
+	SnapshotRule   SnapshotRule `json:"snapshotRule"`
 
 	SourceAccountIDs  string `json:"sourceAccountIDs"`
 	DownloadAccountID uint   `json:"downloadAccountID"`
 	RetainCopies      int    `json:"retainCopies" validate:"number,min=1"`
 	RetryTimes        int    `json:"retryTimes" validate:"number,min=0"`
 	Timeout           uint   `json:"timeout" validate:"number,min=1"`
+	IgnoreErr         bool   `json:"ignoreErr"`
 	Secret            string `json:"secret"`
 
-	AlertCount uint   `json:"alertCount"`
-	AlertTitle string `json:"alertTitle"`
+	AlertCount  uint   `json:"alertCount"`
+	AlertTitle  string `json:"alertTitle"`
+	AlertMethod string `json:"alertMethod"`
+}
+
+type SnapshotRule struct {
+	WithImage    bool   `json:"withImage"`
+	IgnoreAppIDs []uint `json:"ignoreAppIDs"`
 }
 
 type CronjobUpdateStatus struct {
@@ -87,18 +95,20 @@ type CronjobInfo struct {
 	ContainerName string `json:"containerName"`
 	User          string `json:"user"`
 
-	ScriptID       uint   `json:"scriptID"`
-	AppID          string `json:"appID"`
-	Website        string `json:"website"`
-	ExclusionRules string `json:"exclusionRules"`
-	DBType         string `json:"dbType"`
-	DBName         string `json:"dbName"`
-	URL            string `json:"url"`
-	IsDir          bool   `json:"isDir"`
-	SourceDir      string `json:"sourceDir"`
-	RetainCopies   int    `json:"retainCopies"`
-	RetryTimes     int    `json:"retryTimes"`
-	Timeout        uint   `json:"timeout"`
+	ScriptID       uint         `json:"scriptID"`
+	AppID          string       `json:"appID"`
+	Website        string       `json:"website"`
+	ExclusionRules string       `json:"exclusionRules"`
+	DBType         string       `json:"dbType"`
+	DBName         string       `json:"dbName"`
+	URL            string       `json:"url"`
+	IsDir          bool         `json:"isDir"`
+	SourceDir      string       `json:"sourceDir"`
+	RetainCopies   int          `json:"retainCopies"`
+	RetryTimes     int          `json:"retryTimes"`
+	Timeout        uint         `json:"timeout"`
+	IgnoreErr      bool         `json:"ignoreErr"`
+	SnapshotRule   SnapshotRule `json:"snapshotRule"`
 
 	SourceAccounts    []string `json:"sourceAccounts"`
 	DownloadAccount   string   `json:"downloadAccount"`

agent/app/dto/dashboard.go

@@ -74,8 +74,11 @@ type DashboardCurrent struct {
 	CPUTotal       int       `json:"cpuTotal"`
 
 	MemoryTotal       uint64  `json:"memoryTotal"`
-	MemoryAvailable   uint64  `json:"memoryAvailable"`
 	MemoryUsed        uint64  `json:"memoryUsed"`
+	MemoryFree        uint64  `json:"memoryFree"`
+	MemoryShard       uint64  `json:"memoryShard"`
+	MemoryCache       uint64  `json:"memoryCache"`
+	MemoryAvailable   uint64  `json:"memoryAvailable"`
 	MemoryUsedPercent float64 `json:"memoryUsedPercent"`
 
 	SwapMemoryTotal       uint64  `json:"swapMemoryTotal"`

agent/app/dto/database.go

@@ -4,14 +4,14 @@ import "time"
 
 // common
 type DBConfUpdateByFile struct {
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql redis"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql redis mysql-cluster postgresql-cluster"`
 	Database string `json:"database" validate:"required"`
 	File     string `json:"file"`
 }
 type ChangeDBInfo struct {
 	ID       uint   `json:"id"`
 	From     string `json:"from" validate:"required,oneof=local remote"`
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql mysql-cluster postgresql-cluster"`
 	Database string `json:"database" validate:"required"`
 	Value    string `json:"value" validate:"required"`
 }
@@ -74,19 +74,19 @@ type BindUser struct {
 
 type MysqlLoadDB struct {
 	From     string `json:"from" validate:"required,oneof=local remote"`
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb mysql-cluster"`
 	Database string `json:"database" validate:"required"`
 }
 
 type MysqlDBDeleteCheck struct {
 	ID       uint   `json:"id" validate:"required"`
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb mysql-cluster"`
 	Database string `json:"database" validate:"required"`
 }
 
 type MysqlDBDelete struct {
 	ID           uint   `json:"id" validate:"required"`
-	Type         string `json:"type" validate:"required,oneof=mysql mariadb"`
+	Type         string `json:"type" validate:"required,oneof=mysql mariadb mysql-cluster"`
 	Database     string `json:"database" validate:"required"`
 	ForceDelete  bool   `json:"forceDelete"`
 	DeleteBackup bool   `json:"deleteBackup"`
@@ -153,7 +153,7 @@ type MysqlVariables struct {
 }
 
 type MysqlVariablesUpdate struct {
-	Type      string                       `json:"type" validate:"required,oneof=mysql mariadb"`
+	Type      string                       `json:"type" validate:"required,oneof=mysql mariadb mysql-cluster"`
 	Database  string                       `json:"database" validate:"required"`
 	Variables []MysqlVariablesUpdateHelper `json:"variables"`
 }
@@ -174,6 +174,7 @@ type RedisConfUpdate struct {
 	Timeout    string `json:"timeout"`
 	Maxclients string `json:"maxclients"`
 	Maxmemory  string `json:"maxmemory"`
+	DBType     string `json:"dbType" validate:"required,oneof=redis redis-cluster"`
 }
 type RedisConfPersistenceUpdate struct {
 	Database    string `json:"database" validate:"required"`
@@ -181,6 +182,7 @@ type RedisConfPersistenceUpdate struct {
 	Appendonly  string `json:"appendonly"`
 	Appendfsync string `json:"appendfsync"`
 	Save        string `json:"save"`
+	DBType      string `json:"dbType" validate:"required,oneof=redis redis-cluster"`
 }
 
 type RedisConf struct {
@@ -319,3 +321,8 @@ type DatabaseDelete struct {
 	ForceDelete  bool `json:"forceDelete"`
 	DeleteBackup bool `json:"deleteBackup"`
 }
+
+type LoadRedisStatus struct {
+	Name string `json:"name" validate:"required"`
+	Type string `json:"type" validate:"required"`
+}

agent/app/dto/image_repo.go

@@ -6,8 +6,8 @@ type ImageRepoCreate struct {
 	Name        string `json:"name" validate:"required"`
 	DownloadUrl string `json:"downloadUrl"`
 	Protocol    string `json:"protocol"`
-	Username    string `json:"username" validate:"max=256"`
-	Password    string `json:"password" validate:"max=256"`
+	Username    string `json:"username"`
+	Password    string `json:"password"`
 	Auth        bool   `json:"auth"`
 }
 
@@ -15,8 +15,8 @@ type ImageRepoUpdate struct {
 	ID          uint   `json:"id"`
 	DownloadUrl string `json:"downloadUrl"`
 	Protocol    string `json:"protocol"`
-	Username    string `json:"username" validate:"max=256"`
-	Password    string `json:"password" validate:"max=256"`
+	Username    string `json:"username"`
+	Password    string `json:"password"`
 	Auth        bool   `json:"auth"`
 }
 

agent/app/dto/request/file.go

@@ -92,11 +92,12 @@ type FileWget struct {
 }
 
 type FileMove struct {
-	Type     string   `json:"type" validate:"required"`
-	OldPaths []string `json:"oldPaths" validate:"required"`
-	NewPath  string   `json:"newPath" validate:"required"`
-	Name     string   `json:"name"`
-	Cover    bool     `json:"cover"`
+	Type       string   `json:"type" validate:"required"`
+	OldPaths   []string `json:"oldPaths" validate:"required"`
+	NewPath    string   `json:"newPath" validate:"required"`
+	Name       string   `json:"name"`
+	Cover      bool     `json:"cover"`
+	CoverPaths []string `json:"coverPaths"`
 }
 
 type FileDownload struct {

agent/app/dto/request/runtime.go

@@ -12,15 +12,17 @@ type RuntimeSearch struct {
 }
 
 type RuntimeCreate struct {
-	AppDetailID uint                   `json:"appDetailId"`
-	Name        string                 `json:"name"`
-	Params      map[string]interface{} `json:"params"`
-	Resource    string                 `json:"resource"`
-	Image       string                 `json:"image"`
-	Type        string                 `json:"type"`
-	Version     string                 `json:"version"`
-	Source      string                 `json:"source"`
-	CodeDir     string                 `json:"codeDir"`
+	AppDetailID uint   `json:"appDetailId"`
+	Name        string `json:"name"`
+	Resource    string `json:"resource"`
+	Image       string `json:"image"`
+	Type        string `json:"type"`
+	Version     string `json:"version"`
+	Source      string `json:"source"`
+	CodeDir     string `json:"codeDir"`
+	Remark      string `json:"remark"`
+
+	Params map[string]interface{} `json:"params"`
 	NodeConfig
 }
 
@@ -53,14 +55,16 @@ type RuntimeDelete struct {
 }
 
 type RuntimeUpdate struct {
-	Name    string                 `json:"name"`
-	ID      uint                   `json:"id"`
-	Params  map[string]interface{} `json:"params"`
-	Image   string                 `json:"image"`
-	Version string                 `json:"version"`
-	Rebuild bool                   `json:"rebuild"`
-	Source  string                 `json:"source"`
-	CodeDir string                 `json:"codeDir"`
+	Name    string `json:"name"`
+	ID      uint   `json:"id"`
+	Image   string `json:"image"`
+	Version string `json:"version"`
+	Rebuild bool   `json:"rebuild"`
+	Source  string `json:"source"`
+	CodeDir string `json:"codeDir"`
+	Remark  string `json:"remark"`
+
+	Params map[string]interface{} `json:"params"`
 	NodeConfig
 }
 
@@ -131,3 +135,8 @@ type PHPContainerConfig struct {
 	Environments  []Environment `json:"environments"`
 	Volumes       []Volume      `json:"volumes"`
 }
+
+type RuntimeRemark struct {
+	ID     uint   `json:"id" validate:"required"`
+	Remark string `json:"remark"`
+}

agent/app/dto/request/website.go

@@ -32,6 +32,8 @@ type WebsiteCreate struct {
 	TaskID          string `json:"taskID"`
 	ParentWebsiteID uint   `json:"parentWebsiteID"`
 
+	SiteDir string `json:"siteDir"`
+
 	RuntimeConfig
 	FtpConfig
 	DataBaseConfig

agent/app/dto/response/app.go

@@ -129,6 +129,19 @@ type AppInstallDTO struct {
 	Container     string    `json:"container"`
 }
 
+type AppInstallInfo struct {
+	ID          uint   `json:"id"`
+	Name        string `json:"name"`
+	Version     string `json:"version"`
+	Status      string `json:"status"`
+	Message     string `json:"message"`
+	HttpPort    int    `json:"HttpPort"`
+	Container   string `json:"container"`
+	ComposePath string `json:"composePath"`
+
+	Env map[string]interface{} `json:"env"`
+}
+
 type DatabaseConn struct {
 	Status        string `json:"status"`
 	Username      string `json:"username"`
@@ -158,6 +171,7 @@ type AppParam struct {
 	ShowValue string      `json:"showValue"`
 	Required  bool        `json:"required"`
 	Multiple  bool        `json:"multiple"`
+	Label     dto.Locale  `json:"label"`
 }
 
 type AppConfig struct {

agent/app/dto/response/file.go

@@ -53,6 +53,7 @@ type ExistFileInfo struct {
 	Path    string    `json:"path"`
 	Size    int64     `json:"size"`
 	ModTime time.Time `json:"modTime"`
+	IsDir   bool      `json:"isDir"`
 }
 
 type UserInfo struct {

agent/app/dto/response/runtime.go

@@ -30,6 +30,7 @@ type RuntimeDTO struct {
 	Volumes         []request.Volume       `json:"volumes"`
 	ContainerStatus string                 `json:"containerStatus"`
 	Container       string                 `json:"container"`
+	Remark          string                 `json:"remark"`
 }
 
 type PackageScripts struct {
@@ -53,6 +54,7 @@ func NewRuntimeDTO(runtime model.Runtime) RuntimeDTO {
 		Port:        runtime.Port,
 		Path:        runtime.GetPath(),
 		Container:   runtime.ContainerName,
+		Remark:      runtime.Remark,
 	}
 }
 

agent/app/dto/setting.go

@@ -23,8 +23,6 @@ type SettingInfo struct {
 	AppStoreSyncStatus   string `json:"appStoreSyncStatus"`
 
 	FileRecycleBin string `json:"fileRecycleBin"`
-
-	SnapshotIgnore string `json:"snapshotIgnore"`
 }
 
 type SettingUpdate struct {

agent/app/dto/snapshot.go

@@ -18,16 +18,20 @@ type SnapshotCreate struct {
 	Description       string `json:"description" validate:"max=256"`
 	Secret            string `json:"secret"`
 	InterruptStep     string `json:"interruptStep"`
+	Timeout           uint   `json:"timeout"`
 
 	AppData    []DataTree `json:"appData"`
 	BackupData []DataTree `json:"backupData"`
 	PanelData  []DataTree `json:"panelData"`
 
+	WithDockerConf   bool `json:"withDockerConf"`
 	WithMonitorData  bool `json:"withMonitorData"`
 	WithLoginLog     bool `json:"withLoginLog"`
 	WithOperationLog bool `json:"withOperationLog"`
 	WithSystemLog    bool `json:"withSystemLog"`
 	WithTaskLog      bool `json:"withTaskLog"`
+
+	IgnoreFiles []string `json:"ignoreFiles"`
 }
 
 type SnapshotData struct {
@@ -35,11 +39,13 @@ type SnapshotData struct {
 	BackupData []DataTree `json:"backupData"`
 	PanelData  []DataTree `json:"panelData"`
 
-	WithMonitorData  bool `json:"withMonitorData"`
-	WithLoginLog     bool `json:"withLoginLog"`
-	WithOperationLog bool `json:"withOperationLog"`
-	WithSystemLog    bool `json:"withSystemLog"`
-	WithTaskLog      bool `json:"withTaskLog"`
+	WithDockerConf   bool     `json:"withDockerConf"`
+	WithMonitorData  bool     `json:"withMonitorData"`
+	WithLoginLog     bool     `json:"withLoginLog"`
+	WithOperationLog bool     `json:"withOperationLog"`
+	WithSystemLog    bool     `json:"withSystemLog"`
+	WithTaskLog      bool     `json:"withTaskLog"`
+	IgnoreFiles      []string `json:"ignoreFiles"`
 }
 type DataTree struct {
 	ID        string `json:"id"`

agent/app/model/alert.go

@@ -0,0 +1,45 @@
+package model
+
+type Alert struct {
+	BaseModel
+
+	Title     string `gorm:"type:varchar(256);not null" json:"title"`
+	Type      string `gorm:"type:varchar(64);not null" json:"type"`
+	Cycle     uint   `gorm:"type:integer;not null" json:"cycle"`
+	Count     uint   `gorm:"type:integer;not null" json:"count"`
+	Project   string `gorm:"type:varchar(64)" json:"project"`
+	Status    string `gorm:"type:varchar(64);not null" json:"status"`
+	Method    string `gorm:"type:varchar(64);not null" json:"method"`
+	SendCount uint   `gorm:"type:integer" json:"sendCount"`
+}
+
+type AlertTask struct {
+	BaseModel
+	Type      string `gorm:"type:varchar(64);not null" json:"type"`
+	Quota     string `gorm:"type:varchar(64)" json:"quota"`
+	QuotaType string `gorm:"type:varchar(64)" json:"quotaType"`
+	Method    string `gorm:"type:varchar(64);not null;default:'sms" json:"method"`
+}
+
+type AlertLog struct {
+	BaseModel
+
+	Type        string `gorm:"type:varchar(64);not null" json:"type"`
+	Status      string `gorm:"type:varchar(64);not null" json:"status"`
+	AlertId     uint   `gorm:"type:integer;not null" json:"alertId"`
+	AlertDetail string `gorm:"type:varchar(256);not null" json:"alertDetail"`
+	AlertRule   string `gorm:"type:varchar(256);not null" json:"alertRule"`
+	Count       uint   `gorm:"type:integer;not null" json:"count"`
+	Message     string `gorm:"type:varchar(256);" json:"message"`
+	RecordId    uint   `gorm:"type:integer;" json:"recordId"`
+	LicenseId   string `gorm:"type:varchar(256);not null;" json:"licenseId" `
+	Method      string `gorm:"type:varchar(64);not null;default:'sms" json:"method"`
+}
+
+type AlertConfig struct {
+	BaseModel
+	Type   string `gorm:"type:varchar(64);not null" json:"type"`
+	Title  string `gorm:"type:varchar(64);not null" json:"title"`
+	Status string `gorm:"type:varchar(64);not null" json:"status"`
+	Config string `gorm:"type:varchar(256);not null" json:"config"`
+}

agent/app/model/cronjob.go

@@ -29,12 +29,14 @@ type Cronjob struct {
 	URL            string `json:"url"`
 	IsDir          bool   `json:"isDir"`
 	SourceDir      string `json:"sourceDir"`
+	SnapshotRule   string `json:"snapshotRule"`
 	ExclusionRules string `json:"exclusionRules"`
 
 	SourceAccountIDs  string `json:"sourceAccountIDs"`
 	DownloadAccountID uint   `json:"downloadAccountID"`
 	RetryTimes        uint   `json:"retryTimes"`
 	Timeout           uint   `json:"timeout"`
+	IgnoreErr         bool   `json:"ignoreErr"`
 	RetainCopies      uint64 `json:"retainCopies"`
 
 	Status   string       `json:"status"`

agent/app/model/runtime.go

@@ -23,6 +23,7 @@ type Runtime struct {
 	Message       string `json:"message"`
 	CodeDir       string `json:"codeDir"`
 	ContainerName string `json:"containerName"`
+	Remark        string `json:"remark"`
 }
 
 func (r *Runtime) GetComposePath() string {

agent/app/model/snapshot.go

@@ -10,19 +10,23 @@ type Snapshot struct {
 	Status            string `json:"status"`
 	Message           string `json:"message"`
 	Version           string `json:"version"`
+	Timeout           uint   `json:"timeout"`
 
 	TaskID         string `json:"taskID"`
 	TaskRecoverID  string `json:"taskRecoverID"`
 	TaskRollbackID string `json:"taskRollbackID"`
 
-	AppData          string `json:"appData"`
-	PanelData        string `json:"panelData"`
-	BackupData       string `json:"backupData"`
+	AppData    string `json:"appData"`
+	PanelData  string `json:"panelData"`
+	BackupData string `json:"backupData"`
+
+	WithDockerConf   bool   `json:"withDockerConf"`
 	WithMonitorData  bool   `json:"withMonitorData"`
 	WithLoginLog     bool   `json:"withLoginLog"`
 	WithOperationLog bool   `json:"withOperationLog"`
 	WithSystemLog    bool   `json:"withSystemLog"`
 	WithTaskLog      bool   `json:"withTaskLog"`
+	IgnoreFiles      string `json:"ignoreFiles"`
 
 	InterruptStep   string `json:"interruptStep"`
 	RecoverStatus   string `json:"recoverStatus"`

agent/app/repo/alert.go

@@ -0,0 +1,337 @@
+package repo
+
+import (
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"google.golang.org/genproto/googleapis/type/date"
+	"gorm.io/gorm"
+	"time"
+)
+
+type AlertRepo struct{}
+
+type IAlertRepo interface {
+	WithByType(alertType string) DBOption
+	WithByStatusIn(status []string) DBOption
+	WithByProject(project string) DBOption
+	WithByCount(count uint) DBOption
+	WithByAlertId(alertId uint) DBOption
+	WithByCreateAt(date *date.Date) DBOption
+	WithByLicenseId(licenseId string) DBOption
+	WithByRecordId(recordId uint) DBOption
+	WithByMethod(method string) DBOption
+
+	Create(alert *model.Alert) error
+	Get(opts ...DBOption) (model.Alert, error)
+	Page(page, size int, opts ...DBOption) (int64, []model.Alert, error)
+	List(opts ...DBOption) ([]model.Alert, error)
+	Delete(opts ...DBOption) error
+	Save(alert *model.Alert) error
+	Update(maps map[string]interface{}, opts ...DBOption) error
+
+	GetLog(opts ...DBOption) (model.AlertLog, error)
+	CreateLog(alertLog *model.AlertLog) error
+	PageLog(limit, offset int, opts ...DBOption) (int64, []model.AlertLog, error)
+	ListLog(opts ...DBOption) ([]model.AlertLog, error)
+	UpdateLog(id uint, maps map[string]interface{}) error
+	BatchUpdateLogBy(maps map[string]interface{}, opts ...DBOption) error
+	DeleteLog(opts ...DBOption) error
+	CleanAlertLogs() error
+
+	CreateAlertTask(alertTaskBase *model.AlertTask) error
+	DeleteAlertTask(opts ...DBOption) error
+	GetAlertTask(opts ...DBOption) (model.AlertTask, error)
+	LoadTaskCount(alertType string, project string, method string) (uint, uint, error)
+	GetTaskLog(alertType string, alertId uint) (time.Time, error)
+	GetLicensePushCount(method string) (uint, error)
+
+	GetConfig(opts ...DBOption) (model.AlertConfig, error)
+	AlertConfigList(opts ...DBOption) ([]model.AlertConfig, error)
+	UpdateAlertConfig(maps map[string]interface{}, opts ...DBOption) error
+	CreateAlertConfig(config *model.AlertConfig) error
+	DeleteAlertConfig(opts ...DBOption) error
+
+	SyncAll(data []model.AlertConfig) error
+}
+
+func NewIAlertRepo() IAlertRepo {
+	return &AlertRepo{}
+}
+
+func (a *AlertRepo) WithByType(alertType string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("`type` = ?", alertType)
+	}
+}
+
+func (a *AlertRepo) WithByStatusIn(status []string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("status in (?)", status)
+	}
+}
+
+func (a *AlertRepo) WithByCount(count uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("count = ?", count)
+	}
+}
+
+func (a *AlertRepo) WithByProject(project string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("project = ?", project)
+	}
+}
+
+func (a *AlertRepo) WithByAlertId(alertId uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("alert_id = ?", alertId)
+	}
+}
+
+func (a *AlertRepo) WithByLicenseId(licenseId string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("license_id = ?", licenseId)
+	}
+}
+
+func (a *AlertRepo) WithByRecordId(recordId uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("record_id = ?", recordId)
+	}
+}
+
+func (a *AlertRepo) WithByMethod(method string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("method = ?", method)
+	}
+}
+
+func (a *AlertRepo) WithByCreateAt(createAt *date.Date) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("DATE(created_at) = DATE(?)", createAt)
+	}
+}
+
+func (a *AlertRepo) Create(alert *model.Alert) error {
+	return global.AlertDB.Model(&model.Alert{}).Create(alert).Error
+}
+
+func (a *AlertRepo) Save(alert *model.Alert) error {
+	return global.AlertDB.Save(alert).Error
+}
+
+func (a *AlertRepo) Get(opts ...DBOption) (model.Alert, error) {
+	var alert model.Alert
+	db, _ := getAlertDB(opts...)
+	err := db.First(&alert).Error
+	return alert, err
+}
+
+func (a *AlertRepo) Page(page, size int, opts ...DBOption) (int64, []model.Alert, error) {
+	var alerts []model.Alert
+	alertDb, _ := getAlertDB(opts...)
+	db := alertDb.Model(&model.Alert{})
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&alerts).Error
+	return count, alerts, err
+}
+
+func (a *AlertRepo) List(opts ...DBOption) ([]model.Alert, error) {
+	var alert []model.Alert
+	db, _ := getAlertDB(opts...)
+	err := db.Find(&alert).Error
+	return alert, err
+}
+
+func (a *AlertRepo) Update(maps map[string]interface{}, opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Model(&model.Alert{}).Updates(maps).Error
+}
+
+func (a *AlertRepo) Delete(opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Delete(&model.Alert{}).Error
+}
+
+func (a *AlertRepo) GetLog(opts ...DBOption) (model.AlertLog, error) {
+	var alertLog model.AlertLog
+	db, _ := getAlertDB(opts...)
+	err := db.First(&alertLog).Error
+	return alertLog, err
+}
+
+func (a *AlertRepo) CreateLog(log *model.AlertLog) error {
+	return global.AlertDB.Model(&model.AlertLog{}).Create(&log).Error
+}
+
+func (a *AlertRepo) UpdateLog(id uint, maps map[string]interface{}) error {
+	return global.AlertDB.Model(&model.AlertLog{}).Where("id = ?", id).Updates(maps).Error
+}
+
+func (a *AlertRepo) BatchUpdateLogBy(maps map[string]interface{}, opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	if len(opts) == 0 {
+		db = db.Where("1=1")
+	}
+	return db.Model(&model.AlertLog{}).Updates(&maps).Error
+}
+
+func (a *AlertRepo) PageLog(page, size int, opts ...DBOption) (int64, []model.AlertLog, error) {
+	var alerts []model.AlertLog
+	db := global.AlertDB.Model(&model.AlertLog{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	count := int64(0)
+	db = db.Order("created_at desc").Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&alerts).Error
+	return count, alerts, err
+}
+
+func (a *AlertRepo) ListLog(opts ...DBOption) ([]model.AlertLog, error) {
+	var alertLog []model.AlertLog
+	db, _ := getAlertDB(opts...)
+	err := db.Find(&alertLog).Error
+	return alertLog, err
+}
+
+func (a *AlertRepo) DeleteLog(opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Delete(&model.AlertLog{}).Error
+}
+
+func (a *AlertRepo) CleanAlertLogs() error {
+	return global.AlertDB.Where("1 = 1").Delete(&model.AlertLog{}).Error
+}
+
+func (a *AlertRepo) CreateAlertTask(alertTaskBase *model.AlertTask) error {
+	return global.AlertDB.Model(&model.AlertTask{}).Create(&alertTaskBase).Error
+}
+
+func (a *AlertRepo) DeleteAlertTask(opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Delete(&model.AlertTask{}).Error
+}
+
+func (a *AlertRepo) GetAlertTask(opts ...DBOption) (model.AlertTask, error) {
+	var data model.AlertTask
+	db, _ := getAlertDB(opts...)
+	err := db.First(&data).Error
+	return data, err
+}
+
+func (a *AlertRepo) LoadTaskCount(alertType string, project string, method string) (uint, uint, error) {
+	var (
+		todayCount int64
+		totalCount int64
+	)
+	_ = global.AlertDB.Model(&model.AlertTask{}).Where("type = ? AND quota_type = ? AND method = ?", alertType, project, method).Count(&totalCount).Error
+
+	now := time.Now()
+	todayMidnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	tomorrowMidnight := todayMidnight.Add(24 * time.Hour)
+	err := global.AlertDB.Model(&model.AlertTask{}).Where("type =  ? AND quota_type = ?  AND method = ? AND created_at > ? AND created_at < ?", alertType, project, method, todayMidnight, tomorrowMidnight).Count(&todayCount).Error
+	return uint(todayCount), uint(totalCount), err
+}
+
+func (a *AlertRepo) GetTaskLog(alertType string, alertId uint) (time.Time, error) {
+	var newDate time.Time
+	status := []string{constant.AlertSuccess, constant.AlertPushSuccess, constant.AlertSyncError, constant.AlertPushing}
+	now := time.Now()
+	todayMidnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	tomorrowMidnight := todayMidnight.Add(24 * time.Hour)
+	err := global.AlertDB.Model(&model.AlertLog{}).
+		Where("type = ? AND alert_id = ? AND status in ? AND created_at > ? AND created_at < ?", alertType, alertId, status, todayMidnight, tomorrowMidnight).
+		Order("created_at DESC").
+		Limit(1).
+		Pluck("created_at", &newDate).Error
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	if newDate.IsZero() {
+		return time.Time{}, nil
+	}
+
+	return newDate, nil
+}
+
+func getAlertDB(opts ...DBOption) (*gorm.DB, error) {
+	var db *gorm.DB
+	db = global.AlertDB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	return db, nil
+}
+
+func (a *AlertRepo) GetLicensePushCount(method string) (uint, error) {
+	var (
+		todayCount int64
+	)
+	now := time.Now()
+	todayMidnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	tomorrowMidnight := todayMidnight.Add(24 * time.Hour)
+	err := global.AlertDB.Model(&model.AlertTask{}).Where("created_at > ? AND created_at < ? AND method = ?", todayMidnight, tomorrowMidnight, method).Count(&todayCount).Error
+	return uint(todayCount), err
+}
+
+func (a *AlertRepo) AlertConfigList(opts ...DBOption) ([]model.AlertConfig, error) {
+	var config []model.AlertConfig
+	db, _ := getAlertDB(opts...)
+	err := db.Find(&config).Error
+	return config, err
+}
+
+func (a *AlertRepo) UpdateAlertConfig(maps map[string]interface{}, opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Model(&model.AlertConfig{}).Updates(maps).Error
+}
+
+func (a *AlertRepo) CreateAlertConfig(config *model.AlertConfig) error {
+	return global.AlertDB.Model(&model.AlertConfig{}).Create(config).Error
+}
+
+func (a *AlertRepo) DeleteAlertConfig(opts ...DBOption) error {
+	db, _ := getAlertDB(opts...)
+	return db.Delete(&model.AlertConfig{}).Error
+}
+
+func (a *AlertRepo) GetConfig(opts ...DBOption) (model.AlertConfig, error) {
+	var alertConfig model.AlertConfig
+	db, _ := getAlertDB(opts...)
+	err := db.First(&alertConfig).Error
+	return alertConfig, err
+}
+
+func (a *AlertRepo) SyncAll(data []model.AlertConfig) error {
+	tx := global.AlertDB.Begin()
+	var oldConfigs []model.AlertConfig
+	_ = tx.Find(&oldConfigs).Error
+	oldConfigMap := make(map[string]uint)
+	for _, item := range oldConfigs {
+		oldConfigMap[item.Type] = item.ID
+	}
+	for _, item := range data {
+		if val, ok := oldConfigMap[item.Type]; ok {
+			item.ID = val
+			delete(oldConfigMap, item.Type)
+		} else {
+			item.ID = 0
+		}
+		if err := tx.Model(model.AlertConfig{}).Where("id = ?", item.ID).Save(&item).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+	for _, val := range oldConfigMap {
+		if err := tx.Where("id = ?", val).Delete(&model.AlertConfig{}).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+	tx.Commit()
+	return nil
+}

agent/app/repo/app_install.go

@@ -206,17 +206,17 @@ func (a *AppInstallRepo) LoadBaseInfo(key string, name string) (*RootInfo, error
 		return nil, err
 	}
 	switch app.Key {
-	case "mysql", "mariadb":
+	case "mysql", "mariadb", constant.AppMysqlCluster:
 		password, ok := envMap["PANEL_DB_ROOT_PASSWORD"].(string)
 		if ok {
 			info.Password = password
 		}
-	case "redis":
+	case "redis", constant.AppRedisCluster:
 		password, ok := envMap["PANEL_REDIS_ROOT_PASSWORD"].(string)
 		if ok {
 			info.Password = password
 		}
-	case "mongodb", constant.AppPostgresql:
+	case "mongodb", constant.AppPostgresql, constant.AppPostgresqlCluster:
 		user, ok := envMap["PANEL_DB_ROOT_USER"].(string)
 		if ok {
 			info.UserName = user

agent/app/service/alert.go

@@ -0,0 +1,507 @@
+package service
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/buserr"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/i18n"
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
+	"github.com/1Panel-dev/1Panel/agent/utils/copier"
+	"github.com/1Panel-dev/1Panel/agent/utils/email"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+	"github.com/shirou/gopsutil/v3/disk"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+type AlertService struct{}
+
+type IAlertService interface {
+	PageAlert(req dto.AlertSearch) (int64, []dto.AlertDTO, error)
+	GetAlerts() ([]dto.AlertDTO, error)
+	CreateAlert(create dto.AlertCreate) error
+	UpdateAlert(req dto.AlertUpdate) error
+	DeleteAlert(id uint) error
+	GetAlert(id uint) (dto.AlertDTO, error)
+	UpdateStatus(id uint, status string) error
+	ExternalUpdateAlert(req dto.AlertCreate) error
+
+	GetDisks() ([]dto.DiskDTO, error)
+	PageAlertLogs(req dto.AlertLogSearch) (int64, []dto.AlertLogDTO, error)
+	CleanAlertLogs() error
+	GetClams() ([]dto.ClamDTO, error)
+	GetCronJobs(req dto.CronJobReq) ([]dto.CronJobDTO, error)
+
+	GetAlertConfig() ([]model.AlertConfig, error)
+	UpdateAlertConfig(req dto.AlertConfigUpdate) error
+	DeleteAlertConfig(id uint) error
+	TestAlertConfig(req dto.AlertConfigTest) (bool, error)
+}
+
+func NewIAlertService() IAlertService {
+	return &AlertService{}
+}
+
+func (a AlertService) PageAlert(search dto.AlertSearch) (int64, []dto.AlertDTO, error) {
+	var (
+		opts   []repo.DBOption
+		result []dto.AlertDTO
+	)
+	if search.Status != "" {
+		opts = append(opts, repo.WithByStatus(search.Status))
+	}
+	if search.Type != "" {
+		opts = append(opts, alertRepo.WithByType(search.Type))
+	}
+	opts = append(opts, repo.WithOrderBy("created_at desc"))
+
+	total, alerts, err := alertRepo.Page(search.Page, search.PageSize, opts...)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	for _, item := range alerts {
+
+		result = append(result, dto.AlertDTO{
+			ID:        item.ID,
+			Type:      item.Type,
+			Cycle:     item.Cycle,
+			Count:     item.Count,
+			Method:    item.Method,
+			Title:     item.Title,
+			Project:   item.Project,
+			Status:    item.Status,
+			SendCount: item.SendCount,
+			CreatedAt: item.CreatedAt,
+			UpdatedAt: item.UpdatedAt,
+		})
+	}
+
+	return total, result, err
+}
+
+func (a AlertService) GetAlerts() ([]dto.AlertDTO, error) {
+	var (
+		opts   []repo.DBOption
+		result []dto.AlertDTO
+	)
+	opts = append(opts, repo.WithByStatus(constant.AlertEnable))
+	alerts, err := alertRepo.List(opts...)
+	if err != nil {
+		return nil, err
+	}
+	for _, item := range alerts {
+
+		result = append(result, dto.AlertDTO{
+			ID:        item.ID,
+			Type:      item.Type,
+			Cycle:     item.Cycle,
+			Count:     item.Count,
+			Method:    item.Method,
+			Title:     item.Title,
+			Project:   item.Project,
+			Status:    item.Status,
+			SendCount: item.SendCount,
+			CreatedAt: item.CreatedAt,
+			UpdatedAt: item.UpdatedAt,
+		})
+	}
+
+	return result, err
+}
+
+func (a AlertService) CreateAlert(create dto.AlertCreate) error {
+	var alertID uint
+	var alertInfo model.Alert
+	if create.Project != "" {
+		alertInfo, _ := alertRepo.Get(alertRepo.WithByType(create.Type), alertRepo.WithByProject(create.Project))
+		alertID = alertInfo.ID
+	} else {
+		alertInfo, _ := alertRepo.Get(alertRepo.WithByType(create.Type))
+		alertID = alertInfo.ID
+	}
+
+	if alertID != 0 {
+		var upAlert dto.AlertUpdate
+		if err := copier.Copy(&upAlert, &create); err != nil {
+			return buserr.WithErr("ErrStructTransform", err)
+		}
+		upAlert.ID = alertID
+		err := a.UpdateAlert(upAlert)
+		if err != nil {
+			return err
+		}
+	} else {
+		alertInfo.Status = constant.AlertEnable
+		if err := copier.Copy(&alertInfo, &create); err != nil {
+			return buserr.WithErr("ErrStructTransform", err)
+		}
+
+		if err := alertRepo.Create(&alertInfo); err != nil {
+			return err
+		}
+		NewIAlertTaskHelper().InitTask(alertInfo.Type)
+	}
+
+	return nil
+}
+
+func (a AlertService) UpdateAlert(req dto.AlertUpdate) error {
+
+	upMap := make(map[string]interface{})
+	upMap["id"] = req.ID
+	upMap["type"] = req.Type
+	upMap["cycle"] = req.Cycle
+	upMap["count"] = req.Count
+	upMap["method"] = req.Method
+	upMap["title"] = req.Title
+	upMap["project"] = req.Project
+	upMap["status"] = req.Status
+	upMap["send_count"] = req.SendCount
+
+	if err := alertRepo.Update(upMap, repo.WithByID(req.ID)); err != nil {
+		return err
+	}
+	NewIAlertTaskHelper().InitTask(req.Type)
+	return nil
+}
+
+func (a AlertService) DeleteAlert(id uint) error {
+	return alertRepo.Delete(repo.WithByID(id))
+}
+
+func (a AlertService) GetAlert(id uint) (dto.AlertDTO, error) {
+	var res dto.AlertDTO
+	alertInfo, err := alertRepo.Get(repo.WithByID(id))
+	if err != nil {
+		return res, err
+	}
+	_ = copier.Copy(&res, &alertInfo)
+	return res, nil
+}
+
+func (a AlertService) UpdateStatus(id uint, status string) error {
+	alertInfo, _ := alertRepo.Get(repo.WithByID(id))
+	if alertInfo.ID == 0 {
+		return buserr.New("ErrRecordNotFound")
+	}
+	err := alertRepo.Update(map[string]interface{}{"status": status}, repo.WithByID(alertInfo.ID))
+	if err != nil {
+		return err
+	}
+	alerts, err := a.GetAlerts()
+	if err != nil {
+		return err
+	}
+	if len(alerts) > 0 {
+		NewIAlertTaskHelper().InitTask(alertInfo.Type)
+	} else {
+		NewIAlertTaskHelper().StopTask()
+	}
+	return nil
+}
+
+func (a AlertService) GetDisks() ([]dto.DiskDTO, error) {
+	var disks []dto.DiskDTO
+	excludes := map[string]struct{}{
+		"/mnt/cdrom": {}, "/boot": {}, "/boot/efi": {}, "/dev": {}, "/dev/shm": {},
+		"/run/lock": {}, "/run": {}, "/run/shm": {}, "/run/user": {},
+	}
+	stdout, err := executeDiskCommand()
+	if err != nil {
+		return disks, nil
+	}
+
+	lines := strings.Split(stdout, "\n")
+	var mounts []dto.AlertDiskInfo
+
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 7 {
+			continue
+		}
+		mountPoint := strings.Join(fields[6:], " ")
+		if shouldExclude(fields, mountPoint, excludes) {
+			continue
+		}
+		mounts = append(mounts, dto.AlertDiskInfo{Type: fields[1], Device: fields[0], Mount: mountPoint})
+
+	}
+
+	var (
+		wg sync.WaitGroup
+		mu sync.Mutex
+	)
+	wg.Add(len(mounts))
+	for i := 0; i < len(mounts); i++ {
+		go func(timeoutCh <-chan time.Time, mount dto.AlertDiskInfo) {
+			defer wg.Done()
+
+			var itemData dto.DiskDTO
+			itemData.Path = mount.Mount
+			itemData.Type = mount.Type
+			itemData.Device = mount.Device
+			select {
+			case <-timeoutCh:
+				mu.Lock()
+				disks = append(disks, itemData)
+				mu.Unlock()
+				global.LOG.Errorf("load disk info from %s failed, err: timeout", mount.Mount)
+			default:
+				state, err := disk.Usage(mount.Mount)
+				if err != nil {
+					mu.Lock()
+					disks = append(disks, itemData)
+					mu.Unlock()
+					global.LOG.Errorf("load disk info from %s failed, err: %v", mount.Mount, err)
+					return
+				}
+				itemData.Total = state.Total
+				itemData.Free = state.Free
+				itemData.Used = state.Used
+				itemData.UsedPercent = state.UsedPercent
+				itemData.InodesTotal = state.InodesTotal
+				itemData.InodesUsed = state.InodesUsed
+				itemData.InodesFree = state.InodesFree
+				itemData.InodesUsedPercent = state.InodesUsedPercent
+				mu.Lock()
+				disks = append(disks, itemData)
+				mu.Unlock()
+			}
+		}(time.After(5*time.Second), mounts[i])
+	}
+	wg.Wait()
+
+	sort.Slice(disks, func(i, j int) bool {
+		return disks[i].Path < disks[j].Path
+	})
+	return disks, nil
+}
+
+func executeDiskCommand() (string, error) {
+	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(2 * time.Second))
+	stdout, err := cmdMgr.RunWithStdoutBashC("df -hT -P | grep '/' | grep -v tmpfs | grep -v 'snap/core' | grep -v udev")
+	if err != nil {
+		cmdMgr2 := cmd.NewCommandMgr(cmd.WithTimeout(1 * time.Second))
+		stdout, err = cmdMgr2.RunWithStdoutBashC("df -lhT -P | grep '/' | grep -v tmpfs | grep -v 'snap/core' | grep -v udev")
+	}
+	return stdout, err
+}
+
+func shouldExclude(fields []string, mountPoint string, excludes map[string]struct{}) bool {
+	if strings.HasPrefix(mountPoint, "/snap") || len(strings.Split(mountPoint, "/")) > 10 {
+		return true
+	}
+	if strings.TrimSpace(fields[1]) == "tmpfs" {
+		return true
+	}
+	if strings.Contains(fields[2], "K") {
+		return true
+	}
+	if strings.Contains(mountPoint, "docker") {
+		return true
+	}
+	_, excluded := excludes[mountPoint]
+	return excluded
+}
+
+func (a AlertService) PageAlertLogs(search dto.AlertLogSearch) (int64, []dto.AlertLogDTO, error) {
+	var (
+		opts   []repo.DBOption
+		result []dto.AlertLogDTO
+	)
+	if search.Status != "" {
+		opts = append(opts, repo.WithByStatus(search.Status))
+	}
+	if search.Count != 0 {
+		opts = append(opts, alertRepo.WithByCount(search.Count))
+	}
+	opts = append(opts, repo.WithOrderBy("created_at desc"))
+
+	total, alerts, err := alertRepo.PageLog(search.Page, search.PageSize, opts...)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	for _, item := range alerts {
+		alertLogDTO, err := a.parseAlertLog(item)
+		if err != nil {
+			return 0, nil, err
+		}
+		result = append(result, alertLogDTO)
+	}
+
+	return total, result, err
+}
+
+func (a AlertService) parseAlertLog(item model.AlertLog) (dto.AlertLogDTO, error) {
+	var alertDetail dto.AlertDetail
+	var alertRule dto.AlertRule
+
+	if err := unmarshalAlertInfo(item.AlertDetail, &alertDetail); err != nil {
+		return dto.AlertLogDTO{}, err
+	}
+	if err := unmarshalAlertInfo(item.AlertRule, &alertRule); err != nil {
+		return dto.AlertLogDTO{}, err
+	}
+	return dto.AlertLogDTO{
+		ID:          item.ID,
+		Count:       item.Count,
+		Type:        item.Type,
+		Status:      item.Status,
+		Method:      item.Method,
+		Message:     item.Message,
+		AlertId:     item.AlertId,
+		AlertDetail: alertDetail,
+		AlertRule:   alertRule,
+		CreatedAt:   item.CreatedAt,
+		UpdatedAt:   item.UpdatedAt,
+	}, nil
+}
+
+func unmarshalAlertInfo(data string, v interface{}) error {
+	if err := json.Unmarshal([]byte(data), v); err != nil {
+		return fmt.Errorf("unmarshal alert info vars failed, err: %v", err)
+	}
+	return nil
+}
+
+func (a AlertService) CleanAlertLogs() error {
+	return alertRepo.CleanAlertLogs()
+}
+
+func (a AlertService) GetClams() ([]dto.ClamDTO, error) {
+	var clams []dto.ClamDTO
+	clamList, err := clamRepo.List()
+
+	for _, clam := range clamList {
+		var clamDTO dto.ClamDTO
+		clamDTO.ID = clam.ID
+		clamDTO.Name = clam.Name
+		clamDTO.Path = clam.Path
+		clamDTO.Status = clam.Status
+		clamDTO.UpdatedAt = clam.UpdatedAt
+		clamDTO.CreatedAt = clam.CreatedAt
+		clams = append(clams, clamDTO)
+	}
+	return clams, err
+}
+
+func (a AlertService) GetCronJobs(req dto.CronJobReq) ([]dto.CronJobDTO, error) {
+	var cronJobs []dto.CronJobDTO
+	var (
+		opts []repo.DBOption
+	)
+	if req.Status != "" {
+		opts = append(opts, repo.WithByStatus(req.Status))
+	}
+	if req.Type != "" {
+		opts = append(opts, repo.WithByType(req.Type))
+	}
+	cronjobList, err := cronjobRepo.List(opts...)
+
+	for _, cronJob := range cronjobList {
+		var cronJobDTO dto.CronJobDTO
+		cronJobDTO.ID = cronJob.ID
+		cronJobDTO.Name = cronJob.Name
+		cronJobDTO.Status = cronJob.Status
+		cronJobDTO.Type = cronJob.Type
+		cronJobDTO.UpdatedAt = cronJob.UpdatedAt
+		cronJobDTO.CreatedAt = cronJob.CreatedAt
+		cronJobs = append(cronJobs, cronJobDTO)
+	}
+	return cronJobs, err
+}
+
+func (a AlertService) GetAlertConfig() ([]model.AlertConfig, error) {
+	var (
+		opts    []repo.DBOption
+		configs []model.AlertConfig
+	)
+	opts = append(opts, repo.WithByStatus(constant.AlertEnable))
+	configs, err := alertRepo.AlertConfigList(opts...)
+	return configs, err
+}
+
+func (a AlertService) UpdateAlertConfig(req dto.AlertConfigUpdate) error {
+	if req.ID != 0 {
+		upMap := make(map[string]interface{})
+		upMap["id"] = req.ID
+		upMap["type"] = req.Type
+		upMap["title"] = req.Title
+		upMap["status"] = req.Status
+		upMap["config"] = req.Config
+		if err := alertRepo.UpdateAlertConfig(upMap, repo.WithByID(req.ID)); err != nil {
+			return err
+		}
+	} else {
+		var alertConfig model.AlertConfig
+		if err := copier.Copy(&alertConfig, &req); err != nil {
+			return buserr.WithErr("ErrStructTransform", err)
+		}
+		if err := alertRepo.CreateAlertConfig(&alertConfig); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (a AlertService) DeleteAlertConfig(id uint) error {
+	return alertRepo.DeleteAlertConfig(repo.WithByID(id))
+}
+
+func (a AlertService) TestAlertConfig(req dto.AlertConfigTest) (bool, error) {
+	cfg := email.SMTPConfig{
+		Host:       req.Host,
+		Port:       req.Port,
+		Username:   req.Sender,
+		Password:   req.Password,
+		From:       fmt.Sprintf("%s <%s>", req.DisplayName, req.Sender),
+		Encryption: req.Encryption,
+		Recipient:  req.Recipient,
+	}
+
+	msg := email.EmailMessage{
+		Subject: i18n.GetMsgByKey("TestAlertTitle"),
+		Body:    i18n.GetMsgByKey("TestAlert"),
+		IsHTML:  false,
+	}
+	transport := xpack.LoadRequestTransport()
+	if err := email.SendMail(cfg, msg, transport); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (a AlertService) ExternalUpdateAlert(updateAlert dto.AlertCreate) error {
+	upMap := make(map[string]interface{})
+	if updateAlert.SendCount == 0 {
+		upMap["status"] = constant.AlertDisable
+	} else {
+		upMap["status"] = constant.AlertEnable
+		upMap["send_count"] = updateAlert.SendCount
+	}
+	upMap["method"] = updateAlert.Method
+	alertInfo, _ := alertRepo.Get(alertRepo.WithByType(updateAlert.Type), alertRepo.WithByProject(updateAlert.Project))
+	if alertInfo.ID > 0 {
+		if err := alertRepo.Update(upMap, alertRepo.WithByProject(updateAlert.Project), alertRepo.WithByType(updateAlert.Type)); err != nil {
+			return err
+		}
+	} else {
+		updateAlert.Status = constant.AlertEnable
+		err := a.CreateAlert(updateAlert)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

agent/app/service/alert_helper.go

@@ -0,0 +1,894 @@
+package service
+
+import (
+	"encoding/json"
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	versionUtil "github.com/1Panel-dev/1Panel/agent/utils/version"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	alertUtil "github.com/1Panel-dev/1Panel/agent/utils/alert"
+	"github.com/1Panel-dev/1Panel/agent/utils/common"
+	"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"
+)
+
+type AlertTaskHelper struct {
+	DiskIO chan []disk.IOCountersStat
+	NetIO  chan []net.IOCountersStat
+}
+
+type IAlertTaskHelper interface {
+	StopTask()
+	StartTask()
+	ResetTask()
+	InitTask(alertType string)
+}
+
+var cpuLoad1, cpuLoad5, cpuLoad15 []float64
+var memoryLoad1, memoryLoad5, memoryLoad15 []float64
+
+const ResourceAlertInterval = 30
+
+var baseTypes = map[string]bool{"ssl": true, "siteEndTime": true, "panelPwdEndTime": true, "panelUpdate": true}
+var resourceTypes = map[string]bool{"cpu": true, "memory": true, "disk": true, "load": true}
+
+func NewIAlertTaskHelper() IAlertTaskHelper {
+	return &AlertTaskHelper{}
+}
+func (m *AlertTaskHelper) StartTask() {
+	baseAlert, resourceAlert := handleTask()
+	if len(baseAlert) == 0 && len(resourceAlert) == 0 {
+		return
+	}
+	handleBaseAlerts(baseAlert)
+	handleResourceAlerts(resourceAlert)
+}
+
+func (m *AlertTaskHelper) StopTask() {
+	stopBaseJob()
+	stopResourceJob()
+}
+
+func (m *AlertTaskHelper) ResetTask() {
+	m.StopTask()
+	m.StartTask()
+}
+
+func (m *AlertTaskHelper) InitTask(alertType string) {
+	if alertType == "cpu" {
+		cpuLoad1 = []float64{}
+		cpuLoad5 = []float64{}
+		cpuLoad15 = []float64{}
+	}
+	if alertType == "memory" {
+		memoryLoad1 = []float64{}
+		memoryLoad5 = []float64{}
+		memoryLoad15 = []float64{}
+	}
+	if baseTypes[alertType] {
+		stopBaseJob()
+	} else if resourceTypes[alertType] {
+		stopResourceJob()
+	}
+	m.StartTask()
+}
+
+func resourceTask(resourceAlert []dto.AlertDTO) {
+	for _, alert := range resourceAlert {
+		if !alertUtil.CheckSendTimeRange(alert.Type) {
+			continue
+		}
+		switch alert.Type {
+		case "cpu":
+			loadCPUUsage(alert)
+		case "memory":
+			loadMemUsage(alert)
+		case "load":
+			loadLoadInfo(alert)
+		case "disk":
+			loadDiskUsage(alert)
+		default:
+		}
+	}
+}
+
+func baseTask(baseAlert []dto.AlertDTO) {
+	for _, alert := range baseAlert {
+		if !alertUtil.CheckSendTimeRange(alert.Type) {
+			continue
+		}
+		switch alert.Type {
+		case "ssl":
+			loadSSLInfo(alert)
+		case "siteEndTime":
+			loadWebsiteInfo(alert)
+		case "panelPwdEndTime":
+			if global.IsMaster {
+				loadPanelPwd(alert)
+			}
+		case "panelUpdate":
+			if global.IsMaster {
+				loadPanelUpdate(alert)
+			}
+		default:
+		}
+	}
+}
+
+func handleTask() (baseAlert []dto.AlertDTO, resourceAlert []dto.AlertDTO) {
+	alertList, _ := NewIAlertService().GetAlerts()
+	baseAlert, resourceAlert = classifyAlerts(alertList)
+	return baseAlert, resourceAlert
+}
+
+func classifyAlerts(alertList []dto.AlertDTO) (baseAlert, resourceAlert []dto.AlertDTO) {
+	for _, alert := range alertList {
+		if baseTypes[alert.Type] {
+			baseAlert = append(baseAlert, alert)
+		} else if resourceTypes[alert.Type] {
+			resourceAlert = append(resourceAlert, alert)
+		}
+	}
+	return
+}
+
+func handleBaseAlerts(baseAlert []dto.AlertDTO) {
+	if len(baseAlert) > 0 {
+		if global.AlertBaseJobID == 0 {
+			baseTask(baseAlert)
+			jobID, err := global.Cron.AddFunc("*/30 * * * *", func() {
+				baseTask(baseAlert)
+			})
+			if err != nil {
+				global.LOG.Errorf("alert base job start failed: %v", err)
+				return
+			}
+			global.AlertBaseJobID = jobID
+			global.LOG.Info("start alert base job")
+		}
+	} else {
+		stopBaseJob()
+	}
+}
+
+func handleResourceAlerts(resourceAlert []dto.AlertDTO) {
+	if len(resourceAlert) > 0 {
+		if global.AlertResourceJobID == 0 {
+			jobID, err := global.Cron.AddFunc("*/1 * * * *", func() {
+				resourceTask(resourceAlert)
+			})
+			if err != nil {
+				global.LOG.Errorf("alert resource job start failed: %v", err)
+				return
+			}
+			global.AlertResourceJobID = jobID
+			global.LOG.Info("start alert resource job")
+		}
+	} else {
+		stopResourceJob()
+	}
+}
+
+func stopBaseJob() {
+	if global.AlertBaseJobID != 0 {
+		global.Cron.Remove(global.AlertBaseJobID)
+		global.AlertBaseJobID = 0
+		global.LOG.Info("stop alert base job")
+	}
+}
+
+func stopResourceJob() {
+	if global.AlertResourceJobID != 0 {
+		global.Cron.Remove(global.AlertResourceJobID)
+		global.AlertResourceJobID = 0
+		global.LOG.Info("stop alert resource job")
+	}
+}
+
+func loadSSLInfo(alert dto.AlertDTO) {
+	var opts []repo.DBOption
+	if alert.Project != "all" {
+		itemID, _ := strconv.Atoi(alert.Project)
+		opts = append(opts, repo.WithByID(uint(itemID)))
+	}
+
+	sslList, _ := repo.NewISSLRepo().List(opts...)
+	currentDate := time.Now()
+	daysDifferenceMap := make(map[int][]string)
+	projectMap := make(map[uint][]time.Time)
+	for _, ssl := range sslList {
+		daysDifference := int(ssl.ExpireDate.Sub(currentDate).Hours() / 24)
+		if daysDifference > 0 && int(alert.Cycle) >= daysDifference {
+			daysDifferenceMap[daysDifference] = append(daysDifferenceMap[daysDifference], ssl.PrimaryDomain)
+			projectMap[ssl.ID] = append(projectMap[ssl.ID], ssl.ExpireDate)
+		}
+	}
+	projectJSON := serializeAndSortProjects(projectMap)
+	if projectJSON == "" {
+		return
+	}
+	if len(daysDifferenceMap) > 0 {
+		for daysDifference, ssl := range daysDifferenceMap {
+			primaryDomain := strings.Join(ssl, ",")
+			var params []dto.Param
+			params = createAlertBaseParams(strconv.Itoa(len(ssl)), strconv.Itoa(daysDifference))
+			methods := strings.Split(alert.Method, ",")
+			for _, m := range methods {
+				m = strings.TrimSpace(m)
+				switch m {
+				case constant.SMS:
+					todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, projectJSON, constant.SMS)
+					if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+						continue
+					}
+					create := dto.AlertLogCreate{
+						Status:  constant.AlertSuccess,
+						Count:   totalCount + 1,
+						AlertId: alert.ID,
+						Type:    alert.Type,
+					}
+					if !alertUtil.CheckTaskFrequency(constant.SMS) {
+						continue
+					}
+					_ = xpack.CreateSMSAlertLog(alert, create, primaryDomain, params, constant.SMS)
+					alertUtil.CreateNewAlertTask(alert.Project, alert.Type, projectJSON, constant.SMS)
+				case constant.Email:
+					todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, projectJSON, constant.Email)
+					if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+						continue
+					}
+					create := dto.AlertLogCreate{
+						Status:  constant.AlertSuccess,
+						Count:   totalCount + 1,
+						AlertId: alert.ID,
+						Type:    alert.Type,
+					}
+					alertDetail := alertUtil.ProcessAlertDetail(alert, primaryDomain, params, constant.Email)
+					alertRule := alertUtil.ProcessAlertRule(alert)
+					create.AlertRule = alertRule
+					create.AlertDetail = alertDetail
+					transport := xpack.LoadRequestTransport()
+					_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+					alertUtil.CreateNewAlertTask(alert.Project, alert.Type, projectJSON, constant.Email)
+				default:
+				}
+			}
+		}
+		global.LOG.Info("SSL alert push successful")
+	}
+}
+
+func loadWebsiteInfo(alert dto.AlertDTO) {
+	var opts []repo.DBOption
+	if alert.Project != "all" {
+		itemID, _ := strconv.Atoi(alert.Project)
+		opts = append(opts, repo.WithByID(uint(itemID)))
+	}
+
+	websiteList, _ := websiteRepo.List(opts...)
+	currentDate := time.Now()
+	daysDifferenceMap := make(map[int][]string)
+	projectMap := make(map[uint][]time.Time)
+	for _, website := range websiteList {
+		daysDifference := int(website.ExpireDate.Sub(currentDate).Hours() / 24)
+		if daysDifference > 0 && int(alert.Cycle) >= daysDifference {
+			daysDifferenceMap[daysDifference] = append(daysDifferenceMap[daysDifference], website.PrimaryDomain)
+			projectMap[website.ID] = append(projectMap[website.ID], website.ExpireDate)
+		}
+	}
+	projectJSON := serializeAndSortProjects(projectMap)
+	if projectJSON == "" {
+		return
+	}
+	if len(daysDifferenceMap) > 0 {
+		methods := strings.Split(alert.Method, ",")
+		for daysDifference, websites := range daysDifferenceMap {
+			primaryDomain := strings.Join(websites, ",")
+			var params []dto.Param
+			params = createAlertBaseParams(strconv.Itoa(len(websites)), strconv.Itoa(daysDifference))
+			for _, m := range methods {
+				m = strings.TrimSpace(m)
+				switch m {
+				case constant.SMS:
+					if !alertUtil.CheckTaskFrequency(constant.SMS) {
+						continue
+					}
+					todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, projectJSON, constant.SMS)
+					if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+						continue
+					}
+					create := dto.AlertLogCreate{
+						Status:  constant.AlertSuccess,
+						Count:   totalCount + 1,
+						AlertId: alert.ID,
+						Type:    alert.Type,
+					}
+					_ = xpack.CreateSMSAlertLog(alert, create, primaryDomain, params, constant.SMS)
+					alertUtil.CreateNewAlertTask(alert.Project, alert.Type, projectJSON, constant.SMS)
+				case constant.Email:
+					todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, projectJSON, constant.Email)
+					if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+						continue
+					}
+					create := dto.AlertLogCreate{
+						Status:  constant.AlertSuccess,
+						Count:   totalCount + 1,
+						AlertId: alert.ID,
+						Type:    alert.Type,
+					}
+					alertDetail := alertUtil.ProcessAlertDetail(alert, primaryDomain, params, constant.Email)
+					alertRule := alertUtil.ProcessAlertRule(alert)
+					create.AlertDetail = alertDetail
+					create.AlertRule = alertRule
+					transport := xpack.LoadRequestTransport()
+					_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+					alertUtil.CreateNewAlertTask(alert.Project, alert.Type, projectJSON, constant.Email)
+				default:
+				}
+			}
+		}
+		global.LOG.Info("website expiration alert push successful")
+	}
+}
+
+func loadPanelPwd(alert dto.AlertDTO) {
+	// only master alert
+	var expirationDays model.Setting
+	if err := global.CoreDB.Model(&model.Setting{}).Where("key = ?", "ExpirationDays").First(&expirationDays).Error; err != nil {
+		global.LOG.Errorf("load %s from db setting failed, err: %v", "ExpirationDays", err)
+		return
+	}
+	if expirationDays.Value == "0" {
+		global.LOG.Info("panel password expiration setting not enabled, skip")
+		return
+	}
+	var expirationTime model.Setting
+	if err := global.CoreDB.Model(&model.Setting{}).Where("key = ?", "ExpirationTime").First(&expirationTime).Error; err != nil {
+		global.LOG.Errorf("load %s from db setting failed, err: %v", "ExpirationTime", err)
+		return
+	}
+
+	var params []dto.Param
+	defaultDate, _ := time.Parse(constant.DateTimeLayout, expirationTime.Value)
+	daysDifference := calculateDaysDifference(defaultDate)
+	if daysDifference >= 0 && int(alert.Cycle) >= daysDifference {
+		params = createAlertPwdParams(strconv.Itoa(daysDifference))
+		methods := strings.Split(alert.Method, ",")
+		for _, m := range methods {
+			m = strings.TrimSpace(m)
+			switch m {
+			case constant.SMS:
+				if !alertUtil.CheckTaskFrequency(constant.SMS) {
+					continue
+				}
+				todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, expirationTime.Value, constant.SMS)
+				if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+					continue
+				}
+				create := dto.AlertLogCreate{
+					Count:   totalCount + 1,
+					AlertId: alert.ID,
+					Type:    alert.Type,
+				}
+				_ = xpack.CreateSMSAlertLog(alert, create, strconv.Itoa(daysDifference), params, constant.SMS)
+				alertUtil.CreateNewAlertTask(expirationTime.Value, alert.Type, expirationTime.Value, constant.SMS)
+			case constant.Email:
+				todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, expirationTime.Value, constant.Email)
+				if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+					continue
+				}
+				create := dto.AlertLogCreate{
+					Count:   totalCount + 1,
+					AlertId: alert.ID,
+					Type:    alert.Type,
+				}
+				alertDetail := alertUtil.ProcessAlertDetail(alert, strconv.Itoa(daysDifference), params, constant.Email)
+				alertRule := alertUtil.ProcessAlertRule(alert)
+				create.AlertRule = alertRule
+				create.AlertDetail = alertDetail
+				transport := xpack.LoadRequestTransport()
+				_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+				alertUtil.CreateNewAlertTask(expirationTime.Value, alert.Type, expirationTime.Value, constant.Email)
+			default:
+			}
+		}
+		global.LOG.Info("panel password expiration alert push successful")
+	}
+}
+
+func loadPanelUpdate(alert dto.AlertDTO) {
+	// only master alert
+	info, err := versionUtil.GetUpgradeVersionInfo()
+	if err != nil {
+		global.LOG.Errorf("error getting version, err: %s", err)
+		return
+	}
+
+	// 获取版本信息
+	var version string
+	// 检查哪个版本字段不为空，并赋值
+	if info.NewVersion != "" {
+		version = info.NewVersion
+	} else if info.TestVersion != "" {
+		version = info.TestVersion
+	} else if info.LatestVersion != "" {
+		version = info.LatestVersion
+	}
+	if version == "" {
+		return
+	}
+
+	var params []dto.Param
+	methods := strings.Split(alert.Method, ",")
+	for _, m := range methods {
+		m = strings.TrimSpace(m)
+		switch m {
+		case constant.SMS:
+			if !alertUtil.CheckTaskFrequency(constant.SMS) {
+				continue
+			}
+			todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, version, constant.SMS)
+			if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+				continue
+			}
+			var create = dto.AlertLogCreate{
+				Type:    alert.Type,
+				AlertId: alert.ID,
+				Count:   totalCount + 1,
+			}
+			_ = xpack.CreateSMSAlertLog(alert, create, version, params, constant.SMS)
+			alertUtil.CreateNewAlertTask(version, alert.Type, version, constant.SMS)
+		case constant.Email:
+			todayCount, totalCount, err := alertRepo.LoadTaskCount(alert.Type, version, constant.Email)
+			if err != nil || todayCount >= 1 || alert.SendCount <= totalCount {
+				continue
+			}
+			var create = dto.AlertLogCreate{
+				Type:    alert.Type,
+				AlertId: alert.ID,
+				Count:   totalCount + 1,
+			}
+			alertDetail := alertUtil.ProcessAlertDetail(alert, version, params, constant.Email)
+			alertRule := alertUtil.ProcessAlertRule(alert)
+			create.AlertRule = alertRule
+			create.AlertDetail = alertDetail
+			transport := xpack.LoadRequestTransport()
+			_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+			alertUtil.CreateNewAlertTask(version, alert.Type, version, constant.Email)
+		default:
+		}
+	}
+	global.LOG.Info("panel update alert push successful")
+}
+
+// 获取 CPU 使用率数据并发送到通道
+func loadCPUUsage(alert dto.AlertDTO) {
+	percent, err := cpu.Percent(3*time.Second, false)
+	if err != nil {
+		global.LOG.Errorf("error getting cpu usage, err: %v", err)
+		return
+	}
+
+	if len(percent) > 0 {
+		var cpuLoad *[]float64
+		var threshold int
+
+		switch alert.Cycle {
+		case 1:
+			cpuLoad = &cpuLoad1
+			threshold = 1
+		case 5:
+			cpuLoad = &cpuLoad5
+			threshold = 5
+		case 15:
+			cpuLoad = &cpuLoad15
+			threshold = 15
+		default:
+			return
+		}
+
+		if checkAndSendAlert(alert, percent[0], cpuLoad, threshold) {
+			global.LOG.Info("cpu alert push successful")
+		}
+	}
+
+}
+
+// 获取内存使用情况数据并发送到通道
+func loadMemUsage(alert dto.AlertDTO) {
+
+	memStat, err := mem.VirtualMemory()
+	if err != nil {
+		global.LOG.Errorf("error getting memory usage, err: %v", err)
+		return
+	}
+
+	percent := memStat.UsedPercent
+	var memoryLoad *[]float64
+	var threshold int
+
+	switch alert.Cycle {
+	case 1:
+		memoryLoad = &memoryLoad1
+		threshold = 1
+	case 5:
+		memoryLoad = &memoryLoad5
+		threshold = 5
+	case 15:
+		memoryLoad = &memoryLoad15
+		threshold = 15
+	default:
+		return
+	}
+	if checkAndSendAlert(alert, percent, memoryLoad, threshold) {
+		global.LOG.Info("memory alert push successful")
+	}
+}
+
+// 获取系统负载数据并发送到通道
+func loadLoadInfo(alert dto.AlertDTO) {
+	avgStat, err := load.Avg()
+	if err != nil {
+		global.LOG.Errorf("error getting load usage, err: %v", err)
+		return
+	}
+	var loadValue float64
+	CPUTotal, _ := cpu.Counts(true)
+	switch alert.Cycle {
+	case 1:
+		loadValue = avgStat.Load1 / (float64(CPUTotal*2) * 0.75) * 100
+	case 5:
+		loadValue = avgStat.Load5 / (float64(CPUTotal*2) * 0.75) * 100
+	case 15:
+		loadValue = avgStat.Load15 / (float64(CPUTotal*2) * 0.75) * 100
+	default:
+		return
+	}
+	newDate, err := alertRepo.GetTaskLog(alert.Type, alert.ID)
+	if err != nil {
+		global.LOG.Errorf("task log record not found, err: %v", err)
+	}
+	if newDate.IsZero() || calculateMinutesDifference(newDate) > ResourceAlertInterval {
+		if loadValue >= float64(alert.Count) {
+			global.LOG.Infof("%d minute load: %f,detail: %v", alert.Cycle, loadValue, avgStat)
+			createAndLogAlert(alert, loadValue)
+			global.LOG.Info("load alert task push successful")
+		}
+	}
+}
+
+// 内存/cpu检查是否需要发送告警并处理相关逻辑
+func checkAndSendAlert(alert dto.AlertDTO, currentUsage float64, usageLoad *[]float64, threshold int) bool {
+	newDate, err := alertRepo.GetTaskLog(alert.Type, alert.ID)
+	if err != nil {
+		global.LOG.Errorf("record not found, err: %v", err)
+		return false
+	}
+
+	*usageLoad = append(*usageLoad, currentUsage)
+
+	if len(*usageLoad) > threshold {
+		*usageLoad = (*usageLoad)[1:]
+	}
+
+	if newDate.IsZero() || calculateMinutesDifference(newDate) > ResourceAlertInterval {
+		if len(*usageLoad) == threshold {
+			avgUsage := average(*usageLoad)
+			if avgUsage >= float64(alert.Count) {
+				global.LOG.Infof("%d minute %s: %f , usage: %v", threshold, alert.Type, avgUsage, usageLoad)
+				createAndLogAlert(alert, avgUsage)
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// 检查是否超过今日发送次数限制
+func checkTaskFrequency(alertType, quotaType string, sendCount uint, method string) (uint, bool) {
+	todayCount, _, err := alertRepo.LoadTaskCount(alertType, quotaType, method)
+	if err != nil {
+		global.LOG.Errorf("error getting task info, err: %v", err)
+		return todayCount, false
+	}
+	if todayCount >= sendCount {
+		return todayCount, false
+	}
+
+	return todayCount, true
+}
+
+// 创建告警日志和详情
+func createAndLogAlert(alert dto.AlertDTO, avgUsage float64) {
+	avgUsagePercent := common.FormatPercent(avgUsage)
+	params := createAlertAvgParams(strconv.Itoa(int(alert.Cycle)), getModule(alert.Type), avgUsagePercent)
+	methods := strings.Split(alert.Method, ",")
+	for _, m := range methods {
+		m = strings.TrimSpace(m)
+		switch m {
+		case constant.SMS:
+			if !alertUtil.CheckTaskFrequency(constant.SMS) {
+				continue
+			}
+			todayCount, isValid := checkTaskFrequency(alert.Type, strconv.Itoa(int(alert.Cycle)), alert.SendCount, constant.SMS)
+			if !isValid {
+				continue
+			}
+			create := dto.AlertLogCreate{
+				Status:  constant.AlertSuccess,
+				Count:   todayCount + 1,
+				AlertId: alert.ID,
+				Type:    alert.Type,
+			}
+			_ = xpack.CreateSMSAlertLog(alert, create, avgUsagePercent, params, constant.SMS)
+			alertUtil.CreateNewAlertTask(avgUsagePercent, alert.Type, strconv.Itoa(int(alert.Cycle)), constant.SMS)
+		case constant.Email:
+			todayCount, isValid := checkTaskFrequency(alert.Type, strconv.Itoa(int(alert.Cycle)), alert.SendCount, constant.Email)
+			if !isValid {
+				continue
+			}
+			create := dto.AlertLogCreate{
+				Status:  constant.AlertSuccess,
+				Count:   todayCount + 1,
+				AlertId: alert.ID,
+				Type:    alert.Type,
+			}
+			alertDetail := alertUtil.ProcessAlertDetail(alert, avgUsagePercent, params, constant.Email)
+			alertRule := alertUtil.ProcessAlertRule(alert)
+			create.AlertRule = alertRule
+			create.AlertDetail = alertDetail
+			transport := xpack.LoadRequestTransport()
+			_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+			alertUtil.CreateNewAlertTask(avgUsagePercent, alert.Type, strconv.Itoa(int(alert.Cycle)), constant.Email)
+		default:
+		}
+	}
+}
+
+func getModule(alertType string) string {
+	var module string
+	switch alertType {
+	case "cpu":
+		module = " CPU "
+	case "memory":
+		module = "内存"
+	case "load":
+		module = "负载"
+	default:
+	}
+	return module
+}
+
+func loadDiskUsage(alert dto.AlertDTO) {
+	newDate, err := alertRepo.GetTaskLog(alert.Type, alert.ID)
+	if err != nil {
+		global.LOG.Errorf("record not found, err: %v", err)
+	}
+
+	if newDate.IsZero() || calculateMinutesDifference(newDate) > ResourceAlertInterval {
+		if strings.Contains(alert.Project, "all") {
+			err = processAllDisks(alert)
+		} else {
+			err = processSingleDisk(alert)
+		}
+		if err != nil {
+			global.LOG.Errorf("error processing disk usage, err: %v", err)
+		}
+	}
+}
+
+func processAllDisks(alert dto.AlertDTO) error {
+	diskList, err := NewIAlertService().GetDisks()
+	if err != nil {
+		global.LOG.Errorf("error getting disk list, err: %v", err)
+		return err
+	}
+
+	var flag bool
+	for _, item := range diskList {
+		if success, err := checkAndCreateDiskAlert(alert, item.Path); err == nil && success {
+			flag = true
+		}
+	}
+	if flag {
+		global.LOG.Info("all disk alert push successful")
+	}
+	return nil
+}
+
+func processSingleDisk(alert dto.AlertDTO) error {
+	success, err := checkAndCreateDiskAlert(alert, alert.Project)
+	if err != nil {
+		return err
+	}
+	if success {
+		global.LOG.Info("disk alert push successful")
+	}
+	return nil
+}
+
+func checkAndCreateDiskAlert(alert dto.AlertDTO, path string) (bool, error) {
+	usageStat, err := disk.Usage(path)
+	if err != nil {
+		global.LOG.Errorf("error getting disk usage for %s, err: %v", path, err)
+		return false, err
+	}
+
+	usedTotal, usedStr := calculateUsedTotal(alert.Cycle, usageStat)
+	commonTotal := float64(alert.Count)
+	if alert.Cycle == 1 {
+		commonTotal *= 1024 * 1024 * 1024
+	}
+	if usedTotal < commonTotal {
+		return false, nil
+	}
+	global.LOG.Infof("disk「 %s 」usage: %s", path, usedStr)
+	var params []dto.Param
+	params = createAlertDiskParams(path, usedStr)
+	methods := strings.Split(alert.Method, ",")
+	for _, m := range methods {
+		m = strings.TrimSpace(m)
+		switch m {
+		case constant.SMS:
+			if !alertUtil.CheckTaskFrequency(constant.SMS) {
+				continue
+			}
+			todayCount, isValid := checkTaskFrequency(alert.Type, alert.Project, alert.SendCount, constant.SMS)
+			if !isValid {
+				continue
+			}
+			create := dto.AlertLogCreate{
+				Status:  constant.AlertSuccess,
+				Count:   todayCount + 1,
+				AlertId: alert.ID,
+				Type:    alert.Type,
+			}
+			_ = xpack.CreateSMSAlertLog(alert, create, path, params, constant.SMS)
+			alertUtil.CreateNewAlertTask(strconv.Itoa(int(alert.Cycle)), alert.Type, alert.Project, constant.SMS)
+		case constant.Email:
+			todayCount, isValid := checkTaskFrequency(alert.Type, alert.Project, alert.SendCount, constant.Email)
+			if !isValid {
+				continue
+			}
+			create := dto.AlertLogCreate{
+				Status:  constant.AlertSuccess,
+				Count:   todayCount + 1,
+				AlertId: alert.ID,
+				Type:    alert.Type,
+			}
+			alertDetail := alertUtil.ProcessAlertDetail(alert, path, params, constant.Email)
+			alertRule := alertUtil.ProcessAlertRule(alert)
+			create.AlertRule = alertRule
+			create.AlertDetail = alertDetail
+			transport := xpack.LoadRequestTransport()
+			_ = alertUtil.CreateEmailAlertLog(create, alert, params, transport)
+			alertUtil.CreateNewAlertTask(strconv.Itoa(int(alert.Cycle)), alert.Type, alert.Project, constant.Email)
+		default:
+		}
+	}
+
+	return true, nil
+}
+
+func calculateUsedTotal(cycle uint, usageStat *disk.UsageStat) (float64, string) {
+	if cycle == 1 {
+		return float64(usageStat.Used), common.FormatBytes(usageStat.Used)
+	}
+	return usageStat.UsedPercent, common.FormatPercent(usageStat.UsedPercent)
+}
+
+func calculateDaysDifference(expirationTime time.Time) int {
+	currentDate := time.Now()
+	formattedTime := currentDate.Format(constant.DateTimeLayout)
+	parsedTime, _ := time.Parse(constant.DateTimeLayout, formattedTime)
+	timeGap := expirationTime.Sub(parsedTime).Milliseconds()
+	if timeGap < 0 {
+		return -1
+	}
+	daysDifference := int(math.Floor(float64(timeGap) / (3600 * 1000 * 24)))
+	return daysDifference
+}
+
+func calculateMinutesDifference(newDate time.Time) int {
+	now := time.Now()
+	if newDate.After(now) {
+		return -1
+	}
+	minutesDifference := int(now.Sub(newDate).Minutes())
+	return minutesDifference
+}
+
+func average(arr []float64) float64 {
+	total := 0.0
+	for _, v := range arr {
+		total += v
+	}
+	return total / float64(len(arr))
+}
+
+func createAlertBaseParams(project, cycle string) []dto.Param {
+	return []dto.Param{
+		{
+			Index: "1",
+			Key:   "project",
+			Value: project,
+		},
+		{
+			Index: "2",
+			Key:   "cycle",
+			Value: cycle,
+		},
+	}
+}
+
+func createAlertPwdParams(cycle string) []dto.Param {
+	return []dto.Param{
+		{
+			Index: "1",
+			Key:   "cycle",
+			Value: cycle,
+		},
+	}
+}
+
+func createAlertAvgParams(cycle, module, count string) []dto.Param {
+	return []dto.Param{
+		{
+			Index: "1",
+			Key:   "cycle",
+			Value: cycle,
+		},
+		{
+			Index: "2",
+			Key:   "module",
+			Value: module,
+		},
+		{
+			Index: "3",
+			Key:   "count",
+			Value: count,
+		},
+	}
+}
+
+func createAlertDiskParams(project, count string) []dto.Param {
+	return []dto.Param{
+		{
+			Index: "1",
+			Key:   "project",
+			Value: project,
+		},
+		{
+			Index: "2",
+			Key:   "count",
+			Value: count,
+		},
+	}
+}
+
+func serializeAndSortProjects(projectMap map[uint][]time.Time) string {
+	keys := make([]int, 0, len(projectMap))
+	for k := range projectMap {
+		keys = append(keys, int(k))
+	}
+	sort.Ints(keys)
+	projectJSON, err := json.Marshal(projectMap)
+	if err != nil {
+		global.LOG.Errorf("Failed to serialize projectMap: %v", err)
+		return ""
+	}
+
+	return string(projectJSON)
+}

agent/app/service/app.go

@@ -483,6 +483,7 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 			req.Params["PANEL_DB_HOST"] = database.Address
 			req.Params["PANEL_DB_PORT"] = database.Port
 			req.Params["PANEL_DB_HOST_NAME"] = hostName
+			req.Params["DATABASE_NAME"] = database.Name
 		}
 	}
 	paramByte, err = json.Marshal(req.Params)

agent/app/service/app_install.go

@@ -14,29 +14,25 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/1Panel-dev/1Panel/agent/utils/files"
-	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
-	"github.com/docker/docker/api/types"
-	"gopkg.in/yaml.v3"
-
-	"github.com/1Panel-dev/1Panel/agent/utils/env"
-	"github.com/1Panel-dev/1Panel/agent/utils/nginx"
-	"github.com/joho/godotenv"
-
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
 	"github.com/1Panel-dev/1Panel/agent/app/dto/response"
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-
-	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
+	"github.com/1Panel-dev/1Panel/agent/utils/env"
+	"github.com/1Panel-dev/1Panel/agent/utils/files"
+	"github.com/1Panel-dev/1Panel/agent/utils/nginx"
+	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
+	"github.com/docker/docker/api/types/container"
+	"github.com/joho/godotenv"
 	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
 )
 
 type AppInstallService struct {
@@ -60,6 +56,7 @@ type IAppInstallService interface {
 
 	UpdateAppConfig(req request.AppConfigUpdate) error
 	GetInstallList() ([]dto.AppInstallInfo, error)
+	GetAppInstallInfo(appInstallID uint) (*response.AppInstallInfo, error)
 }
 
 func NewIAppInstalledService() IAppInstallService {
@@ -124,7 +121,7 @@ func (a *AppInstallService) Page(req request.AppInstalledSearch) (int64, []respo
 		}
 	}
 
-	installDTOs, err := handleInstalled(installs, req.Update, req.Sync)
+	installDTOs, _ := handleInstalled(installs, req.Update, req.Sync)
 	if req.Update {
 		total = int64(len(installDTOs))
 	}
@@ -476,10 +473,20 @@ func (a *AppInstallService) SyncAll(systemInit bool) error {
 func (a *AppInstallService) GetServices(key string) ([]response.AppService, error) {
 	var res []response.AppService
 	if DatabaseKeys[key] > 0 {
+		types := []string{key}
 		if key == constant.AppPostgres {
 			key = constant.AppPostgresql
 		}
-		dbs, _ := databaseRepo.GetList(repo.WithByType(key))
+		switch key {
+		case constant.AppMysql:
+			types = []string{constant.AppMysql, constant.AppMysqlCluster}
+		case constant.AppPostgresql:
+			types = []string{constant.AppPostgresql, constant.AppPostgresqlCluster}
+		case constant.AppRedis:
+			types = []string{constant.AppRedis, constant.AppRedisCluster}
+		}
+
+		dbs, _ := databaseRepo.GetList(repo.WithTypes(types))
 		if len(dbs) == 0 {
 			return res, nil
 		}
@@ -635,10 +642,14 @@ func (a *AppInstallService) DeleteCheck(installID uint) ([]dto.AppResource, erro
 	resources, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithLinkId(appInstall.ID), repo.WithByFrom(constant.AppResourceLocal))
 	for _, resource := range resources {
 		linkInstall, _ := appInstallRepo.GetFirst(repo.WithByID(resource.AppInstallId))
-		res = append(res, dto.AppResource{
-			Type: "app",
-			Name: linkInstall.Name,
-		})
+		if linkInstall.ID > 0 {
+			res = append(res, dto.AppResource{
+				Type: "app",
+				Name: linkInstall.Name,
+			})
+		} else {
+			_ = appInstallResourceRepo.DeleteBy(context.Background(), appInstallResourceRepo.WithAppInstallId(resource.AppInstallId))
+		}
 	}
 	return res, nil
 }
@@ -658,7 +669,7 @@ func (a *AppInstallService) GetDefaultConfigByKey(key, name string) (string, err
 		return "", buserr.New("ErrPathNotFound")
 	}
 
-	if key == constant.AppMysql || key == constant.AppMariaDB {
+	if key == constant.AppMysql || key == constant.AppMariaDB || key == constant.AppMysqlCluster {
 		filePath = path.Join(filePath, "my.cnf")
 	}
 	if key == constant.AppRedis {
@@ -703,12 +714,14 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 				Rule:     form.Rule,
 				Type:     form.Type,
 				Multiple: form.Multiple,
+				Required: form.Required,
 			}
 			if form.Edit {
 				appParam.Edit = true
 			}
 			appParam.LabelZh = form.LabelZh
 			appParam.LabelEn = form.LabelEn
+			appParam.Label = form.Label
 			appParam.Value = v
 			if form.Type == "service" {
 				appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithServiceName(v.(string)))
@@ -761,6 +774,8 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 				Value:    form.Default,
 				Values:   form.Values,
 				Multiple: form.Multiple,
+				Required: form.Required,
+				Label:    form.Label,
 			})
 		}
 	}
@@ -789,15 +804,15 @@ func syncAppInstallStatus(appInstall *model.AppInstall, force bool) error {
 	defer cli.Close()
 
 	var (
-		containers     []types.Container
-		containersMap  map[string]types.Container
+		containers     []container.Summary
+		containersMap  map[string]container.Summary
 		containerNames = strings.Split(appInstall.ContainerName, ",")
 	)
 	containers, err = cli.ListContainersByName(containerNames)
 	if err != nil {
 		return err
 	}
-	containersMap = make(map[string]types.Container)
+	containersMap = make(map[string]container.Summary)
 	for _, con := range containers {
 		containersMap[con.Names[0]] = con
 	}
@@ -896,3 +911,31 @@ func updateInstallInfoInDB(appKey, appName, param string, value interface{}) err
 	}
 	return nil
 }
+
+func (a *AppInstallService) GetAppInstallInfo(installID uint) (*response.AppInstallInfo, error) {
+	appInstall, _ := appInstallRepo.GetFirst(repo.WithByID(installID))
+	if appInstall.ID == 0 {
+		return &response.AppInstallInfo{
+			Status: constant.StatusDeleted,
+		}, nil
+	}
+	_ = syncAppInstallStatus(&appInstall, false)
+	appInstall, _ = appInstallRepo.GetFirst(repo.WithByID(installID))
+	var envMap map[string]interface{}
+	err := json.Unmarshal([]byte(appInstall.Env), &envMap)
+	if err != nil {
+		return nil, err
+	}
+	res := &response.AppInstallInfo{
+		ID:          appInstall.ID,
+		Name:        appInstall.Name,
+		Version:     appInstall.Version,
+		Container:   appInstall.ContainerName,
+		HttpPort:    appInstall.HttpPort,
+		Status:      appInstall.Status,
+		Message:     appInstall.Message,
+		Env:         envMap,
+		ComposePath: appInstall.GetComposePath(),
+	}
+	return res, nil
+}

agent/app/service/app_utils.go

@@ -18,41 +18,33 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-	"github.com/1Panel-dev/1Panel/agent/utils/nginx"
-	"github.com/1Panel-dev/1Panel/agent/utils/nginx/parser"
-	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
-
-	"github.com/1Panel-dev/1Panel/agent/app/task"
-
-	"github.com/docker/docker/api/types"
-
-	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
-	"github.com/docker/docker/api/types/container"
-
-	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
-
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
-	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
-	"github.com/1Panel-dev/1Panel/agent/i18n"
-	"github.com/subosito/gotenv"
-	"gopkg.in/yaml.v3"
-
-	"github.com/1Panel-dev/1Panel/agent/utils/env"
-
-	"github.com/1Panel-dev/1Panel/agent/app/dto/response"
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
+	"github.com/1Panel-dev/1Panel/agent/app/dto/response"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/app/task"
+	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/i18n"
+	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
 	composeV2 "github.com/1Panel-dev/1Panel/agent/utils/docker"
+	"github.com/1Panel-dev/1Panel/agent/utils/env"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
+	"github.com/1Panel-dev/1Panel/agent/utils/nginx"
+	"github.com/1Panel-dev/1Panel/agent/utils/nginx/parser"
+	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/docker/api/types/container"
 	"github.com/pkg/errors"
+	"github.com/subosito/gotenv"
+	"gopkg.in/yaml.v3"
 )
 
 type DatabaseOp string
@@ -124,13 +116,16 @@ func checkPortExist(port int) error {
 }
 
 var DatabaseKeys = map[string]uint{
-	constant.AppMysql:      3306,
-	constant.AppMariaDB:    3306,
-	constant.AppPostgresql: 5432,
-	constant.AppPostgres:   5432,
-	constant.AppMongodb:    27017,
-	constant.AppRedis:      6379,
-	constant.AppMemcached:  11211,
+	constant.AppMysql:             3306,
+	constant.AppMariaDB:           3306,
+	constant.AppPostgresql:        5432,
+	constant.AppPostgres:          5432,
+	constant.AppMongodb:           27017,
+	constant.AppRedis:             6379,
+	constant.AppMemcached:         11211,
+	constant.AppMysqlCluster:      3306,
+	constant.AppPostgresqlCluster: 5432,
+	constant.AppRedisCluster:      6379,
 }
 
 var ToolKeys = map[string]uint{
@@ -146,7 +141,6 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 		}
 		_ = deleteLink(del)
 	}
-	var dbConfig dto.AppDatabase
 	if DatabaseKeys[app.Key] > 0 {
 		handleDataBaseApp := func(task *task.Task) error {
 			database := &model.Database{
@@ -178,11 +172,11 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 			}
 
 			switch app.Key {
-			case constant.AppMysql, constant.AppMariaDB, constant.AppPostgresql, constant.AppMongodb:
+			case constant.AppMysql, constant.AppMariaDB, constant.AppPostgresql, constant.AppMongodb, constant.AppMysqlCluster, constant.AppPostgresqlCluster:
 				if password, ok := params["PANEL_DB_ROOT_PASSWORD"]; ok {
 					if password != "" {
 						database.Password = password.(string)
-						if app.Key == "mysql" || app.Key == "mariadb" {
+						if app.Key == "mysql" || app.Key == "mariadb" || app.Key == constant.AppMysqlCluster {
 							database.Username = "root"
 						}
 						if rootUser, ok := params["PANEL_DB_ROOT_USER"]; ok {
@@ -200,7 +194,7 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 
 					}
 				}
-			case constant.AppRedis:
+			case constant.AppRedis, constant.AppRedisCluster:
 				if password, ok := params["PANEL_REDIS_ROOT_PASSWORD"]; ok {
 					authParam := dto.RedisAuthParam{
 						RootPassword: "",
@@ -237,6 +231,7 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 		}
 	}
 
+	var dbConfig dto.AppDatabase
 	if app.Type == "website" || app.Type == "tool" {
 		paramByte, err := json.Marshal(params)
 		if err != nil {
@@ -260,8 +255,11 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 			var resourceId uint
 			if dbConfig.DbName != "" && dbConfig.DbUser != "" && dbConfig.Password != "" {
 				switch database.Type {
-				case constant.AppPostgresql, constant.AppPostgres:
+				case constant.AppPostgresql, constant.AppPostgres, constant.AppPostgresqlCluster:
 					oldPostgresqlDb, _ := postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), repo.WithByFrom(constant.ResourceLocal))
+					if oldPostgresqlDb.ID == 0 {
+						oldPostgresqlDb, _ = postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), postgresqlRepo.WithByPostgresqlName(dbConfig.DatabaseName), repo.WithByFrom(constant.AppResourceRemote))
+					}
 					resourceId = oldPostgresqlDb.ID
 					if oldPostgresqlDb.ID > 0 {
 						if oldPostgresqlDb.Username != dbConfig.DbUser || oldPostgresqlDb.Password != dbConfig.Password {
@@ -282,8 +280,11 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 						}
 						resourceId = pgdb.ID
 					}
-				case constant.AppMysql, constant.AppMariaDB:
+				case constant.AppMysql, constant.AppMariaDB, constant.AppMysqlCluster:
 					oldMysqlDb, _ := mysqlRepo.Get(repo.WithByName(dbConfig.DbName), repo.WithByFrom(constant.ResourceLocal))
+					if oldMysqlDb.ID == 0 {
+						oldMysqlDb, _ = mysqlRepo.Get(repo.WithByName(dbConfig.DbName), mysqlRepo.WithByMysqlName(dbConfig.DatabaseName), repo.WithByFrom(constant.AppResourceRemote))
+					}
 					resourceId = oldMysqlDb.ID
 					if oldMysqlDb.ID > 0 {
 						if oldMysqlDb.Username != dbConfig.DbUser || oldMysqlDb.Password != dbConfig.Password {
@@ -387,21 +388,25 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
 		}
 
 		resources, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithAppInstallId(install.ID))
-		if deleteReq.DeleteDB && len(resources) > 0 {
-			del := dto.DelAppLink{
-				Ctx:         ctx,
-				Install:     &install,
-				ForceDelete: deleteReq.ForceDelete,
-				Task:        uninstallTask,
-			}
-			t.LogWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"))
-			if err = deleteLink(del); err != nil {
-				t.LogFailedWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"), err)
-				if !deleteReq.ForceDelete {
-					return err
+		if len(resources) > 0 {
+			if deleteReq.DeleteDB {
+				del := dto.DelAppLink{
+					Ctx:         ctx,
+					Install:     &install,
+					ForceDelete: deleteReq.ForceDelete,
+					Task:        uninstallTask,
 				}
+				t.LogWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"))
+				if err = deleteLink(del); err != nil {
+					t.LogFailedWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"), err)
+					if !deleteReq.ForceDelete {
+						return err
+					}
+				}
+				t.LogSuccessWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"))
+			} else {
+				_ = appInstallResourceRepo.DeleteBy(ctx, appInstallResourceRepo.WithAppInstallId(install.ID))
 			}
-			t.LogSuccessWithOps(task.TaskDelete, i18n.GetMsgByKey("Database"))
 		}
 
 		if DatabaseKeys[install.App.Key] > 0 {
@@ -409,9 +414,9 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
 		}
 
 		switch install.App.Key {
-		case constant.AppMysql, constant.AppMariaDB:
+		case constant.AppMysql, constant.AppMariaDB, constant.AppMysqlCluster:
 			_ = mysqlRepo.Delete(ctx, mysqlRepo.WithByMysqlName(install.Name))
-		case constant.AppPostgresql:
+		case constant.AppPostgresql, constant.AppPostgresqlCluster:
 			_ = postgresqlRepo.Delete(ctx, postgresqlRepo.WithByPostgresqlName(install.Name))
 		}
 
@@ -490,17 +495,14 @@ func deleteLink(del dto.DelAppLink) error {
 	return appInstallResourceRepo.DeleteBy(del.Ctx, appInstallResourceRepo.WithAppInstallId(install.ID))
 }
 
-func getUpgradeCompose(install model.AppInstall, detail model.AppDetail) (string, error) {
-	if detail.DockerCompose == "" {
-		return "", nil
-	}
+func handleUpgradeCompose(install model.AppInstall, detail model.AppDetail) (map[string]interface{}, error) {
 	composeMap := make(map[string]interface{})
 	if err := yaml.Unmarshal([]byte(detail.DockerCompose), &composeMap); err != nil {
-		return "", err
+		return nil, err
 	}
 	value, ok := composeMap["services"]
 	if !ok || value == nil {
-		return "", buserr.New("ErrFileParse")
+		return nil, buserr.New("ErrFileParse")
 	}
 	servicesMap := value.(map[string]interface{})
 	if len(servicesMap) == 1 {
@@ -518,6 +520,34 @@ func getUpgradeCompose(install model.AppInstall, detail model.AppDetail) (string
 			delete(servicesMap, oldServiceName)
 		}
 	}
+	serviceValue := servicesMap[install.ServiceName].(map[string]interface{})
+
+	oldComposeMap := make(map[string]interface{})
+	if err := yaml.Unmarshal([]byte(install.DockerCompose), &oldComposeMap); err != nil {
+		return nil, err
+	}
+	oldValue, ok := oldComposeMap["services"]
+	if !ok || oldValue == nil {
+		return nil, buserr.New("ErrFileParse")
+	}
+	oldValueMap := oldValue.(map[string]interface{})
+	oldServiceValue := oldValueMap[install.ServiceName].(map[string]interface{})
+	if oldServiceValue["deploy"] != nil {
+		serviceValue["deploy"] = oldServiceValue["deploy"]
+	}
+	servicesMap[install.ServiceName] = serviceValue
+	composeMap["services"] = servicesMap
+	return composeMap, nil
+}
+
+func getUpgradeCompose(install model.AppInstall, detail model.AppDetail) (string, error) {
+	if detail.DockerCompose == "" {
+		return "", nil
+	}
+	composeMap, err := handleUpgradeCompose(install, detail)
+	if err != nil {
+		return "", err
+	}
 	envs := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(install.Env), &envs); err != nil {
 		return "", err
@@ -618,7 +648,7 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		if err != nil {
 			return err
 		}
-		dockerCLi, err := docker.NewClient()
+		dockerCLi, _ := docker.NewClient()
 		if req.PullImage {
 			images, err := composeV2.GetDockerComposeImagesV2(content, []byte(detail.DockerCompose))
 			if err != nil {
@@ -635,10 +665,7 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		}
 
 		command := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -rn %s/* %s || true", detailDir, install.GetPath()))
-		stdout, _ := command.CombinedOutput()
-		if stdout != nil {
-			t.Logger.Printf("upgrade app [%s] [%s] cp file log : %s ", install.App.Key, install.Name, string(stdout))
-		}
+		_, _ = command.CombinedOutput()
 		sourceScripts := path.Join(detailDir, "scripts")
 		if fileOp.Stat(sourceScripts) {
 			dstScripts := path.Join(install.GetPath(), "scripts")
@@ -675,63 +702,6 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		}
 		envParams := make(map[string]string, len(envs))
 		handleMap(envs, envParams)
-		if install.App.Key == "openresty" && install.App.Resource == "remote" && !common.CompareVersion(install.Version, "1.25.3.2-0-1") {
-			t.Log(i18n.GetMsgByKey("MoveSiteDir"))
-			siteDir := path.Join(global.Dir.DataDir, "www")
-			envParams["WEBSITE_DIR"] = siteDir
-			oldSiteDir := path.Join(install.GetPath(), "www")
-			t.Log(i18n.GetWithName("MoveSiteToDir", siteDir))
-			if err := fileOp.CopyDir(oldSiteDir, global.Dir.DataDir); err != nil {
-				t.Log(i18n.GetMsgByKey("ErrMoveSiteDir"))
-				return err
-			}
-			newConfDir := path.Join(global.Dir.DataDir, "www", "conf.d")
-			_ = fileOp.CreateDir(newConfDir, constant.DirPerm)
-			oldConfDir := path.Join(install.GetPath(), "conf/conf.d")
-			items, err := os.ReadDir(oldConfDir)
-			if err != nil {
-				return err
-			}
-			for _, item := range items {
-				itemPath := path.Join(oldConfDir, item.Name())
-				if item.IsDir() {
-					_ = fileOp.Mv(itemPath, newConfDir)
-				}
-				if item.Name() != "default.conf" && item.Name() != "00.default.conf" {
-					_ = fileOp.Mv(itemPath, newConfDir)
-				}
-			}
-			nginxConfPath := path.Join(install.GetPath(), "conf", "nginx.conf")
-			parse, err := parser.NewParser(nginxConfPath)
-			if err != nil {
-				return err
-			}
-			config, err := parse.Parse()
-			if err != nil {
-				return err
-			}
-			config.FilePath = nginxConfPath
-			httpDirective := config.FindHttp()
-			httpDirective.UpdateDirective("include", []string{"/usr/local/openresty/nginx/conf/default/*.conf"})
-
-			if err = nginx.WriteConfig(config, nginx.IndentedStyle); err != nil {
-				return buserr.WithErr("ErrUpdateBuWebsite", err)
-			}
-			t.Log(i18n.GetMsgByKey("DeleteRuntimePHP"))
-			_ = fileOp.DeleteDir(path.Join(global.Dir.RuntimeDir, "php"))
-			websites, _ := websiteRepo.List(repo.WithByType("runtime"))
-			for _, website := range websites {
-				runtime, _ := runtimeRepo.GetFirst(context.Background(), repo.WithByID(website.RuntimeID))
-				if runtime != nil && runtime.Type == "php" {
-					website.Type = constant.Static
-					website.RuntimeID = 0
-					_ = websiteRepo.SaveWithoutCtx(&website)
-				}
-			}
-			_ = runtimeRepo.DeleteBy(repo.WithByType("php"))
-			t.Log(i18n.GetMsgByKey("MoveSiteDirSuccess"))
-		}
-
 		if err = env.Write(envParams, install.GetEnvPath()); err != nil {
 			return err
 		}
@@ -786,6 +756,15 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 	return appInstallRepo.Save(context.Background(), &install)
 }
 
+func skipCheckStatus(service types.ServiceConfig) bool {
+	for key := range service.Labels {
+		if key == "skipStatusCheck" {
+			return true
+		}
+	}
+	return false
+}
+
 func getContainerNames(install model.AppInstall) ([]string, error) {
 	envStr, err := coverEnvJsonToStr(install.Env)
 	if err != nil {
@@ -797,7 +776,7 @@ func getContainerNames(install model.AppInstall) ([]string, error) {
 	}
 	containerMap := make(map[string]struct{})
 	for _, service := range project.AllServices() {
-		if service.ContainerName == "${CONTAINER_NAME}" || service.ContainerName == "" {
+		if service.ContainerName == "${CONTAINER_NAME}" || service.ContainerName == "" || skipCheckStatus(service) {
 			continue
 		}
 		containerMap[service.ContainerName] = struct{}{}
@@ -995,14 +974,16 @@ func runScript(task *task.Task, appInstall *model.AppInstall, operate string) er
 	case "uninstall":
 		scriptPath = path.Join(workDir, "scripts", "uninstall.sh")
 	}
-	if !files.NewFileOp().Stat(scriptPath) {
+	fileOp := files.NewFileOp()
+	if !fileOp.Stat(scriptPath) {
 		return nil
 	}
+	_ = fileOp.ChmodR(scriptPath, constant.DirPerm, false)
 	logStr := i18n.GetWithName("ExecShell", operate)
 	task.LogStart(logStr)
 
-	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10*time.Minute), cmd.WithScriptPath(scriptPath), cmd.WithWorkDir(workDir))
-	out, err := cmdMgr.RunWithStdout("bash")
+	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10*time.Minute), cmd.WithWorkDir(workDir))
+	out, err := cmdMgr.RunWithStdoutBashCf(scriptPath)
 	if err != nil {
 		if out != "" {
 			err = errors.New(out)
@@ -1047,12 +1028,12 @@ func upApp(task *task.Task, appInstall *model.AppInstall, pullImages bool) error
 			errMsg string
 		)
 		if pullImages && appInstall.App.Type != "php" {
-			projectName := strings.ToLower(appInstall.Name)
+			//projectName := strings.ToLower(appInstall.Name)
 			envByte, err := files.NewFileOp().GetContent(appInstall.GetEnvPath())
 			if err != nil {
 				return err
 			}
-			images, err := composeV2.GetDockerComposeImages(projectName, envByte, []byte(appInstall.DockerCompose))
+			images, err := composeV2.GetImagesFromDockerCompose(envByte, []byte(appInstall.DockerCompose))
 			if err != nil {
 				return err
 			}
@@ -1363,7 +1344,7 @@ func doNotNeedSync(installed model.AppInstall) bool {
 		installed.Status == constant.StatusSyncing || installed.Status == constant.StatusUninstalling || installed.Status == constant.StatusInstallErr
 }
 
-func synAppInstall(containers map[string]types.Container, appInstall *model.AppInstall, force bool) {
+func synAppInstall(containers map[string]container.Summary, appInstall *model.AppInstall, force bool) {
 	oldStatus := appInstall.Status
 	containerNames := strings.Split(appInstall.ContainerName, ",")
 	if len(containers) == 0 {
@@ -1437,7 +1418,7 @@ func synAppInstall(containers map[string]types.Container, appInstall *model.AppI
 func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool) ([]response.AppInstallDTO, error) {
 	var (
 		res           []response.AppInstallDTO
-		containersMap map[string]types.Container
+		containersMap map[string]container.Summary
 	)
 	if sync {
 		cli, err := docker.NewClient()
@@ -1445,7 +1426,7 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 			defer cli.Close()
 			containers, err := cli.ListAllContainers()
 			if err == nil {
-				containersMap = make(map[string]types.Container, len(containers))
+				containersMap = make(map[string]container.Summary, len(containers))
 				for _, contain := range containers {
 					containersMap[contain.Names[0]] = contain
 				}
@@ -1517,7 +1498,7 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 			continue
 		}
 		lastVersion := versions[0]
-		if app.Key == constant.AppMysql {
+		if app.Key == constant.AppMysql || app.Key == constant.AppMysqlCluster {
 			for _, version := range versions {
 				majorVersion := getMajorVersion(installed.Version)
 				if !strings.HasPrefix(version, majorVersion) {
@@ -1794,10 +1775,7 @@ func ignoreUpdate(installed model.AppInstall) bool {
 		return true
 	}
 	ignores, _ := appIgnoreUpgradeRepo.List(appDetailRepo.WithAppId(installed.AppId), appIgnoreUpgradeRepo.WithScope("all"))
-	if len(ignores) > 0 {
-		return true
-	}
-	return false
+	return len(ignores) > 0
 }
 
 func RequestDownloadCallBack(downloadCallBackUrl string) {
@@ -1822,24 +1800,15 @@ func getAppTags(appID uint, lang string) ([]response.TagDTO, error) {
 	}
 	var res []response.TagDTO
 	for _, t := range tags {
-		if t.Name != "" {
+		var translations = make(map[string]string)
+		_ = json.Unmarshal([]byte(t.Translations), &translations)
+		if name, ok := translations[lang]; ok {
 			tagDTO := response.TagDTO{
 				ID:   t.ID,
 				Key:  t.Key,
-				Name: t.Name,
+				Name: name,
 			}
 			res = append(res, tagDTO)
-		} else {
-			var translations = make(map[string]string)
-			_ = json.Unmarshal([]byte(t.Translations), &translations)
-			if name, ok := translations[lang]; ok {
-				tagDTO := response.TagDTO{
-					ID:   t.ID,
-					Key:  t.Key,
-					Name: name,
-				}
-				res = append(res, tagDTO)
-			}
 		}
 	}
 	return res, nil

agent/app/service/backup.go

@@ -290,8 +290,6 @@ func (u *BackupService) RefreshToken(req dto.OperateByID) error {
 	switch backup.Type {
 	case constant.OneDrive:
 		refreshToken, err = client.RefreshToken("refresh_token", "refreshToken", varMap)
-	case constant.GoogleDrive:
-		refreshToken, err = client.RefreshGoogleToken("refresh_token", "refreshToken", varMap)
 	case constant.ALIYUN:
 		refreshToken, err = client.RefreshALIToken(varMap)
 	}
@@ -543,11 +541,17 @@ func changeLocalBackup(oldPath, newPath string) error {
 			return err
 		}
 	}
+	if fileOp.Stat(path.Join(oldPath, "master")) {
+		if err := fileOp.CopyDir(path.Join(oldPath, "master"), newPath); err != nil {
+			return err
+		}
+	}
 	_ = fileOp.RmRf(path.Join(oldPath, "app"))
 	_ = fileOp.RmRf(path.Join(oldPath, "database"))
 	_ = fileOp.RmRf(path.Join(oldPath, "directory"))
 	_ = fileOp.RmRf(path.Join(oldPath, "system_snapshot"))
 	_ = fileOp.RmRf(path.Join(oldPath, "website"))
 	_ = fileOp.RmRf(path.Join(oldPath, "log"))
+	_ = fileOp.RmRf(path.Join(oldPath, "master"))
 	return nil
 }

agent/app/service/backup_record.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"strings"
 	"sync"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
@@ -194,7 +193,7 @@ func (u *BackupRecordService) ListFiles(req dto.OperateByID) []string {
 	var datas []string
 	for _, file := range files {
 		fileName := path.Base(file)
-		if len(file) != 0 && (strings.HasPrefix(fileName, "1panel-v2.") || strings.HasPrefix(fileName, "snapshot-1panel-v2.")) {
+		if len(file) != 0 && checkSnapshotIsOk(fileName) {
 			datas = append(datas, path.Base(file))
 		}
 	}

agent/app/service/backup_redis.go

@@ -23,7 +23,7 @@ import (
 )
 
 func (u *BackupService) RedisBackup(req dto.CommonBackup) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.Type, req.Name)
 	if err != nil {
 		return err
 	}
@@ -64,7 +64,7 @@ func (u *BackupService) RedisBackup(req dto.CommonBackup) error {
 }
 
 func (u *BackupService) RedisRecover(req dto.CommonRecover) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.Type, req.Name)
 	if err != nil {
 		return err
 	}
@@ -76,6 +76,7 @@ func (u *BackupService) RedisRecover(req dto.CommonRecover) error {
 }
 
 func handleRedisBackup(redisInfo *repo.RootInfo, parentTask *task.Task, backupDir, fileName, secret, taskID string) error {
+
 	var (
 		err      error
 		itemTask *task.Task
@@ -102,7 +103,7 @@ func handleRedisBackup(redisInfo *repo.RootInfo, parentTask *task.Task, backupDi
 		}
 
 		if strings.HasSuffix(fileName, ".tar.gz") {
-			redisDataDir := fmt.Sprintf("%s/%s/%s/data/appendonlydir", global.Dir.AppInstallDir, "redis", redisInfo.Name)
+			redisDataDir := fmt.Sprintf("%s/%s/%s/data/appendonlydir", global.Dir.AppInstallDir, redisInfo.Key, redisInfo.Name)
 			if err := fileOp.TarGzCompressPro(true, redisDataDir, path.Join(backupDir, fileName), secret, ""); err != nil {
 				return err
 			}
@@ -111,14 +112,14 @@ func handleRedisBackup(redisInfo *repo.RootInfo, parentTask *task.Task, backupDi
 		if strings.HasSuffix(fileName, ".aof") {
 			stdout1, err := cmd.RunDefaultWithStdoutBashCf("docker cp %s:/data/appendonly.aof %s/%s", redisInfo.ContainerName, backupDir, fileName)
 			if err != nil {
-				return errors.New(string(stdout1))
+				return errors.New(stdout1)
 			}
 			return nil
 		}
 
 		stdout1, err1 := cmd.RunDefaultWithStdoutBashCf("docker cp %s:/data/dump.rdb %s/%s", redisInfo.ContainerName, backupDir, fileName)
 		if err1 != nil {
-			return errors.New(string(stdout1))
+			return errors.New(stdout1)
 		}
 		return nil
 	}
@@ -196,12 +197,12 @@ func handleRedisRecover(redisInfo *repo.RootInfo, parentTask *task.Task, recover
 				}
 			}()
 		}
-		composeDir := fmt.Sprintf("%s/redis/%s", global.Dir.AppInstallDir, redisInfo.Name)
+		composeDir := fmt.Sprintf("%s/%s/%s", global.Dir.AppInstallDir, redisInfo.Key, redisInfo.Name)
 		if _, err := compose.Down(composeDir + "/docker-compose.yml"); err != nil {
 			return err
 		}
 		if appendonly == "yes" && strings.HasPrefix(redisInfo.Version, "7.") {
-			redisDataDir := fmt.Sprintf("%s/%s/%s/data", global.Dir.AppInstallDir, "redis", redisInfo.Name)
+			redisDataDir := fmt.Sprintf("%s/%s/%s/data", global.Dir.AppInstallDir, redisInfo.Key, redisInfo.Name)
 			if err := fileOp.TarGzExtractPro(recoverFile, redisDataDir, secret); err != nil {
 				return err
 			}

agent/app/service/clam.go

@@ -3,6 +3,7 @@ package service
 import (
 	"bufio"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
 	"os"
 	"os/exec"
 	"path"
@@ -158,9 +159,10 @@ func (c *ClamService) SearchWithPage(req dto.SearchClamWithPage) (int64, interfa
 			AlertType: "clams",
 			EntryID:   datas[i].ID,
 		}
-		alertCount := xpack.GetAlert(alertBase)
-		if alertCount != 0 {
-			datas[i].AlertCount = alertCount
+		alertInfo, _ := alertRepo.Get(alertRepo.WithByType(alertBase.AlertType), alertRepo.WithByProject(strconv.Itoa(int(alertBase.EntryID))), repo.WithByStatus(constant.AlertEnable))
+		datas[i].AlertMethod = alertInfo.Method
+		if alertInfo.SendCount != 0 {
+			datas[i].AlertCount = alertInfo.SendCount
 		} else {
 			datas[i].AlertCount = 0
 		}
@@ -191,13 +193,15 @@ func (c *ClamService) Create(req dto.ClamCreate) error {
 		return err
 	}
 	if req.AlertCount != 0 {
-		createAlert := dto.CreateOrUpdateAlert{
-			AlertTitle: req.AlertTitle,
-			AlertCount: req.AlertCount,
-			AlertType:  "clams",
-			EntryID:    clam.ID,
+		createAlert := dto.AlertCreate{
+			Title:     req.AlertTitle,
+			SendCount: req.AlertCount,
+			Method:    req.AlertMethod,
+			Type:      "clams",
+			Project:   strconv.Itoa(int(clam.ID)),
+			Status:    constant.AlertEnable,
 		}
-		err := xpack.CreateAlert(createAlert)
+		err := NewIAlertService().CreateAlert(createAlert)
 		if err != nil {
 			return err
 		}
@@ -247,13 +251,14 @@ func (c *ClamService) Update(req dto.ClamUpdate) error {
 	if err := clamRepo.Update(req.ID, upMap); err != nil {
 		return err
 	}
-	updateAlert := dto.CreateOrUpdateAlert{
-		AlertTitle: req.AlertTitle,
-		AlertType:  "clams",
-		AlertCount: req.AlertCount,
-		EntryID:    clam.ID,
+	updateAlert := dto.AlertCreate{
+		Title:     req.AlertTitle,
+		SendCount: req.AlertCount,
+		Method:    req.AlertMethod,
+		Type:      "clams",
+		Project:   strconv.Itoa(int(clam.ID)),
 	}
-	err := xpack.UpdateAlert(updateAlert)
+	err := NewIAlertService().ExternalUpdateAlert(updateAlert)
 	if err != nil {
 		return err
 	}
@@ -297,11 +302,7 @@ func (c *ClamService) Delete(req dto.ClamDelete) error {
 		if err := clamRepo.Delete(repo.WithByID(id)); err != nil {
 			return err
 		}
-		alertBase := dto.AlertBase{
-			AlertType: "clams",
-			EntryID:   clam.ID,
-		}
-		err := xpack.DeleteAlert(alertBase)
+		err := alertRepo.Delete(alertRepo.WithByProject(strconv.Itoa(int(clam.ID))), alertRepo.WithByType("clams"))
 		if err != nil {
 			return err
 		}
@@ -639,10 +640,7 @@ func handleAlert(stdout, clamName string, clamId uint) {
 						EntryID:   clamId,
 						Param:     strconv.Itoa(infectedFiles),
 					}
-					err := xpack.PushAlert(pushAlert)
-					if err != nil {
-						global.LOG.Errorf("clamdscan push failed, err: %v", err)
-					}
+					_ = alert_push.PushAlert(pushAlert)
 					break
 				}
 			}

agent/app/service/container.go

@@ -12,6 +12,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -33,7 +34,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
-	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/build"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/image"
@@ -52,7 +53,7 @@ type ContainerService struct{}
 
 type IContainerService interface {
 	Page(req dto.PageContainer) (int64, interface{}, error)
-	List() []string
+	List() []dto.ContainerOptions
 	LoadStatus() (dto.ContainerStatus, error)
 	PageNetwork(req dto.SearchWithPage) (int64, interface{}, error)
 	ListNetwork() ([]dto.Options, error)
@@ -61,7 +62,7 @@ type IContainerService interface {
 	PageCompose(req dto.SearchWithPage) (int64, interface{}, error)
 	CreateCompose(req dto.ComposeCreate) error
 	ComposeOperation(req dto.ComposeOperation) error
-	ContainerCreate(req dto.ContainerOperate) error
+	ContainerCreate(req dto.ContainerOperate, inThread bool) error
 	ContainerCreateByCommand(req dto.ContainerCreateByCommand) error
 	ContainerUpdate(req dto.ContainerOperate) error
 	ContainerUpgrade(req dto.ContainerUpgrade) error
@@ -83,6 +84,8 @@ type IContainerService interface {
 	ComposeUpdate(req dto.ComposeUpdate) error
 	Prune(req dto.ContainerPrune) (dto.ContainerPruneReport, error)
 
+	LoadUsers(req dto.OperationWithName) []string
+
 	StreamLogs(ctx *gin.Context, params dto.StreamLog)
 }
 
@@ -92,8 +95,8 @@ func NewIContainerService() IContainerService {
 
 func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, error) {
 	var (
-		records []types.Container
-		list    []types.Container
+		records []container.Summary
+		list    []container.Summary
 	)
 	client, err := docker.NewDockerClient()
 	if err != nil {
@@ -163,7 +166,7 @@ func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, erro
 
 	total, start, end := len(list), (req.Page-1)*req.PageSize, req.Page*req.PageSize
 	if start > total {
-		records = make([]types.Container, 0)
+		records = make([]container.Summary, 0)
 	} else {
 		if end >= total {
 			end = total
@@ -219,7 +222,8 @@ func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, erro
 	return int64(total), backDatas, nil
 }
 
-func (u *ContainerService) List() []string {
+func (u *ContainerService) List() []dto.ContainerOptions {
+	var options []dto.ContainerOptions
 	client, err := docker.NewDockerClient()
 	if err != nil {
 		global.LOG.Errorf("load docker client for contianer list failed, err: %v", err)
@@ -228,19 +232,18 @@ func (u *ContainerService) List() []string {
 	defer client.Close()
 	containers, err := client.ContainerList(context.Background(), container.ListOptions{All: true})
 	if err != nil {
-		global.LOG.Errorf("load contianer list failed, err: %v", err)
+		global.LOG.Errorf("load container list failed, err: %v", err)
 		return nil
 	}
-	var datas []string
 	for _, container := range containers {
 		for _, name := range container.Names {
 			if len(name) != 0 {
-				datas = append(datas, strings.TrimPrefix(name, "/"))
+				options = append(options, dto.ContainerOptions{Name: strings.TrimPrefix(name, "/"), State: container.State})
 			}
 		}
 	}
 
-	return datas
+	return options
 }
 
 func (u *ContainerService) LoadStatus() (dto.ContainerStatus, error) {
@@ -305,7 +308,7 @@ func (u *ContainerService) ContainerListStats() ([]dto.ContainerListStats, error
 	var wg sync.WaitGroup
 	wg.Add(len(list))
 	for i := 0; i < len(list); i++ {
-		go func(item types.Container) {
+		go func(item container.Summary) {
 			datas = append(datas, loadCpuAndMem(client, item.ID))
 			wg.Done()
 		}(list[i])
@@ -464,7 +467,7 @@ func (u *ContainerService) Prune(req dto.ContainerPrune) (dto.ContainerPruneRepo
 		report.DeletedNumber = len(rep.VolumesDeleted)
 		report.SpaceReclaimed = int(rep.SpaceReclaimed)
 	case "buildcache":
-		opts := types.BuildCachePruneOptions{}
+		opts := build.CachePruneOptions{}
 		opts.All = true
 		rep, err := client.BuildCachePrune(context.Background(), opts)
 		if err != nil {
@@ -493,7 +496,7 @@ func (u *ContainerService) LoadResourceLimit() (*dto.ResourceLimit, error) {
 	return &data, nil
 }
 
-func (u *ContainerService) ContainerCreate(req dto.ContainerOperate) error {
+func (u *ContainerService) ContainerCreate(req dto.ContainerOperate, inThread bool) error {
 	client, err := docker.NewDockerClient()
 	if err != nil {
 		return err
@@ -511,63 +514,62 @@ func (u *ContainerService) ContainerCreate(req dto.ContainerOperate) error {
 		return err
 	}
 
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		taskItem.AddSubTask(i18n.GetWithName("ContainerImagePull", req.Image), func(t *task.Task) error {
-			if !checkImageExist(client, req.Image) || req.ForcePull {
-				if err := pullImages(taskItem, client, req.Image); err != nil {
-					if !req.ForcePull {
-						return err
-					}
+	taskItem.AddSubTask(i18n.GetWithName("ContainerImagePull", req.Image), func(t *task.Task) error {
+		if !checkImageExist(client, req.Image) || req.ForcePull {
+			if err := pullImages(taskItem, client, req.Image); err != nil {
+				if !req.ForcePull {
+					return err
 				}
 			}
-			return nil
-		}, nil)
-
-		taskItem.AddSubTask(i18n.GetMsgByKey("ContainerImageCheck"), func(t *task.Task) error {
-			imageInfo, _, err := client.ImageInspectWithRaw(ctx, req.Image)
-			if err != nil {
-				return err
-			}
-			if len(req.Entrypoint) == 0 {
-				req.Entrypoint = imageInfo.Config.Entrypoint
-			}
-			if len(req.Cmd) == 0 {
-				req.Cmd = imageInfo.Config.Cmd
-			}
-			return nil
-		}, nil)
-
-		taskItem.AddSubTask(i18n.GetWithName("ContainerCreate", req.Name), func(t *task.Task) error {
-			config, hostConf, networkConf, err := loadConfigInfo(true, req, nil)
-			taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerLoadInfo"), err)
-			if err != nil {
-				return err
-			}
-			con, err := client.ContainerCreate(ctx, config, hostConf, networkConf, &v1.Platform{}, req.Name)
-			if err != nil {
-				taskItem.Log(i18n.GetMsgByKey("ContainerCreateFailed"))
-				_ = client.ContainerRemove(ctx, req.Name, container.RemoveOptions{RemoveVolumes: true, Force: true})
-				return err
-			}
-			err = client.ContainerStart(ctx, con.ID, container.StartOptions{})
-			taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerStartCheck"), err)
-			if err != nil {
-				taskItem.Log(i18n.GetMsgByKey("ContainerCreateFailed"))
-				_ = client.ContainerRemove(ctx, req.Name, container.RemoveOptions{RemoveVolumes: true, Force: true})
-				return fmt.Errorf("create successful but start failed, err: %v", err)
-			}
-			return nil
-		}, nil)
-
-		if err := taskItem.Execute(); err != nil {
-			global.LOG.Error(err.Error())
 		}
-	}()
-	wg.Wait()
-	return nil
+		return nil
+	}, nil)
+
+	taskItem.AddSubTask(i18n.GetMsgByKey("ContainerImageCheck"), func(t *task.Task) error {
+		imageInfo, _, err := client.ImageInspectWithRaw(ctx, req.Image)
+		if err != nil {
+			return err
+		}
+		if len(req.Entrypoint) == 0 {
+			req.Entrypoint = imageInfo.Config.Entrypoint
+		}
+		if len(req.Cmd) == 0 {
+			req.Cmd = imageInfo.Config.Cmd
+		}
+		return nil
+	}, nil)
+
+	taskItem.AddSubTask(i18n.GetWithName("ContainerCreate", req.Name), func(t *task.Task) error {
+		config, hostConf, networkConf, err := loadConfigInfo(true, req, nil)
+		taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerLoadInfo"), err)
+		if err != nil {
+			return err
+		}
+		con, err := client.ContainerCreate(ctx, config, hostConf, networkConf, &v1.Platform{}, req.Name)
+		if err != nil {
+			taskItem.Log(i18n.GetMsgByKey("ContainerCreateFailed"))
+			_ = client.ContainerRemove(ctx, req.Name, container.RemoveOptions{RemoveVolumes: true, Force: true})
+			return err
+		}
+		err = client.ContainerStart(ctx, con.ID, container.StartOptions{})
+		taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerStartCheck"), err)
+		if err != nil {
+			taskItem.Log(i18n.GetMsgByKey("ContainerCreateFailed"))
+			_ = client.ContainerRemove(ctx, req.Name, container.RemoveOptions{RemoveVolumes: true, Force: true})
+			return fmt.Errorf("create successful but start failed, err: %v", err)
+		}
+		return nil
+	}, nil)
+
+	if inThread {
+		go func() {
+			if err := taskItem.Execute(); err != nil {
+				global.LOG.Error(err.Error())
+			}
+		}()
+		return nil
+	}
+	return taskItem.Execute()
 }
 
 func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.ContainerOperate, error) {
@@ -674,7 +676,7 @@ func (u *ContainerService) ContainerUpdate(req dto.ContainerOperate) error {
 
 		taskItem.AddSubTask(i18n.GetWithName("ContainerCreate", req.Name), func(t *task.Task) error {
 			err := client.ContainerRemove(ctx, req.ContainerID, container.RemoveOptions{Force: true})
-			taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerRemoveOld"), err)
+			taskItem.LogWithStatus(i18n.GetWithName("ContainerRemoveOld", req.Name), err)
 			if err != nil {
 				return err
 			}
@@ -750,7 +752,7 @@ func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
 				}
 			}
 			err := client.ContainerRemove(ctx, req.Name, container.RemoveOptions{Force: true})
-			taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerRemoveOld"), err)
+			taskItem.LogWithStatus(i18n.GetWithName("ContainerRemoveOld", req.Name), err)
 			if err != nil {
 				return err
 			}
@@ -807,10 +809,23 @@ func (u *ContainerService) ContainerCommit(req dto.ContainerCommit) error {
 		Pause:     req.Pause,
 		Config:    nil,
 	}
-	_, err = client.ContainerCommit(ctx, req.ContainerId, options)
+
+	taskItem, err := task.NewTaskWithOps(req.NewImageName, task.TaskCommit, task.TaskScopeContainer, req.TaskID, 1)
 	if err != nil {
-		return fmt.Errorf("failed to commit container, err: %v", err)
+		return fmt.Errorf("new task for container commit failed, err: %v", err)
 	}
+
+	go func() {
+		taskItem.AddSubTask(i18n.GetWithName("TaskCommit", req.NewImageName), func(t *task.Task) error {
+			res, err := client.ContainerCommit(ctx, req.ContainerId, options)
+			if err != nil {
+				return fmt.Errorf("failed to commit container, err: %v", err)
+			}
+			taskItem.Log(res.ID)
+			return nil
+		}, nil)
+		_ = taskItem.Execute()
+	}()
 	return nil
 }
 
@@ -882,16 +897,20 @@ func (u *ContainerService) ContainerLogClean(req dto.OperationWithName) error {
 func (u *ContainerService) StreamLogs(ctx *gin.Context, params dto.StreamLog) {
 	messageChan := make(chan string, 1024)
 	errorChan := make(chan error, 1)
+	doneChan := make(chan struct{})
 
-	go collectLogs(params, messageChan, errorChan)
-
+	go func() {
+		<-ctx.Request.Context().Done()
+		close(doneChan)
+	}()
+	go collectLogs(doneChan, params, messageChan, errorChan)
 	ctx.Stream(func(w io.Writer) bool {
 		select {
 		case msg, ok := <-messageChan:
 			if !ok {
-				return msg == ""
+				return false
 			}
-			_, err := fmt.Fprintf(w, "data: %v\n\n", msg)
+			_, err := fmt.Fprintf(w, "data: %s\n\n", msg)
 			if err != nil {
 				return false
 			}
@@ -900,21 +919,15 @@ func (u *ContainerService) StreamLogs(ctx *gin.Context, params dto.StreamLog) {
 			if err != nil {
 				_, _ = fmt.Fprintf(w, "event: error\ndata: %v\n\n", err.Error())
 			}
-			return true
-		case <-ctx.Request.Context().Done():
 			return false
 		}
 	})
 }
 
-func collectLogs(params dto.StreamLog, messageChan chan<- string, errorChan chan<- error) {
+func collectLogs(done <-chan struct{}, params dto.StreamLog, messageChan chan<- string, errorChan chan<- error) {
 	defer close(messageChan)
 	defer close(errorChan)
-
 	var cmdArgs []string
-	if params.Type == "compose" {
-		cmdArgs = []string{"compose", "-f", params.Compose}
-	}
 	cmdArgs = append(cmdArgs, "logs")
 	if params.Follow {
 		cmdArgs = append(cmdArgs, "-f")
@@ -928,36 +941,85 @@ func collectLogs(params dto.StreamLog, messageChan chan<- string, errorChan chan
 	if params.Container != "" {
 		cmdArgs = append(cmdArgs, params.Container)
 	}
-	dockerCmd := exec.Command("docker", cmdArgs...)
+
+	var dockerCmd *exec.Cmd
+	if params.Type == "compose" {
+		dockerComposCmd := common.GetDockerComposeCommand()
+		if dockerComposCmd == "docker-compose" {
+			newCmdArgs := append([]string{"-f", params.Compose}, cmdArgs...)
+			dockerCmd = exec.Command(dockerComposCmd, newCmdArgs...)
+		} else {
+			newCmdArgs := append([]string{"compose", "-f", params.Compose}, cmdArgs...)
+			dockerCmd = exec.Command("docker", newCmdArgs...)
+		}
+	} else {
+		dockerCmd = exec.Command("docker", cmdArgs...)
+	}
+
+	dockerCmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
 
 	stdout, err := dockerCmd.StdoutPipe()
 	if err != nil {
 		errorChan <- fmt.Errorf("failed to get stdout pipe: %v", err)
 		return
 	}
+
 	dockerCmd.Stderr = dockerCmd.Stdout
+
 	if err = dockerCmd.Start(); err != nil {
-		errorChan <- fmt.Errorf("failed to start command: %v", err)
+		errorChan <- fmt.Errorf("failed to start docker logs command: %v", err)
 		return
 	}
-	scanner := bufio.NewScanner(stdout)
-	for scanner.Scan() {
-		message := scanner.Text()
+
+	defer func() {
+		if dockerCmd.Process != nil {
+			if pgid, err := syscall.Getpgid(dockerCmd.Process.Pid); err == nil {
+				_ = syscall.Kill(-pgid, syscall.SIGKILL)
+			}
+			_ = dockerCmd.Process.Kill()
+			_ = dockerCmd.Wait()
+		}
+	}()
+
+	reader := bufio.NewReader(stdout)
+
+	processKilled := false
+	go func() {
+		<-done
+		if !processKilled && dockerCmd.Process != nil {
+			processKilled = true
+			if pgid, err := syscall.Getpgid(dockerCmd.Process.Pid); err == nil {
+				_ = syscall.Kill(-pgid, syscall.SIGKILL)
+			}
+			_ = dockerCmd.Process.Kill()
+		}
+	}()
+
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				if len(line) > 0 {
+					line = strings.TrimSuffix(line, "\n")
+					select {
+					case messageChan <- line:
+					case <-done:
+						return
+					}
+				}
+				break
+			}
+			errorChan <- fmt.Errorf("reader error: %v", err)
+			return
+		}
+		line = strings.TrimSuffix(line, "\n")
 		select {
-		case messageChan <- message:
-		case <-time.After(5 * time.Second):
-			errorChan <- fmt.Errorf("message channel blocked")
+		case messageChan <- line:
+		case <-done:
 			return
 		}
 	}
-	if err = scanner.Err(); err != nil {
-		errorChan <- fmt.Errorf("scanner error: %v", err)
-		return
-	}
-	if err = dockerCmd.Wait(); err != nil {
-		errorChan <- fmt.Errorf("%v", err)
-		return
-	}
+	_ = dockerCmd.Wait()
 }
 
 func (u *ContainerService) DownloadContainerLogs(containerType, container, since, tail string, c *gin.Context) error {
@@ -965,9 +1027,15 @@ func (u *ContainerService) DownloadContainerLogs(containerType, container, since
 		return buserr.New("ErrCmdIllegal")
 	}
 	commandArg := []string{"logs", container}
+	dockerCommand := global.CONF.DockerConfig.Command
 	if containerType == "compose" {
-		commandArg = []string{"compose", "-f", container, "logs"}
+		if dockerCommand == "docker-compose" {
+			commandArg = []string{"-f", container, "logs"}
+		} else {
+			commandArg = []string{"compose", "-f", container, "logs"}
+		}
 	}
+
 	if tail != "0" {
 		commandArg = append(commandArg, "--tail")
 		commandArg = append(commandArg, tail)
@@ -976,16 +1044,20 @@ func (u *ContainerService) DownloadContainerLogs(containerType, container, since
 		commandArg = append(commandArg, "--since")
 		commandArg = append(commandArg, since)
 	}
-
-	cmd := exec.Command("docker", commandArg...)
-	stdout, err := cmd.StdoutPipe()
+	var dockerCmd *exec.Cmd
+	if containerType == "compose" && dockerCommand == "docker-compose" {
+		dockerCmd = exec.Command("docker-compose", commandArg...)
+	} else {
+		dockerCmd = exec.Command("docker", commandArg...)
+	}
+	stdout, err := dockerCmd.StdoutPipe()
 	if err != nil {
-		_ = cmd.Process.Signal(syscall.SIGTERM)
+		_ = dockerCmd.Process.Signal(syscall.SIGTERM)
 		return err
 	}
-	cmd.Stderr = cmd.Stdout
-	if err := cmd.Start(); err != nil {
-		_ = cmd.Process.Signal(syscall.SIGTERM)
+	dockerCmd.Stderr = dockerCmd.Stdout
+	if err := dockerCmd.Start(); err != nil {
+		_ = dockerCmd.Process.Signal(syscall.SIGTERM)
 		return err
 	}
 
@@ -1002,9 +1074,11 @@ func (u *ContainerService) DownloadContainerLogs(containerType, container, since
 	errCh := make(chan error)
 	go func() {
 		scanner := bufio.NewScanner(stdout)
+		var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;?]*[A-Za-z]|\x1b=|\x1b>`)
 		for scanner.Scan() {
 			line := scanner.Text()
-			if _, err := tempFile.WriteString(line + "\n"); err != nil {
+			cleanLine := ansiRegex.ReplaceAllString(line, "")
+			if _, err := tempFile.WriteString(cleanLine + "\n"); err != nil {
 				errCh <- err
 				return
 			}
@@ -1065,6 +1139,21 @@ func (u *ContainerService) ContainerStats(id string) (*dto.ContainerStats, error
 	return &data, nil
 }
 
+func (u *ContainerService) LoadUsers(req dto.OperationWithName) []string {
+	var users []string
+	std, err := cmd.RunDefaultWithStdoutBashCf("docker exec %s cat /etc/passwd", req.Name)
+	if err != nil {
+		return users
+	}
+	lines := strings.Split(string(std), "\n")
+	for _, line := range lines {
+		if strings.Contains(line, ":") {
+			users = append(users, strings.Split(line, ":")[0])
+		}
+	}
+	return users
+}
+
 func stringsToMap(list []string) map[string]string {
 	var labelMap = make(map[string]string)
 	for _, label := range list {
@@ -1257,7 +1346,7 @@ func checkPortStats(ports []dto.PortHelper) (nat.PortMap, error) {
 	return portMap, nil
 }
 
-func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *types.ContainerJSON) (*container.Config, *container.HostConfig, *network.NetworkingConfig, error) {
+func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *container.InspectResponse) (*container.Config, *container.HostConfig, *network.NetworkingConfig, error) {
 	var config container.Config
 	var hostConf container.HostConfig
 	if !isCreate {
@@ -1340,7 +1429,7 @@ func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *types
 	return &config, &hostConf, &networkConf, nil
 }
 
-func reCreateAfterUpdate(name string, client *client.Client, config *container.Config, hostConf *container.HostConfig, networkConf *types.NetworkSettings) {
+func reCreateAfterUpdate(name string, client *client.Client, config *container.Config, hostConf *container.HostConfig, networkConf *container.NetworkSettings) {
 	ctx := context.Background()
 
 	var oldNetworkConf network.NetworkingConfig
@@ -1362,7 +1451,7 @@ func reCreateAfterUpdate(name string, client *client.Client, config *container.C
 	global.LOG.Info("recreate after container update successful")
 }
 
-func loadVolumeBinds(binds []types.MountPoint) []dto.VolumeHelper {
+func loadVolumeBinds(binds []container.MountPoint) []dto.VolumeHelper {
 	var datas []dto.VolumeHelper
 	for _, bind := range binds {
 		var volumeItem dto.VolumeHelper
@@ -1382,13 +1471,13 @@ func loadVolumeBinds(binds []types.MountPoint) []dto.VolumeHelper {
 	return datas
 }
 
-func loadPortByInspect(id string, client *client.Client) ([]types.Port, error) {
-	container, err := client.ContainerInspect(context.Background(), id)
+func loadPortByInspect(id string, client *client.Client) ([]container.Port, error) {
+	containerItem, err := client.ContainerInspect(context.Background(), id)
 	if err != nil {
 		return nil, err
 	}
-	var itemPorts []types.Port
-	for key, val := range container.ContainerJSONBase.HostConfig.PortBindings {
+	var itemPorts []container.Port
+	for key, val := range containerItem.ContainerJSONBase.HostConfig.PortBindings {
 		if !strings.Contains(string(key), "/") {
 			continue
 		}
@@ -1397,15 +1486,15 @@ func loadPortByInspect(id string, client *client.Client) ([]types.Port, error) {
 
 		for _, itemVal := range val {
 			publicPort, _ := strconv.ParseUint(itemVal.HostPort, 10, 16)
-			itemPorts = append(itemPorts, types.Port{PrivatePort: uint16(itemPort), Type: item[1], PublicPort: uint16(publicPort), IP: itemVal.HostIP})
+			itemPorts = append(itemPorts, container.Port{PrivatePort: uint16(itemPort), Type: item[1], PublicPort: uint16(publicPort), IP: itemVal.HostIP})
 		}
 	}
 	return itemPorts, nil
 }
-func transPortToStr(ports []types.Port) []string {
+func transPortToStr(ports []container.Port) []string {
 	var (
-		ipv4Ports []types.Port
-		ipv6Ports []types.Port
+		ipv4Ports []container.Port
+		ipv6Ports []container.Port
 	)
 	for _, port := range ports {
 		if strings.Contains(port.IP, ":") {
@@ -1418,7 +1507,7 @@ func transPortToStr(ports []types.Port) []string {
 	list2 := simplifyPort(ipv6Ports)
 	return append(list1, list2...)
 }
-func simplifyPort(ports []types.Port) []string {
+func simplifyPort(ports []container.Port) []string {
 	var datas []string
 	if len(ports) == 0 {
 		return datas
@@ -1514,7 +1603,7 @@ func loadComposeCount(client *client.Client) int {
 
 	return len(composeMap)
 }
-func loadContainerPortForInfo(itemPorts []types.Port) []dto.PortHelper {
+func loadContainerPortForInfo(itemPorts []container.Port) []dto.PortHelper {
 	var exposedPorts []dto.PortHelper
 	samePortMap := make(map[string]dto.PortHelper)
 	ports := transPortToStr(itemPorts)

agent/app/service/container_compose.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"path"
 	"sort"
 	"strings"
@@ -174,7 +173,7 @@ func (u *ContainerService) TestCompose(req dto.ComposeCreate) (bool, error) {
 	if err := newComposeEnv(req.Path, req.Env); err != nil {
 		return false, err
 	}
-	cmd := exec.Command("docker", "compose", "-f", req.Path, "config")
+	cmd := getComposeCmd(req.Path, "config")
 	stdout, err := cmd.CombinedOutput()
 	if err != nil {
 		return false, errors.New(string(stdout))
@@ -201,7 +200,7 @@ func (u *ContainerService) CreateCompose(req dto.ComposeCreate) error {
 	}
 	go func() {
 		taskItem.AddSubTask(i18n.GetMsgByKey("ComposeCreate"), func(t *task.Task) error {
-			cmd := exec.Command("docker", "compose", "-f", req.Path, "up", "-d")
+			cmd := getComposeCmd(req.Path, "up")
 			out, err := cmd.CombinedOutput()
 			taskItem.Log(i18n.GetWithName("ComposeCreateRes", string(out)))
 			if err != nil {

agent/app/service/cronjob.go

@@ -9,12 +9,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
-
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/jinzhu/copier"
@@ -67,12 +65,15 @@ func (u *CronjobService) SearchWithPage(search dto.PageCronjob) (int64, interfac
 			AlertType: cronjob.Type,
 			EntryID:   cronjob.ID,
 		}
-		alertCount := xpack.GetAlert(alertBase)
-		if alertCount != 0 {
-			item.AlertCount = alertCount
+		alertInfo, _ := alertRepo.Get(alertRepo.WithByType(alertBase.AlertType), alertRepo.WithByProject(strconv.Itoa(int(alertBase.EntryID))), repo.WithByStatus(constant.AlertEnable))
+		if alertInfo.SendCount != 0 {
+			item.AlertCount = alertInfo.SendCount
 		} else {
 			item.AlertCount = 0
 		}
+		if cronjob.Type == "snapshot" && len(cronjob.SnapshotRule) != 0 {
+			_ = json.Unmarshal([]byte(cronjob.SnapshotRule), &item.SnapshotRule)
+		}
 		dtoCronjobs = append(dtoCronjobs, item)
 	}
 	return total, dtoCronjobs, err
@@ -88,12 +89,16 @@ func (u *CronjobService) LoadInfo(req dto.OperateByID) (*dto.CronjobOperate, err
 		AlertType: cronjob.Type,
 		EntryID:   cronjob.ID,
 	}
-	alertCount := xpack.GetAlert(alertBase)
-	if alertCount != 0 {
-		item.AlertCount = alertCount
+	alertInfo, _ := alertRepo.Get(alertRepo.WithByType(alertBase.AlertType), alertRepo.WithByProject(strconv.Itoa(int(alertBase.EntryID))), repo.WithByStatus(constant.AlertEnable))
+	item.AlertMethod = alertInfo.Method
+	if alertInfo.SendCount != 0 {
+		item.AlertCount = alertInfo.SendCount
 	} else {
 		item.AlertCount = 0
 	}
+	if cronjob.Type == "snapshot" && len(cronjob.SnapshotRule) != 0 {
+		_ = json.Unmarshal([]byte(cronjob.SnapshotRule), &item.SnapshotRule)
+	}
 	return &item, err
 }
 
@@ -279,6 +284,13 @@ func (u *CronjobService) Create(req dto.CronjobOperate) error {
 	if err := copier.Copy(&cronjob, &req); err != nil {
 		return buserr.WithDetail("ErrStructTransform", err.Error(), nil)
 	}
+	if cronjob.Type == "snapshot" {
+		rule, err := json.Marshal(req.SnapshotRule)
+		if err != nil {
+			return err
+		}
+		cronjob.SnapshotRule = string(rule)
+	}
 	if cronjob.Type == "cutWebsiteLog" {
 		backupAccount, err := backupRepo.Get(repo.WithByType(constant.Local))
 		if backupAccount.ID == 0 {
@@ -300,13 +312,15 @@ func (u *CronjobService) Create(req dto.CronjobOperate) error {
 		return err
 	}
 	if req.AlertCount != 0 {
-		createAlert := dto.CreateOrUpdateAlert{
-			AlertTitle: req.AlertTitle,
-			AlertCount: req.AlertCount,
-			AlertType:  cronjob.Type,
-			EntryID:    cronjob.ID,
+		createAlert := dto.AlertCreate{
+			Title:     req.AlertTitle,
+			SendCount: req.AlertCount,
+			Method:    req.AlertMethod,
+			Type:      cronjob.Type,
+			Project:   strconv.Itoa(int(cronjob.ID)),
+			Status:    constant.AlertEnable,
 		}
-		err := xpack.CreateAlert(createAlert)
+		err := NewIAlertService().CreateAlert(createAlert)
 		if err != nil {
 			return err
 		}
@@ -354,11 +368,7 @@ func (u *CronjobService) Delete(req dto.CronjobBatchDelete) error {
 		if err := cronjobRepo.Delete(repo.WithByID(id)); err != nil {
 			return err
 		}
-		alertBase := dto.AlertBase{
-			AlertType: cronjob.Type,
-			EntryID:   cronjob.ID,
-		}
-		err := xpack.DeleteAlert(alertBase)
+		err := alertRepo.Delete(alertRepo.WithByProject(strconv.Itoa(int(cronjob.ID))), alertRepo.WithByType(cronjob.Type))
 		if err != nil {
 			return err
 		}
@@ -372,6 +382,13 @@ func (u *CronjobService) Update(id uint, req dto.CronjobOperate) error {
 	if err := copier.Copy(&cronjob, &req); err != nil {
 		return buserr.WithDetail("ErrStructTransform", err.Error(), nil)
 	}
+	if req.Type == "snapshot" {
+		itemRule, err := json.Marshal(req.SnapshotRule)
+		if err != nil {
+			return err
+		}
+		cronjob.SnapshotRule = string(itemRule)
+	}
 	cronModel, err := cronjobRepo.Get(repo.WithByID(id))
 	if err != nil {
 		return buserr.New("ErrRecordNotFound")
@@ -412,24 +429,27 @@ func (u *CronjobService) Update(id uint, req dto.CronjobOperate) error {
 	upMap["db_name"] = req.DBName
 	upMap["url"] = req.URL
 	upMap["source_dir"] = req.SourceDir
+	upMap["snapshot_rule"] = cronjob.SnapshotRule
 
 	upMap["source_account_ids"] = req.SourceAccountIDs
 	upMap["download_account_id"] = req.DownloadAccountID
 	upMap["retain_copies"] = req.RetainCopies
 	upMap["retry_times"] = req.RetryTimes
 	upMap["timeout"] = req.Timeout
+	upMap["ignore_err"] = req.IgnoreErr
 	upMap["secret"] = req.Secret
 	err = cronjobRepo.Update(id, upMap)
 	if err != nil {
 		return err
 	}
-	updateAlert := dto.CreateOrUpdateAlert{
-		AlertTitle: req.AlertTitle,
-		AlertType:  cronModel.Type,
-		AlertCount: req.AlertCount,
-		EntryID:    cronModel.ID,
+	updateAlert := dto.AlertCreate{
+		Title:     req.AlertTitle,
+		SendCount: req.AlertCount,
+		Method:    req.AlertMethod,
+		Type:      cronjob.Type,
+		Project:   strconv.Itoa(int(cronModel.ID)),
 	}
-	err = xpack.UpdateAlert(updateAlert)
+	err = NewIAlertService().ExternalUpdateAlert(updateAlert)
 	if err != nil {
 		return err
 	}

agent/app/service/cronjob_backup.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"os"
 	"path"
@@ -47,6 +48,7 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, t
 		return err
 	}
 	for _, app := range apps {
+		retry := 0
 		taskItem.AddSubTaskWithOps(task.GetTaskName(app.Name, task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 			var record model.BackupRecord
 			record.From = "cronjob"
@@ -55,14 +57,25 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, t
 			record.Name = app.App.Key
 			record.DetailName = app.Name
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-			backupDir := path.Join(global.Dir.TmpDir, fmt.Sprintf("app/%s/%s", app.App.Key, app.Name))
+			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/app/%s/%s", app.App.Key, app.Name))
 			record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
 			if err := doAppBackup(&app, task, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
-				return err
+				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+					retry++
+					return err
+				} else {
+					task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+					return nil
+				}
 			}
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
 			if err != nil {
-				return err
+				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+					retry++
+					return err
+				}
+				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				return nil
 			}
 			record.FileDir = path.Dir(downloadPath)
 			if err := backupRepo.CreateRecord(&record); err != nil {
@@ -86,6 +99,7 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 		return err
 	}
 	for _, web := range webs {
+		retry := 0
 		taskItem.AddSubTaskWithOps(task.GetTaskName(web.Alias, task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 			var record model.BackupRecord
 			record.From = "cronjob"
@@ -94,16 +108,27 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 			record.Name = web.Alias
 			record.DetailName = web.Alias
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-			backupDir := path.Join(global.Dir.TmpDir, fmt.Sprintf("website/%s", web.Alias))
+			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/website/%s", web.Alias))
 			record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", web.Alias, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
 
 			if err := doWebsiteBackup(&web, taskItem, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
-				return err
+				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+					retry++
+					return err
+				} else {
+					task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+					return nil
+				}
 			}
 
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
 			if err != nil {
-				return err
+				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+					retry++
+					return err
+				}
+				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				return nil
 			}
 			record.FileDir = path.Dir(downloadPath)
 			if err := backupRepo.CreateRecord(&record); err != nil {
@@ -127,6 +152,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 		return err
 	}
 	for _, dbInfo := range dbs {
+		retry := 0
 		itemName := fmt.Sprintf("%s[%s] - %s", dbInfo.Database, dbInfo.DBType, dbInfo.Name)
 		taskItem.AddSubTaskWithOps(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 			var record model.BackupRecord
@@ -137,21 +163,38 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 			record.DetailName = dbInfo.Name
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
 
-			backupDir := path.Join(global.Dir.TmpDir, fmt.Sprintf("database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
+			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
 			record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
-			if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+			if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" || cronjob.DBType == "mysql-cluster" {
 				if err := doMysqlBackup(dbInfo, backupDir, record.FileName); err != nil {
-					return err
+					if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+						retry++
+						return err
+					} else {
+						task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+						return nil
+					}
 				}
 			} else {
 				if err := doPostgresqlgBackup(dbInfo, backupDir, record.FileName); err != nil {
-					return err
+					if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+						retry++
+						return err
+					} else {
+						task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+						return nil
+					}
 				}
 			}
 
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
 			if err != nil {
-				return err
+				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
+					retry++
+					return err
+				}
+				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				return nil
 			}
 			record.FileDir = path.Dir(downloadPath)
 			if err := backupRepo.CreateRecord(&record); err != nil {
@@ -172,7 +215,7 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 			return err
 		}
 		fileName := fmt.Sprintf("%s.tar.gz", startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
-		backupDir := path.Join(global.Dir.TmpDir, fmt.Sprintf("%s/%s", cronjob.Type, cronjob.Name))
+		backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/%s/%s", cronjob.Type, cronjob.Name))
 
 		fileOp := files.NewFileOp()
 		if cronjob.IsDir {
@@ -193,7 +236,7 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 		record.CronjobID = cronjob.ID
 		record.Name = cronjob.Name
 		record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, fileName))
+		downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, fileName))
 		if err != nil {
 			taskItem.LogFailedWithErr("Upload backup file", err)
 			return err
@@ -218,7 +261,7 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 		}
 		nameItem := startTime.Format(constant.DateTimeSlimLayout) + common.RandStrAndNum(5)
 		fileName := fmt.Sprintf("system_log_%s.tar.gz", nameItem)
-		backupDir := path.Join(global.Dir.TmpDir, "log", nameItem)
+		backupDir := path.Join(global.Dir.LocalBackupDir, "tmp/log", nameItem)
 		if err := handleBackupLogs(taskItem, backupDir, fileName, cronjob.Secret); err != nil {
 			return err
 		}
@@ -228,7 +271,7 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 		record.CronjobID = cronjob.ID
 		record.Name = cronjob.Name
 		record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(path.Dir(backupDir), fileName))
+		downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(path.Dir(backupDir), fileName))
 		if err != nil {
 			taskItem.LogFailedWithErr("Upload backup file", err)
 			return err
@@ -250,10 +293,6 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.J
 	if err != nil {
 		return err
 	}
-	itemData, err := NewISnapshotService().LoadSnapshotData()
-	if err != nil {
-		return err
-	}
 
 	var record model.BackupRecord
 	record.From = "cronjob"
@@ -268,6 +307,11 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.J
 	if !global.IsMaster {
 		scope = "agent"
 	}
+
+	itemData, err := loadSnapWithRule(cronjob)
+	if err != nil {
+		return err
+	}
 	req := dto.SnapshotCreate{
 		Name:   fmt.Sprintf("snapshot-1panel-%s-%s-linux-%s-%s", scope, versionItem.Value, loadOs(), jobRecord.StartTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)),
 		Secret: cronjob.Secret,
@@ -278,11 +322,13 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.J
 		AppData:           itemData.AppData,
 		PanelData:         itemData.PanelData,
 		BackupData:        itemData.BackupData,
+		WithDockerConf:    true,
 		WithMonitorData:   true,
 		WithLoginLog:      true,
 		WithOperationLog:  true,
 		WithSystemLog:     true,
 		WithTaskLog:       true,
+		IgnoreFiles:       strings.Split(cronjob.ExclusionRules, ","),
 	}
 
 	if err := NewISnapshotService().SnapshotCreate(taskItem, req, jobRecord.ID, cronjob.RetryTimes, cronjob.Timeout); err != nil {
@@ -308,7 +354,7 @@ type DatabaseHelper struct {
 func loadDbsForJob(cronjob model.Cronjob) []DatabaseHelper {
 	var dbs []DatabaseHelper
 	if cronjob.DBName == "all" {
-		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" || cronjob.DBType == "mysql-cluster" {
 			databaseService := NewIDatabaseService()
 			mysqlItems, _ := databaseService.LoadItems(cronjob.DBType)
 			for _, mysql := range mysqlItems {
@@ -335,7 +381,7 @@ func loadDbsForJob(cronjob model.Cronjob) []DatabaseHelper {
 	dbNames := strings.Split(cronjob.DBName, ",")
 	for _, name := range dbNames {
 		itemID, _ := strconv.Atoi(name)
-		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" || cronjob.DBType == "mysql-cluster" {
 			mysqlItem, _ := mysqlRepo.Get(repo.WithByID(uint(itemID)))
 			dbs = append(dbs, DatabaseHelper{
 				ID:       mysqlItem.ID,
@@ -397,7 +443,7 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 					}
 				}
 			}
-			itemDir2 := path.Join(global.Dir.LocalBackupDir, "log/website", website.Alias)
+			itemDir2 := path.Join(global.Dir.LocalBackupDir, "tmp/log/website", website.Alias)
 			logFiles2, _ := os.ReadDir(itemDir2)
 			if len(logFiles2) != 0 {
 				for i := 0; i < len(logFiles2); i++ {
@@ -451,3 +497,52 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 	}()
 	return nil
 }
+
+func loadSnapWithRule(cronjob model.Cronjob) (dto.SnapshotData, error) {
+	itemData, err := NewISnapshotService().LoadSnapshotData()
+	if err != nil {
+		return itemData, err
+	}
+
+	if len(cronjob.SnapshotRule) == 0 {
+		return itemData, nil
+	}
+	var snapRule dto.SnapshotRule
+	if err := json.Unmarshal([]byte(cronjob.SnapshotRule), &snapRule); err != nil {
+		return itemData, err
+	}
+	if len(snapRule.IgnoreAppIDs) == 0 && !snapRule.WithImage {
+		return itemData, nil
+	}
+
+	var ignoreApps []model.AppInstall
+	if len(snapRule.IgnoreAppIDs) != 0 {
+		ignoreApps, _ = appInstallRepo.ListBy(context.Background(), repo.WithByIDs(snapRule.IgnoreAppIDs))
+	}
+	if len(ignoreApps) == 0 && !snapRule.WithImage {
+		return itemData, nil
+	}
+	for i := 0; i < len(itemData.AppData); i++ {
+		isIgnore := false
+		for _, ignore := range ignoreApps {
+			if ignore.App.Key == itemData.AppData[i].Key && ignore.Name == itemData.AppData[i].Name {
+				isIgnore = true
+				itemData.AppData[i].IsCheck = false
+				for j := 0; j < len(itemData.AppData[i].Children); j++ {
+					if itemData.AppData[i].Children[j].Label == "appData" {
+						itemData.AppData[i].Children[j].IsCheck = false
+					}
+				}
+				break
+			}
+		}
+		if snapRule.WithImage && !isIgnore {
+			for j := 0; j < len(itemData.AppData[i].Children); j++ {
+				if itemData.AppData[i].Children[j].Label == "appImage" {
+					itemData.AppData[i].Children[j].IsCheck = true
+				}
+			}
+		}
+	}
+	return itemData, nil
+}

agent/app/service/cronjob_helper.go

@@ -9,6 +9,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
+
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/app/repo"
@@ -19,7 +21,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
 	"github.com/1Panel-dev/1Panel/agent/utils/ntp"
-	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
 )
 
 func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
@@ -48,6 +49,7 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 			global.LOG.Debugf("preper to handle cron job [%s] %s failed, err: %v", cronjob.Type, cronjob.Name, err)
 			record.TaskID = ""
 			cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), record.Records)
+			handleCronJobAlert(cronjob)
 			return
 		}
 		if err := taskItem.Execute(); err != nil {
@@ -118,11 +120,21 @@ func (u *CronjobService) handleShell(cronjob model.Cronjob, taskItem *task.Task)
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTask(*taskItem))
 	taskItem.AddSubTaskWithOps(i18n.GetWithName("HandleShell", cronjob.Name), func(t *task.Task) error {
 		if len(cronjob.ContainerName) != 0 {
+			scriptItem := cronjob.Script
+			if cronjob.ScriptMode == "select" {
+				scriptItem = path.Join("/tmp", path.Base(cronjob.Script))
+				if err := cmdMgr.Run("docker", "cp", cronjob.Script, cronjob.ContainerName+":"+scriptItem); err != nil {
+					return err
+				}
+			}
 			command := "sh"
 			if len(cronjob.Command) != 0 {
 				command = cronjob.Command
 			}
-			return cmdMgr.Run("docker", "exec", cronjob.ContainerName, command, "-c", strings.ReplaceAll(cronjob.Script, "\"", "\\\""))
+			if len(cronjob.User) != 0 {
+				return cmdMgr.Run("docker", "exec", "-u", cronjob.User, cronjob.ContainerName, command, "-c", strings.ReplaceAll(scriptItem, "\"", "\\\""))
+			}
+			return cmdMgr.Run("docker", "exec", cronjob.ContainerName, command, "-c", strings.ReplaceAll(scriptItem, "\"", "\\\""))
 		}
 		if len(cronjob.Executor) == 0 {
 			cronjob.Executor = "bash"
@@ -252,23 +264,32 @@ func (u *CronjobService) handleSystemClean(cronjob model.Cronjob, taskItem *task
 	taskItem.AddSubTaskWithOps(i18n.GetMsgByKey("HandleSystemClean"), cleanTask, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 }
 
-func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, accountMap map[string]backupClientHelper, file string) (string, error) {
+func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, task *task.Task, accountMap map[string]backupClientHelper, file string) (string, error) {
 	defer func() {
 		_ = os.Remove(file)
 	}()
+	var errItem error
 	accounts := strings.Split(cronjob.SourceAccountIDs, ",")
-	cloudSrc := strings.TrimPrefix(file, global.Dir.TmpDir+"/")
+	cloudSrc := strings.TrimPrefix(file, global.Dir.LocalBackupDir+"/tmp/")
 	for _, account := range accounts {
 		if len(account) != 0 {
-			global.LOG.Debugf("start upload file to %s, dir: %s", accountMap[account].name, pathUtils.Join(accountMap[account].backupPath, cloudSrc))
-			if _, err := accountMap[account].client.Upload(file, pathUtils.Join(accountMap[account].backupPath, cloudSrc)); err != nil {
-				global.LOG.Errorf("upload file to %s failed, err: %v", accountMap[account].name, err)
+			task.LogStart(i18n.GetMsgWithMap("UploadFile", map[string]interface{}{
+				"file":   pathUtils.Join(accountMap[account].backupPath, cloudSrc),
+				"backup": accountMap[account].name,
+			}))
+			_, err := accountMap[account].client.Upload(file, pathUtils.Join(accountMap[account].backupPath, cloudSrc))
+			task.LogWithStatus(
+				i18n.GetMsgWithMap("UploadFile", map[string]interface{}{
+					"file":   pathUtils.Join(accountMap[account].backupPath, cloudSrc),
+					"backup": accountMap[account].name,
+				}), err)
+			if err != nil {
+				errItem = err
 				continue
 			}
-			global.LOG.Debugf("upload successful!")
 		}
 	}
-	return cloudSrc, nil
+	return cloudSrc, errItem
 }
 
 func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap map[string]backupClientHelper, record model.BackupRecord) {
@@ -340,9 +361,5 @@ func handleCronJobAlert(cronjob *model.Cronjob) {
 		EntryID:   cronjob.ID,
 		Param:     cronjob.Type,
 	}
-	err := xpack.PushAlert(pushAlert)
-	if err != nil {
-		global.LOG.Errorf("cronjob alert push failed, err: %v", err)
-		return
-	}
+	_ = alert_push.PushAlert(pushAlert)
 }

agent/app/service/dashboard.go

@@ -113,7 +113,7 @@ func (u *DashboardService) LoadCurrentInfoForNode() *dto.NodeCurrent {
 	memoryInfo, _ := mem.VirtualMemory()
 	currentInfo.MemoryTotal = memoryInfo.Total
 	currentInfo.MemoryAvailable = memoryInfo.Available
-	currentInfo.MemoryUsed = memoryInfo.Used
+	currentInfo.MemoryUsed = memoryInfo.Used + memoryInfo.Shared
 	currentInfo.MemoryUsedPercent = memoryInfo.UsedPercent
 
 	swapInfo, _ := mem.SwapMemory()
@@ -210,8 +210,11 @@ func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *d
 
 	memoryInfo, _ := mem.VirtualMemory()
 	currentInfo.MemoryTotal = memoryInfo.Total
+	currentInfo.MemoryUsed = memoryInfo.Used + memoryInfo.Shared
+	currentInfo.MemoryFree = memoryInfo.Free
+	currentInfo.MemoryCache = memoryInfo.Cached + memoryInfo.Buffers
+	currentInfo.MemoryShard = memoryInfo.Shared
 	currentInfo.MemoryAvailable = memoryInfo.Available
-	currentInfo.MemoryUsed = memoryInfo.Used
 	currentInfo.MemoryUsedPercent = memoryInfo.UsedPercent
 
 	swapInfo, _ := mem.SwapMemory()
@@ -390,10 +393,10 @@ type diskInfo struct {
 func loadDiskInfo() []dto.DiskInfo {
 	var datas []dto.DiskInfo
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(2 * time.Second))
-	stdout, err := cmdMgr.RunWithStdoutBashC("df -hT -P|grep '/'|grep -v tmpfs|grep -v 'snap/core'|grep -v udev")
+	stdout, err := cmdMgr.RunWithStdoutBashC("timeout 2 df -hT -P | awk 'NR>1 && !/tmpfs|snap\\/core|udev/ {print}'")
 	if err != nil {
 		cmdMgr2 := cmd.NewCommandMgr(cmd.WithTimeout(1 * time.Second))
-		stdout, err = cmdMgr2.RunWithStdoutBashC("df -lhT -P|grep '/'|grep -v tmpfs|grep -v 'snap/core'|grep -v udev")
+		stdout, err = cmdMgr2.RunWithStdoutBashC("timeout 1 df -lhT -P | awk 'NR>1 && !/tmpfs|snap\\/core|udev/ {print}'")
 		if err != nil {
 			return datas
 		}

agent/app/service/database.go

@@ -92,7 +92,7 @@ func (u *DatabaseService) LoadItems(dbType string) ([]dto.DatabaseItem, error) {
 	dbs, err := databaseRepo.GetList(databaseRepo.WithTypeList(dbType))
 	var datas []dto.DatabaseItem
 	for _, db := range dbs {
-		if dbType == "postgresql" {
+		if dbType == constant.AppPostgresql || dbType == constant.AppPostgresqlCluster {
 			items, _ := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(db.Name))
 			for _, item := range items {
 				var dItem dto.DatabaseItem

agent/app/service/database_common.go

@@ -34,7 +34,7 @@ func (u *DBCommonService) LoadBaseInfo(req dto.OperationWithNameAndType) (*dto.D
 	}
 	data.ContainerName = app.ContainerName
 	data.Name = app.Name
-	data.Port = int64(app.Port)
+	data.Port = app.Port
 
 	return &data, nil
 }
@@ -42,6 +42,10 @@ func (u *DBCommonService) LoadBaseInfo(req dto.OperationWithNameAndType) (*dto.D
 func (u *DBCommonService) LoadDatabaseFile(req dto.OperationWithNameAndType) (string, error) {
 	filePath := ""
 	switch req.Type {
+	case "mysql-cluster-conf":
+		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/mysql-cluster/%s/conf/my.cnf", req.Name))
+	case "postgresql-cluster-conf":
+		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/postgresql-cluster/%s/data/postgresql.conf", req.Name))
 	case "mysql-conf":
 		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/mysql/%s/conf/my.cnf", req.Name))
 	case "mariadb-conf":
@@ -50,6 +54,8 @@ func (u *DBCommonService) LoadDatabaseFile(req dto.OperationWithNameAndType) (st
 		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/postgresql/%s/data/postgresql.conf", req.Name))
 	case "redis-conf":
 		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/redis/%s/conf/redis.conf", req.Name))
+	case "redis-cluster-conf":
+		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/redis-cluster/%s/conf/redis.conf", req.Name))
 	}
 	if _, err := os.Stat(filePath); err != nil {
 		return "", buserr.New("ErrHttpReqNotFound")

agent/app/service/database_mysql.go

@@ -534,7 +534,7 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 	info.File = "OFF"
 	info.Position = "OFF"
 	masterStatus := "show master status;"
-	if common.CompareAppVersion(app.Version, "8.4.0") && req.Type == constant.AppMysql {
+	if common.CompareAppVersion(app.Version, "8.4.0") && (req.Type == constant.AppMysql || req.Type == constant.AppMysqlCluster) {
 		masterStatus = "show binary log status;"
 	}
 	rows, err := executeSqlForRows(app.ContainerName, app.Key, app.Password, masterStatus)
@@ -553,10 +553,13 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 }
 
 func executeSqlForMaps(containerName, dbType, password, command string) (map[string]string, error) {
+	if dbType == "mysql-cluster" {
+		dbType = "mysql"
+	}
 	cmd := exec.Command("docker", "exec", containerName, dbType, "-uroot", "-p"+password, "-e", command)
 	stdout, err := cmd.CombinedOutput()
 	stdStr := strings.ReplaceAll(string(stdout), "mysql: [Warning] Using a password on the command line interface can be insecure.\n", "")
-	if err != nil || strings.HasPrefix(string(stdStr), "ERROR ") {
+	if err != nil || strings.HasPrefix(stdStr, "ERROR ") {
 		return nil, errors.New(stdStr)
 	}
 
@@ -572,10 +575,13 @@ func executeSqlForMaps(containerName, dbType, password, command string) (map[str
 }
 
 func executeSqlForRows(containerName, dbType, password, command string) ([]string, error) {
+	if dbType == "mysql-cluster" {
+		dbType = "mysql"
+	}
 	cmd := exec.Command("docker", "exec", containerName, dbType, "-uroot", "-p"+password, "-e", command)
 	stdout, err := cmd.CombinedOutput()
 	stdStr := strings.ReplaceAll(string(stdout), "mysql: [Warning] Using a password on the command line interface can be insecure.\n", "")
-	if err != nil || strings.HasPrefix(string(stdStr), "ERROR ") {
+	if err != nil || strings.HasPrefix(stdStr, "ERROR ") {
 		return nil, errors.New(stdStr)
 	}
 	return strings.Split(stdStr, "\n"), nil

agent/app/service/database_redis.go

@@ -28,9 +28,9 @@ type IRedisService interface {
 	UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate) error
 	ChangePassword(info dto.ChangeRedisPass) error
 
-	LoadStatus(req dto.OperationWithName) (*dto.RedisStatus, error)
-	LoadConf(req dto.OperationWithName) (*dto.RedisConf, error)
-	LoadPersistenceConf(req dto.OperationWithName) (*dto.RedisPersistence, error)
+	LoadStatus(req dto.LoadRedisStatus) (*dto.RedisStatus, error)
+	LoadConf(req dto.LoadRedisStatus) (*dto.RedisConf, error)
+	LoadPersistenceConf(req dto.LoadRedisStatus) (*dto.RedisPersistence, error)
 
 	CheckHasCli() bool
 	InstallCli() error
@@ -41,7 +41,7 @@ func NewIRedisService() IRedisService {
 }
 
 func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Database)
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.DBType, req.Database)
 	if err != nil {
 		return err
 	}
@@ -50,7 +50,7 @@ func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
 	confs = append(confs, redisConfig{key: "timeout", value: req.Timeout})
 	confs = append(confs, redisConfig{key: "maxclients", value: req.Maxclients})
 	confs = append(confs, redisConfig{key: "maxmemory", value: req.Maxmemory})
-	if err := confSet(redisInfo.Name, "", confs); err != nil {
+	if err := confSet(redisInfo.Name, req.DBType, "", confs); err != nil {
 		return err
 	}
 	if _, err := compose.Restart(fmt.Sprintf("%s/redis/%s/docker-compose.yml", global.Dir.AppInstallDir, redisInfo.Name)); err != nil {
@@ -84,7 +84,7 @@ func (u *RedisService) InstallCli() error {
 		Image:   "redis:7.4.4",
 		Network: "1panel-network",
 	}
-	return NewIContainerService().ContainerCreate(item)
+	return NewIContainerService().ContainerCreate(item, false)
 }
 
 func (u *RedisService) ChangePassword(req dto.ChangeRedisPass) error {
@@ -107,7 +107,7 @@ func (u *RedisService) ChangePassword(req dto.ChangeRedisPass) error {
 }
 
 func (u *RedisService) UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate) error {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Database)
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.DBType, req.Database)
 	if err != nil {
 		return err
 	}
@@ -119,18 +119,18 @@ func (u *RedisService) UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate)
 		confs = append(confs, redisConfig{key: "appendonly", value: req.Appendonly})
 		confs = append(confs, redisConfig{key: "appendfsync", value: req.Appendfsync})
 	}
-	if err := confSet(redisInfo.Name, req.Type, confs); err != nil {
+	if err := confSet(redisInfo.Name, req.DBType, req.Type, confs); err != nil {
 		return err
 	}
-	if _, err := compose.Restart(fmt.Sprintf("%s/redis/%s/docker-compose.yml", global.Dir.AppInstallDir, redisInfo.Name)); err != nil {
+	if _, err := compose.Restart(fmt.Sprintf("%s/%s/%s/docker-compose.yml", global.Dir.AppInstallDir, req.DBType, redisInfo.Name)); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (u *RedisService) LoadStatus(req dto.OperationWithName) (*dto.RedisStatus, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadStatus(req dto.LoadRedisStatus) (*dto.RedisStatus, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.Type, req.Name)
 	if err != nil {
 		return nil, err
 	}
@@ -157,8 +157,8 @@ func (u *RedisService) LoadStatus(req dto.OperationWithName) (*dto.RedisStatus,
 	return &info, nil
 }
 
-func (u *RedisService) LoadConf(req dto.OperationWithName) (*dto.RedisConf, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadConf(req dto.LoadRedisStatus) (*dto.RedisConf, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.Type, req.Name)
 	if err != nil {
 		return nil, err
 	}
@@ -174,8 +174,8 @@ func (u *RedisService) LoadConf(req dto.OperationWithName) (*dto.RedisConf, erro
 	return &item, nil
 }
 
-func (u *RedisService) LoadPersistenceConf(req dto.OperationWithName) (*dto.RedisPersistence, error) {
-	redisInfo, err := appInstallRepo.LoadBaseInfo("redis", req.Name)
+func (u *RedisService) LoadPersistenceConf(req dto.LoadRedisStatus) (*dto.RedisPersistence, error) {
+	redisInfo, err := appInstallRepo.LoadBaseInfo(req.Type, req.Name)
 	if err != nil {
 		return nil, err
 	}
@@ -214,8 +214,8 @@ type redisConfig struct {
 	value string
 }
 
-func confSet(redisName string, updateType string, changeConf []redisConfig) error {
-	path := fmt.Sprintf("%s/redis/%s/conf/redis.conf", global.Dir.AppInstallDir, redisName)
+func confSet(redisName string, redisType string, updateType string, changeConf []redisConfig) error {
+	path := fmt.Sprintf("%s/%s/%s/conf/redis.conf", global.Dir.AppInstallDir, redisType, redisName)
 	lineBytes, err := os.ReadFile(path)
 	if err != nil {
 		return err

agent/app/service/device.go

@@ -120,7 +120,7 @@ func (u *DeviceService) Update(key, value string) error {
 		if err := ntp.UpdateSystemTimeZone(value); err != nil {
 			return err
 		}
-		go common.RestartService(true, true, false)
+		go common.RestartService(global.IsMaster, true, false)
 	case "DNS":
 		if err := updateDNS(strings.Split(value, ",")); err != nil {
 			return err
@@ -246,18 +246,23 @@ func (u *DeviceService) UpdateSwap(req dto.SwapHelper) error {
 		}
 		return operateSwapWithFile(true, req)
 	}
-	std1, err := cmd.RunDefaultWithStdoutBashCf("%s dd if=/dev/zero of=%s bs=1024 count=%d", cmd.SudoHandleCmd(), req.Path, req.Size)
+	stdDD, err := cmd.RunDefaultWithStdoutBashCf("%s dd if=/dev/zero of=%s bs=1024 count=%d", cmd.SudoHandleCmd(), req.Path, req.Size)
 	if err != nil {
-		return fmt.Errorf("handle dd path %s failed, err: %s", req.Path, std1)
+		return fmt.Errorf("handle dd %s failed, std: %s, err: %s", req.Path, stdDD, err)
 	}
-	std2, err := cmd.RunDefaultWithStdoutBashCf("%s mkswap -f %s", cmd.SudoHandleCmd(), req.Path)
+	stdChmod, err := cmd.RunDefaultWithStdoutBashCf("%s chmod 0600 %s", cmd.SudoHandleCmd(), req.Path)
 	if err != nil {
-		return fmt.Errorf("handle dd path %s failed, err: %s", req.Path, std2)
+		return fmt.Errorf("handle chmod 0600 %s failed,std: %s, err: %s", req.Path, stdChmod, err)
 	}
-	std3, err := cmd.RunDefaultWithStdoutBashCf("%s swapon %s", cmd.SudoHandleCmd(), req.Path)
+	stdMkswap, err := cmd.RunDefaultWithStdoutBashCf("%s mkswap -f %s", cmd.SudoHandleCmd(), req.Path)
+	if err != nil {
+		return fmt.Errorf("handle mkswap -f %s failed, std: %s, err: %s", req.Path, stdMkswap, err)
+	}
+
+	stdSwapon, err := cmd.RunDefaultWithStdoutBashCf("%s swapon %s", cmd.SudoHandleCmd(), req.Path)
 	if err != nil {
 		_, _ = cmd.RunDefaultWithStdoutBashCf("%s swapoff %s", cmd.SudoHandleCmd(), req.Path)
-		return fmt.Errorf("handle dd path %s failed, err: %s", req.Path, std3)
+		return fmt.Errorf("handle swapoff %s failed,std: %s, err: %s", req.Path, stdSwapon, err)
 	}
 	return operateSwapWithFile(false, req)
 }

agent/app/service/device_clean.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"sort"
 	"strings"
 	"time"
@@ -12,6 +13,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/build"
 	"github.com/docker/docker/api/types/filters"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
@@ -50,7 +52,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 		ID:          uuid.NewString(),
 		Label:       "1panel_original",
 		Size:        uint64(originalSize),
-		IsCheck:     true,
+		IsCheck:     originalSize > 0,
 		IsRecommend: true,
 		Type:        "1panel_original",
 		Children:    loadTreeWithDir(true, "1panel_original", originalPath, fileOp),
@@ -85,7 +87,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 		ID:          uuid.NewString(),
 		Label:       "snapshot",
 		Size:        snapSize,
-		IsCheck:     true,
+		IsCheck:     snapSize > 0,
 		IsRecommend: true,
 		Type:        "snapshot",
 		Children:    snapTree,
@@ -100,7 +102,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 		ID:          uuid.NewString(),
 		Label:       "rollback",
 		Size:        rollbackSize,
-		IsCheck:     true,
+		IsCheck:     rollbackSize > 0,
 		IsRecommend: true,
 		Type:        "rollback",
 		Children:    rollBackTree,
@@ -126,7 +128,7 @@ func (u *DeviceService) Scan() dto.CleanData {
 		ID:          uuid.NewString(),
 		Label:       "unused",
 		Size:        unusedSize,
-		IsCheck:     true,
+		IsCheck:     unusedSize > 0,
 		IsRecommend: true,
 		Type:        "unused",
 		Children:    unusedTree,
@@ -338,7 +340,7 @@ func doSystemClean(taskItem *task.Task) func(t *task.Task) error {
 		}
 
 		dropWithTask(path.Join(global.Dir.BaseDir, tmpUploadPath), taskItem, &size, &fileCount)
-		dropWithTask(path.Join(global.Dir.BaseDir, uploadPath), taskItem, &size, &fileCount)
+		dropWithExclude(path.Join(global.Dir.BaseDir, uploadPath), []string{"theme"}, taskItem, &size, &fileCount)
 		dropWithTask(path.Join(global.Dir.BaseDir, downloadPath), taskItem, &size, &fileCount)
 
 		logFiles, _ := os.ReadDir(global.Dir.LogDir)
@@ -662,7 +664,7 @@ func dropBuildCache() {
 	if err != nil {
 		global.LOG.Errorf("do not get docker client")
 	}
-	opts := types.BuildCachePruneOptions{}
+	opts := build.CachePruneOptions{}
 	opts.All = true
 	_, err = client.BuildCachePrune(context.Background(), opts)
 	if err != nil {
@@ -714,6 +716,30 @@ func dropVolumes() {
 	}
 }
 
+func dropWithExclude(pathToDelete string, excludeSubDirs []string, taskItem *task.Task, size *int64, count *int) {
+	entries, err := os.ReadDir(pathToDelete)
+	if err != nil {
+		taskItem.LogFailed(fmt.Sprintf("read dir %s failed: %v", pathToDelete, err))
+		return
+	}
+
+	for _, entry := range entries {
+		name := entry.Name()
+		fullPath := filepath.Join(pathToDelete, name)
+		excluded := false
+		for _, ex := range excludeSubDirs {
+			if name == ex {
+				excluded = true
+				break
+			}
+		}
+		if excluded {
+			continue
+		}
+		dropWithTask(fullPath, taskItem, size, count)
+	}
+}
+
 func dropWithTask(itemPath string, taskItem *task.Task, size *int64, count *int) {
 	itemSize := int64(0)
 	itemCount := 0

agent/app/service/docker.go

@@ -220,16 +220,6 @@ func (u *DockerService) UpdateConf(req dto.SettingUpdate, withRestart bool) erro
 			daemonMap["proxies"] = proxies
 		}
 	}
-	if len(daemonMap) == 0 {
-		if len(file) == 0 {
-			return nil
-		}
-		_ = os.Remove(constant.DaemonJsonPath)
-		if withRestart {
-			return restartDocker()
-		}
-		return nil
-	}
 	newJson, err := json.MarshalIndent(daemonMap, "", "\t")
 	if err != nil {
 		return err
@@ -277,11 +267,6 @@ func (u *DockerService) UpdateLogOption(req dto.LogOption) error {
 	_ = json.Unmarshal(file, &daemonMap)
 
 	changeLogOption(daemonMap, req.LogMaxFile, req.LogMaxSize)
-	if len(daemonMap) == 0 {
-		_ = os.Remove(constant.DaemonJsonPath)
-		_ = restartDocker()
-		return nil
-	}
 	newJson, err := json.MarshalIndent(daemonMap, "", "\t")
 	if err != nil {
 		return err
@@ -321,11 +306,6 @@ func (u *DockerService) UpdateIpv6Option(req dto.Ipv6Option) error {
 	if req.Experimental {
 		daemonMap["experimental"] = req.Experimental
 	}
-	if len(daemonMap) == 0 {
-		_ = os.Remove(constant.DaemonJsonPath)
-		_ = restartDocker()
-		return nil
-	}
 	newJson, err := json.MarshalIndent(daemonMap, "", "\t")
 	if err != nil {
 		return err
@@ -345,13 +325,6 @@ func (u *DockerService) UpdateIpv6Option(req dto.Ipv6Option) error {
 }
 
 func (u *DockerService) UpdateConfByFile(req dto.DaemonJsonUpdateByFile) error {
-	if len(req.File) == 0 {
-		_ = os.Remove(constant.DaemonJsonPath)
-		if err := restartDocker(); err != nil {
-			return err
-		}
-		return nil
-	}
 	err := createIfNotExistDaemonJsonFile()
 	if err != nil {
 		return err

agent/app/service/entry.go

@@ -50,4 +50,5 @@ var (
 	taskRepo = repo.NewITaskRepo()
 
 	groupRepo = repo.NewIGroupRepo()
+	alertRepo = repo.NewIAlertRepo()
 )

agent/app/service/file.go

@@ -4,7 +4,10 @@ import (
 	"bufio"
 	"context"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/jinzhu/copier"
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/encoding/simplifiedchinese"
 	"io"
 	"io/fs"
 	"os"
@@ -17,8 +20,6 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/1Panel-dev/1Panel/agent/app/dto"
-
 	"github.com/1Panel-dev/1Panel/agent/app/repo"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
@@ -27,7 +28,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"golang.org/x/net/html/charset"
 	"golang.org/x/sys/unix"
-	"golang.org/x/text/encoding/simplifiedchinese"
 	"golang.org/x/text/transform"
 
 	"github.com/1Panel-dev/1Panel/agent/global"
@@ -337,10 +337,17 @@ func (f *FileService) GetContent(op request.FileContentReq) (response.FileInfo,
 	}
 	if !utf8.Valid(content) {
 		_, decodeName, _ := charset.DetermineEncoding(content, "")
-		if decodeName == "windows-1252" {
+		decoder := files.GetDecoderByName(decodeName)
+		if decoder != nil {
 			reader := strings.NewReader(info.Content)
-			item := transform.NewReader(reader, simplifiedchinese.GBK.NewDecoder())
-			contents, err := io.ReadAll(item)
+			var dec *encoding.Decoder
+			if decodeName == "windows-1252" {
+				dec = simplifiedchinese.GBK.NewDecoder()
+			} else {
+				dec = decoder.NewDecoder()
+			}
+			decodedReader := transform.NewReader(reader, dec)
+			contents, err := io.ReadAll(decodedReader)
 			if err != nil {
 				return response.FileInfo{}, err
 			}
@@ -390,10 +397,18 @@ func (f *FileService) MvFile(m request.FileMove) error {
 			return buserr.New("ErrMovePathFailed")
 		}
 	}
+	var errs []error
 	if m.Type == "cut" {
+		if len(m.CoverPaths) > 0 {
+			for _, src := range m.CoverPaths {
+				if err := fo.CopyAndReName(src, m.NewPath, "", true); err != nil {
+					errs = append(errs, err)
+					global.LOG.Errorf("cut copy file [%s] to [%s] failed, err: %s", src, m.NewPath, err.Error())
+				}
+			}
+		}
 		return fo.Cut(m.OldPaths, m.NewPath, m.Name, m.Cover)
 	}
-	var errs []error
 	if m.Type == "copy" {
 		for _, src := range m.OldPaths {
 			if err := fo.CopyAndReName(src, m.NewPath, m.Name, m.Cover); err != nil {
@@ -565,6 +580,7 @@ func (f *FileService) BatchCheckFiles(req request.FilePathsCheck) []response.Exi
 				Name:    info.Name(),
 				Path:    filePath,
 				ModTime: info.ModTime(),
+				IsDir:   info.IsDir(),
 			})
 		}
 	}

agent/app/service/firewall.go

@@ -182,6 +182,7 @@ func (u *FirewallService) OperateFirewall(operation string) error {
 	if err != nil {
 		return err
 	}
+	needRestartDocker := false
 	switch operation {
 	case "start":
 		if err := client.Start(); err != nil {
@@ -191,26 +192,30 @@ func (u *FirewallService) OperateFirewall(operation string) error {
 			_ = client.Stop()
 			return err
 		}
-		_, _ = cmd.RunDefaultWithStdoutBashC("systemctl restart docker")
-		return nil
+		needRestartDocker = true
 	case "stop":
 		if err := client.Stop(); err != nil {
 			return err
 		}
-		_, _ = cmd.RunDefaultWithStdoutBashC("systemctl restart docker")
-		return nil
+		needRestartDocker = true
 	case "restart":
 		if err := client.Restart(); err != nil {
 			return err
 		}
-		_, _ = cmd.RunDefaultWithStdoutBashC("systemctl restart docker")
-		return nil
+		needRestartDocker = true
 	case "disablePing":
 		return u.updatePingStatus("0")
 	case "enablePing":
 		return u.updatePingStatus("1")
+	default:
+		return fmt.Errorf("not supported operation: %s", operation)
 	}
-	return fmt.Errorf("not support such operation: %s", operation)
+	if needRestartDocker {
+		if err := restartDocker(); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func (u *FirewallService) OperatePortRule(req dto.PortRuleOperate, reload bool) error {

agent/app/service/ftp.go

@@ -105,21 +105,23 @@ func (f *FtpService) Sync() error {
 	if err != nil {
 		return err
 	}
+	currentData := make(map[string]model.Ftp)
+	for _, item := range listsInDB {
+		currentData[item.User] = item
+	}
 	sameData := make(map[string]struct{})
 	for _, item := range lists {
-		for _, itemInDB := range listsInDB {
-			if item.User == itemInDB.User {
-				sameData[item.User] = struct{}{}
-				if item.Path != itemInDB.Path || item.Status != itemInDB.Status {
-					_ = ftpRepo.Update(itemInDB.ID, map[string]interface{}{"path": item.Path, "status": item.Status})
+		if itemInDB, ok := currentData[item.User]; ok {
+			sameData[item.User] = struct{}{}
+			if item.Path != itemInDB.Path || item.Status != itemInDB.Status {
+				if err := ftpRepo.Update(itemInDB.ID, map[string]interface{}{"path": item.Path, "status": item.Status}); err != nil {
+					return err
 				}
-				break
 			}
-		}
-	}
-	for _, item := range lists {
-		if _, ok := sameData[item.User]; !ok {
-			_ = ftpRepo.Create(&model.Ftp{User: item.User, Path: item.Path, Status: item.Status})
+		} else {
+			if err := ftpRepo.Create(&model.Ftp{User: item.User, Path: item.Path, Status: item.Status}); err != nil {
+				return err
+			}
 		}
 	}
 	for _, item := range listsInDB {

agent/app/service/host_tool.go

@@ -602,7 +602,7 @@ func getProcessStatus(config *response.SupervisorProcessConfig, containerName st
 		out, err = exec.Command("supervisorctl", processNames...).Output()
 		output = string(out)
 	}
-	if containerName == "" && err != nil {
+	if output == "" && err != nil {
 		return err
 	}
 	lines := strings.Split(output, "\n")

agent/app/service/image.go

@@ -22,7 +22,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/i18n"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
-	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/build"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/api/types/registry"
@@ -189,7 +189,7 @@ func (u *ImageService) ImageBuild(req dto.ImageBuild) error {
 		return err
 	}
 
-	opts := types.ImageBuildOptions{
+	opts := build.ImageBuildOptions{
 		Dockerfile: fileName,
 		Tags:       []string{req.Name},
 		Remove:     true,
@@ -432,7 +432,7 @@ func formatFileSize(fileSize int64) (size string) {
 	}
 }
 
-func checkUsed(imageID string, containers []types.Container) bool {
+func checkUsed(imageID string, containers []container.Summary) bool {
 	for _, container := range containers {
 		if container.ImageID == imageID {
 			return true

agent/app/service/image_repo.go

@@ -28,7 +28,7 @@ type IImageRepoService interface {
 	Login(req dto.OperateByID) error
 	Create(req dto.ImageRepoCreate) error
 	Update(req dto.ImageRepoUpdate) error
-	BatchDelete(req dto.ImageRepoDelete) error
+	Delete(req dto.OperateByID) error
 }
 
 func NewIImageRepoService() IImageRepoService {
@@ -91,29 +91,7 @@ func (u *ImageRepoService) Create(req dto.ImageRepoCreate) error {
 		if err := u.handleRegistries(req.DownloadUrl, "", "create"); err != nil {
 			return fmt.Errorf("create registry %s failed, err: %v", req.DownloadUrl, err)
 		}
-		stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl restart docker")
-		if err != nil {
-			return errors.New(string(stdout))
-		}
-		ticker := time.NewTicker(3 * time.Second)
-		defer ticker.Stop()
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*20)
-		if err := func() error {
-			for range ticker.C {
-				select {
-				case <-ctx.Done():
-					cancel()
-					return errors.New("the docker service cannot be restarted")
-				default:
-					stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl is-active docker")
-					if string(stdout) == "active\n" && err == nil {
-						global.LOG.Info("docker restart with new conf successful!")
-						return nil
-					}
-				}
-			}
-			return nil
-		}(); err != nil {
+		if err := stopBeforeUpdateRepo(); err != nil {
 			return err
 		}
 	}
@@ -132,15 +110,32 @@ func (u *ImageRepoService) Create(req dto.ImageRepoCreate) error {
 	return imageRepoRepo.Create(&imageRepo)
 }
 
-func (u *ImageRepoService) BatchDelete(req dto.ImageRepoDelete) error {
-	for _, id := range req.Ids {
-		if id == 1 {
-			return errors.New("The default value cannot be edit !")
-		}
+func (u *ImageRepoService) Delete(req dto.OperateByID) error {
+	if req.ID == 1 {
+		return errors.New("The default value cannot be edit !")
 	}
-	if err := imageRepoRepo.Delete(repo.WithByIDs(req.Ids)); err != nil {
+	itemRepo, _ := imageRepoRepo.Get(repo.WithByID(req.ID))
+	if itemRepo.ID == 0 {
+		return buserr.New("ErrRecordNotFound")
+	}
+	if itemRepo.Auth {
+		_, _ = cmd.NewCommandMgr().RunWithStdout("docker", "logout", "-i", itemRepo.DownloadUrl)
+	}
+	if itemRepo.Protocol == "https" {
+		return imageRepoRepo.Delete(repo.WithByID(req.ID))
+	}
+	if err := u.handleRegistries("", itemRepo.DownloadUrl, "delete"); err != nil {
+		return fmt.Errorf("delete registry %s failed, err: %v", itemRepo.DownloadUrl, err)
+	}
+	if err := validateDockerConfig(); err != nil {
 		return err
 	}
+	if err := imageRepoRepo.Delete(repo.WithByID(req.ID)); err != nil {
+		return err
+	}
+	go func() {
+		_ = restartDocker()
+	}()
 	return nil
 }
 
@@ -155,38 +150,39 @@ func (u *ImageRepoService) Update(req dto.ImageRepoUpdate) error {
 	if err != nil {
 		return err
 	}
+	needRestart := false
 	if repo.Protocol == "http" && req.Protocol == "https" {
 		if err := u.handleRegistries("", repo.DownloadUrl, "delete"); err != nil {
 			return fmt.Errorf("delete registry %s failed, err: %v", repo.DownloadUrl, err)
 		}
+		needRestart = true
 	}
 	if repo.Protocol == "http" && req.Protocol == "http" {
 		if err := u.handleRegistries(req.DownloadUrl, repo.DownloadUrl, "update"); err != nil {
 			return fmt.Errorf("update registry %s => %s failed, err: %v", repo.DownloadUrl, req.DownloadUrl, err)
 		}
+		needRestart = repo.DownloadUrl == req.DownloadUrl
 	}
 	if repo.Protocol == "https" && req.Protocol == "http" {
-		if err := u.handleRegistries(req.DownloadUrl, "", "create"); err != nil {
-			return fmt.Errorf("create registry %s failed, err: %v", req.DownloadUrl, err)
-		}
-	}
-	if repo.Auth != req.Auth || repo.DownloadUrl != req.DownloadUrl {
-		if repo.Auth {
-			cmdMgr := cmd.NewCommandMgr()
-			_, _ = cmdMgr.RunWithStdout("docker", "logout", "-i", repo.DownloadUrl)
-		}
-		if req.Auth {
-			if err := u.CheckConn(req.DownloadUrl, req.Username, req.Password); err != nil {
-				return err
+		if req.DownloadUrl != repo.DownloadUrl {
+			if err := u.handleRegistries(req.DownloadUrl, repo.DownloadUrl, "update"); err != nil {
+				return fmt.Errorf("update registry %s => %s failed, err: %v", repo.DownloadUrl, req.DownloadUrl, err)
 			}
+			needRestart = true
 		}
 	}
-
-	if err := validateDockerConfig(); err != nil {
-		return err
+	if needRestart {
+		if err := stopBeforeUpdateRepo(); err != nil {
+			return err
+		}
 	}
-	if err := restartDocker(); err != nil {
-		return err
+	if repo.Auth {
+		_, _ = cmd.NewCommandMgr().RunWithStdout("docker", "logout", "-i", repo.DownloadUrl)
+	}
+	if req.Auth {
+		if err := u.CheckConn(req.DownloadUrl, req.Username, req.Password); err != nil {
+			return err
+		}
 	}
 
 	upMap := make(map[string]interface{})
@@ -261,3 +257,34 @@ func (u *ImageRepoService) handleRegistries(newHost, delHost, handle string) err
 	}
 	return nil
 }
+
+func stopBeforeUpdateRepo() error {
+	if err := validateDockerConfig(); err != nil {
+		return err
+	}
+	if err := restartDocker(); err != nil {
+		return err
+	}
+	ticker := time.NewTicker(3 * time.Second)
+	defer ticker.Stop()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
+	if err := func() error {
+		for range ticker.C {
+			select {
+			case <-ctx.Done():
+				cancel()
+				return errors.New("the docker service cannot be restarted")
+			default:
+				stdout, err := cmd.RunDefaultWithStdoutBashC("systemctl is-active docker")
+				if string(stdout) == "active\n" && err == nil {
+					global.LOG.Info("docker restart with new conf successful!")
+					return nil
+				}
+			}
+		}
+		return nil
+	}(); err != nil {
+		return err
+	}
+	return nil
+}

agent/app/service/mcp_server.go

@@ -283,11 +283,19 @@ func (m McpServerService) BindDomain(req request.McpBindDomain) error {
 		}
 	}
 	group, _ := groupRepo.Get(groupRepo.WithByWebsiteDefault())
+
+	domain, err := ParseDomain(req.Domain)
+	if err != nil {
+		return err
+	}
+	if domain.Port == 0 {
+		domain.Port = nginxInstall.HttpPort
+	}
 	createWebsiteReq := request.WebsiteCreate{
 		Domains: []request.WebsiteDomain{
 			{
-				Domain: req.Domain,
-				Port:   80,
+				Domain: domain.Domain,
+				Port:   domain.Port,
 			},
 		},
 		Alias:          strings.ToLower(req.Domain),

agent/app/service/runtime.go

@@ -52,6 +52,7 @@ type IRuntimeService interface {
 	SyncForRestart() error
 	SyncRuntimeStatus() error
 	DeleteCheck(installID uint) ([]dto.AppResource, error)
+	UpdateRemark(req request.RuntimeRemark) error
 
 	GetPHPExtensions(runtimeID uint) (response.PHPExtensionRes, error)
 	InstallPHPExtension(req request.PHPExtensionInstallReq) error
@@ -108,6 +109,7 @@ func (r *RuntimeService) Create(create request.RuntimeCreate) (*model.Runtime, e
 				Type:     create.Type,
 				Version:  create.Version,
 				Status:   constant.StatusNormal,
+				Remark:   create.Remark,
 			}
 			return nil, runtimeRepo.Create(context.Background(), runtime)
 		}
@@ -168,6 +170,7 @@ func (r *RuntimeService) Create(create request.RuntimeCreate) (*model.Runtime, e
 		Version:       create.Version,
 		ContainerName: containerName.(string),
 		Port:          strings.Join(hostPorts, ","),
+		Remark:        create.Remark,
 	}
 
 	switch create.Type {
@@ -208,6 +211,9 @@ func (r *RuntimeService) Page(req request.RuntimeSearch) (int64, []response.Runt
 	if err != nil {
 		return 0, nil, err
 	}
+	if len(runtimes) == 0 {
+		return 0, res, nil
+	}
 	if err = SyncRuntimesStatus(runtimes); err != nil {
 		return 0, nil, err
 	}
@@ -454,6 +460,7 @@ func (r *RuntimeService) Update(req request.RuntimeUpdate) error {
 		Params:  req.Params,
 		CodeDir: req.CodeDir,
 		Version: req.Version,
+		Remark:  req.Remark,
 		NodeConfig: request.NodeConfig{
 			Install:      true,
 			ExposedPorts: req.ExposedPorts,
@@ -465,6 +472,7 @@ func (r *RuntimeService) Update(req request.RuntimeUpdate) error {
 	if err != nil {
 		return err
 	}
+	runtime.Remark = req.Remark
 	runtime.Env = string(envContent)
 	runtime.DockerCompose = string(composeContent)
 
@@ -682,7 +690,7 @@ func (r *RuntimeService) GetPHPExtensions(runtimeID uint) (response.PHPExtension
 		}
 	}
 	var phpExtensions []response.SupportExtension
-	if err = json.Unmarshal(nginx_conf.PHPExtensionsJson, &phpExtensions); err != nil {
+	if err = json.Unmarshal(nginx_conf.GetWebsiteFile("php_extensions.json"), &phpExtensions); err != nil {
 		return res, err
 	}
 	for _, ext := range phpExtensions {
@@ -719,25 +727,27 @@ func (r *RuntimeService) InstallPHPExtension(req request.PHPExtensionInstallReq)
 			return err
 		}
 		client, err := docker.NewClient()
+		if err != nil {
+			return err
+		}
 		defer client.Close()
-		if err == nil {
-			oldImageID, err := client.GetImageIDByName(runtime.Image)
-			if err != nil {
-				return err
-			}
-			err = cmdMgr.RunBashCf("docker commit %s %s", runtime.ContainerName, runtime.Image)
-			if err != nil {
-				return err
-			}
-			newImageID, err := client.GetImageIDByName(runtime.Image)
-			if err == nil && newImageID != oldImageID {
-				if err := client.DeleteImage(oldImageID); err != nil {
-					t.Log(fmt.Sprintf("delete old image error %v", err))
-				} else {
-					t.Log("delete old image success")
-				}
+		oldImageID, err := client.GetImageIDByName(runtime.Image)
+		if err != nil {
+			return err
+		}
+		err = cmdMgr.RunBashCf("docker commit %s %s", runtime.ContainerName, runtime.Image)
+		if err != nil {
+			return err
+		}
+		newImageID, err := client.GetImageIDByName(runtime.Image)
+		if err == nil && newImageID != oldImageID {
+			if err := client.DeleteImage(oldImageID); err != nil {
+				t.Log(fmt.Sprintf("delete old image error %v", err))
+			} else {
+				t.Log("delete old image success")
 			}
 		}
+		handlePHPDir(*runtime)
 		if err = restartRuntime(runtime); err != nil {
 			return err
 		}
@@ -887,7 +897,6 @@ func (r *RuntimeService) UpdatePHPConfig(req request.PHPConfigUpdate) (err error
 			pattern := "^" + regexp.QuoteMeta("disable_functions") + "\\s*=\\s*.*$"
 			if matched, _ := regexp.MatchString(pattern, line); matched {
 				lines[i] = "disable_functions" + " = " + strings.Join(req.DisableFunctions, ",")
-				break
 			}
 		case "upload_max_filesize":
 			pattern := "^" + regexp.QuoteMeta("post_max_size") + "\\s*=\\s*.*$"
@@ -1143,3 +1152,12 @@ func (r *RuntimeService) OperateSupervisorProcessFile(req request.PHPSupervisorP
 	logFile := path.Join(supervisorDir, "log", fmt.Sprintf("%s.out.log", req.SupervisorProcessFileReq.Name))
 	return handleSupervisorFile(req.SupervisorProcessFileReq, configDir, runtime.ContainerName, logFile)
 }
+
+func (r *RuntimeService) UpdateRemark(req request.RuntimeRemark) error {
+	runtime, err := runtimeRepo.GetFirst(context.Background(), repo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	runtime.Remark = req.Remark
+	return runtimeRepo.Save(runtime)
+}

agent/app/service/runtime_utils.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	cmd2 "github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"io"
 	"os"
 	"os/exec"
@@ -17,6 +16,8 @@ import (
 	"strings"
 	"time"
 
+	cmd2 "github.com/1Panel-dev/1Panel/agent/utils/cmd"
+
 	"github.com/1Panel-dev/1Panel/agent/i18n"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 
@@ -89,7 +90,7 @@ func handlePHP(create request.RuntimeCreate, runtime *model.Runtime, fileOp file
 	version, ok := create.Params["PHP_VERSION"]
 	if ok {
 		extensionsDir := path.Join(projectDir, "extensions", getExtensionDir(version.(string)))
-		_ = fileOp.CreateDir(extensionsDir, 0644)
+		_ = fileOp.CreateDir(extensionsDir, 0755)
 	}
 
 	composeContent, envContent, forms, err := handleParams(create, projectDir)
@@ -101,6 +102,13 @@ func handlePHP(create request.RuntimeCreate, runtime *model.Runtime, fileOp file
 	runtime.Params = string(forms)
 	runtime.Status = constant.StatusBuilding
 
+	go func() {
+		appDetail, err := appDetailRepo.GetFirst(repo.WithByID(runtime.AppDetailID))
+		if err == nil {
+			RequestDownloadCallBack(appDetail.DownloadCallBackUrl)
+		}
+	}()
+
 	go buildRuntime(runtime, "", "", false)
 	return
 }
@@ -141,11 +149,27 @@ func reCreateRuntime(runtime *model.Runtime) {
 	}
 }
 
-func runComposeCmdWithLog(operate string, composePath string, logPath string) error {
-	cmd := exec.Command("docker", "compose", "-f", composePath, operate)
-	if operate == "up" {
-		cmd = exec.Command("docker", "compose", "-f", composePath, operate, "-d")
+func getComposeCmd(composePath, operate string) *exec.Cmd {
+	dockerCommand := global.CONF.DockerConfig.Command
+	var cmd *exec.Cmd
+	if dockerCommand == "docker-compose" {
+		if operate == "up" {
+			cmd = exec.Command("docker-compose", "-f", composePath, operate, "-d")
+		} else {
+			cmd = exec.Command("docker-compose", "-f", composePath, operate)
+		}
+	} else {
+		if operate == "up" {
+			cmd = exec.Command("docker", "compose", "-f", composePath, operate, "-d")
+		} else {
+			cmd = exec.Command("docker", "compose", "-f", composePath, operate)
+		}
 	}
+	return cmd
+}
+
+func runComposeCmdWithLog(operate string, composePath string, logPath string) error {
+	cmd := getComposeCmd(composePath, operate)
 	logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, constant.FilePerm)
 	if err != nil {
 		global.LOG.Errorf("Failed to open log file: %v", err)
@@ -287,10 +311,22 @@ func buildRuntime(runtime *model.Runtime, oldImageID string, oldEnv string, rebu
 		_ = logFile.Close()
 	}()
 
+	newPHPVersion := getRuntimeEnv(runtime.Env, "PHP_VERSION")
+	oldPHPVersion := getRuntimeEnv(oldEnv, "PHP_VERSION")
+	if newPHPVersion != oldPHPVersion {
+		_ = os.Rename(path.Join(runtimePath, "extensions", getExtensionDir(oldPHPVersion)), path.Join(runtimePath, "extensions", getExtensionDir(newPHPVersion)))
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Hour)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "build")
+	dockerCommand := global.CONF.DockerConfig.Command
+	var cmd *exec.Cmd
+	if dockerCommand == "docker-compose" {
+		cmd = exec.CommandContext(ctx, "docker-compose", "-f", composePath, "build")
+	} else {
+		cmd = exec.CommandContext(ctx, "docker", "compose", "-f", composePath, "build")
+	}
 	cmd.Stdout = logFile
 	var stderrBuf bytes.Buffer
 	multiWriterStderr := io.MultiWriter(&stderrBuf, logFile)
@@ -373,6 +409,7 @@ func buildRuntime(runtime *model.Runtime, oldImageID string, oldEnv string, rebu
 	if deleteImageID != "" {
 		deleteImageByID(deleteImageID, runtime.Image, client)
 	}
+	handlePHPDir(*runtime)
 	if out, err := compose.DownAndUp(composePath); err != nil {
 		runtime.Status = constant.StatusStartErr
 		runtime.Message = out
@@ -553,7 +590,7 @@ func handleCompose(env gotenv.Env, composeContent []byte, create request.Runtime
 		serviceName = name
 		serviceValue = service.(map[string]interface{})
 		delete(serviceValue, "ports")
-		if create.ExposedPorts != nil && len(create.ExposedPorts) > 0 {
+		if len(create.ExposedPorts) > 0 {
 			var ports []interface{}
 			for i, port := range create.ExposedPorts {
 				containerPortStr := fmt.Sprintf("CONTAINER_PORT_%d", i)
@@ -567,12 +604,12 @@ func handleCompose(env gotenv.Env, composeContent []byte, create request.Runtime
 				create.Params[hostIPStr] = port.HostIP
 			}
 			if create.Type == constant.RuntimePHP {
-				ports = append(ports, fmt.Sprintf("127.0.0.1:${PANEL_APP_PORT_HTTP}:9000"))
+				ports = append(ports, "127.0.0.1:${PANEL_APP_PORT_HTTP}:9000")
 			}
 			serviceValue["ports"] = ports
 		} else {
 			if create.Type == constant.RuntimePHP {
-				serviceValue["ports"] = []interface{}{fmt.Sprintf("127.0.0.1:${PANEL_APP_PORT_HTTP}:9000")}
+				serviceValue["ports"] = []interface{}{"127.0.0.1:${PANEL_APP_PORT_HTTP}:9000"}
 			}
 		}
 		var environments []interface{}
@@ -657,7 +694,7 @@ func unInstallPHPExtension(runtime *model.Runtime, delExtensions []string) error
 	dir := runtime.GetPath()
 	fileOP := files.NewFileOp()
 	var phpExtensions []response.SupportExtension
-	if err := json.Unmarshal(nginx_conf.PHPExtensionsJson, &phpExtensions); err != nil {
+	if err := json.Unmarshal(nginx_conf.GetWebsiteFile("php_extensions.json"), &phpExtensions); err != nil {
 		return err
 	}
 	phpVersion := getRuntimeEnv(runtime.Env, "PHP_VERSION")
@@ -959,3 +996,43 @@ func handleRuntimeDTO(res *response.RuntimeDTO, runtime model.Runtime) error {
 	}
 	return nil
 }
+
+func handlePHPDir(runtime model.Runtime) {
+	fileOp := files.NewFileOp()
+	dirs := []string{
+		path.Join(runtime.GetPath(), "conf"),
+		path.Join(runtime.GetPath(), "extensions"),
+		path.Join(runtime.GetPath(), "composer"),
+		path.Join(runtime.GetPath(), "log"),
+	}
+	for _, dir := range dirs {
+		_ = fileOp.ChmodR(dir, 0755, true)
+		_ = fileOp.ChownR(dir, strconv.Itoa(1000), strconv.Itoa(1000), true)
+	}
+}
+
+func HandleOldPHPRuntime() {
+	runtimes, _ := runtimeRepo.List(repo.WithByType(constant.RuntimePHP))
+	if len(runtimes) == 0 {
+		return
+	}
+	fileOp := files.NewFileOp()
+	for _, runtime := range runtimes {
+		composePtah := runtime.GetComposePath()
+		composeBytes, _ := fileOp.GetContent(composePtah)
+		composeContent := strings.ReplaceAll(string(composeBytes), "./conf:/usr/local/etc/php", "./conf/php.ini:/usr/local/etc/php/php.ini")
+		composeContent = strings.ReplaceAll(composeContent, "./conf/php-fpm.conf:/usr/local/etc/php-fpm.d/www.conf", "./conf/php-fpm.conf:/usr/local/etc/php-fpm.conf")
+		composeContent = strings.ReplaceAll(composeContent, "./extensions:${EXTENSION_DIR}", "./extensions:/usr/local/lib/php/extensions")
+		_ = fileOp.WriteFile(composePtah, strings.NewReader(composeContent), constant.DirPerm)
+		_ = fileOp.WriteFile(runtime.GetFPMPath(), bytes.NewReader(nginx_conf.GetWebsiteFile("php-fpm.conf")), constant.DirPerm)
+		supervisorConfigPath := path.Join(runtime.GetPath(), "supervisor", "supervisor.d", "php-fpm.ini")
+		supervisorConfigBytes, _ := fileOp.GetContent(supervisorConfigPath)
+		if !strings.Contains(string(supervisorConfigBytes), "nodaemonize") {
+			newConfigContent := strings.ReplaceAll(string(supervisorConfigBytes), "command=php-fpm", "command=php-fpm --nodaemonize")
+			_ = fileOp.WriteFile(supervisorConfigPath, bytes.NewReader([]byte(newConfigContent)), constant.DirPerm)
+		}
+		go func() {
+			_ = restartRuntime(&runtime)
+		}()
+	}
+}

agent/app/service/snapshot.go

@@ -68,7 +68,7 @@ func (u *SnapshotService) SnapshotImport(req dto.SnapshotImport) error {
 	}
 
 	for _, snapName := range req.Names {
-		if !strings.HasPrefix(snapName, "1panel-v2.") && !strings.HasPrefix(snapName, "snapshot-1panel-v2.") {
+		if !checkSnapshotIsOk(snapName) {
 			return fmt.Errorf("incorrect snapshot name format of %s", snapName)
 		}
 		snap, _ := snapshotRepo.Get(repo.WithByName(strings.ReplaceAll(snapName, ".tar.gz", "")))
@@ -77,11 +77,11 @@ func (u *SnapshotService) SnapshotImport(req dto.SnapshotImport) error {
 		}
 	}
 	for _, snap := range req.Names {
-		shortName := strings.TrimPrefix(snap, "snapshot_")
-		nameItems := strings.Split(shortName, "-")
-		if !strings.HasPrefix(shortName, "1panel-v") || !strings.HasSuffix(shortName, ".tar.gz") || len(nameItems) < 3 {
-			return fmt.Errorf("incorrect snapshot name format of %s", shortName)
-		}
+		shortName := strings.ReplaceAll(snap, "snapshot-", "")
+		shortName = strings.ReplaceAll(shortName, "1panel-", "")
+		shortName = strings.ReplaceAll(shortName, "core-", "")
+		shortName = strings.ReplaceAll(shortName, "agent-", "")
+		nameItems := strings.Split(shortName, "-linux")
 		if strings.HasSuffix(snap, ".tar.gz") {
 			snap = strings.ReplaceAll(snap, ".tar.gz", "")
 		}
@@ -89,7 +89,7 @@ func (u *SnapshotService) SnapshotImport(req dto.SnapshotImport) error {
 			Name:              snap,
 			SourceAccountIDs:  fmt.Sprintf("%v", req.BackupAccountID),
 			DownloadAccountID: req.BackupAccountID,
-			Version:           nameItems[1],
+			Version:           nameItems[0],
 			Description:       req.Description,
 			Status:            constant.StatusSuccess,
 		}
@@ -110,6 +110,7 @@ func (u *SnapshotService) LoadSnapshotData() (dto.SnapshotData, error) {
 	if err != nil {
 		return data, err
 	}
+	data.WithDockerConf = true
 	data.PanelData, err = loadPanelFile(fileOp)
 	if err != nil {
 		return data, err
@@ -403,3 +404,13 @@ func loadFile(pathItem string, index int, fileOp fileUtils.FileOp) ([]dto.DataTr
 	}
 	return data, nil
 }
+
+func checkSnapshotIsOk(name string) bool {
+	names := []string{"1panel-core-v2.", "1panel-agent-v2.", "1panel-v2.", "snapshot-1panel-core-v2.", "snapshot-1panel-agent-v2."}
+	for _, item := range names {
+		if strings.HasPrefix(name, item) {
+			return true
+		}
+	}
+	return false
+}

agent/app/service/snapshot_create.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -34,7 +35,7 @@ func (u *SnapshotService) SnapshotCreate(parentTask *task.Task, req dto.Snapshot
 		scope = "agent"
 	}
 	if jobID == 0 {
-		req.Name = fmt.Sprintf("1panel-%s-%s-linux-%s-%s", versionItem.Value, scope, loadOs(), time.Now().Format(constant.DateTimeSlimLayout))
+		req.Name = fmt.Sprintf("1panel-%s-%s-linux-%s-%s", scope, versionItem.Value, loadOs(), time.Now().Format(constant.DateTimeSlimLayout))
 	}
 	appItem, _ := json.Marshal(req.AppData)
 	panelItem, _ := json.Marshal(req.PanelData)
@@ -50,14 +51,17 @@ func (u *SnapshotService) SnapshotCreate(parentTask *task.Task, req dto.Snapshot
 		AppData:          string(appItem),
 		PanelData:        string(panelItem),
 		BackupData:       string(backupItem),
+		WithDockerConf:   req.WithDockerConf,
 		WithMonitorData:  req.WithMonitorData,
 		WithLoginLog:     req.WithLoginLog,
 		WithOperationLog: req.WithOperationLog,
 		WithTaskLog:      req.WithTaskLog,
 		WithSystemLog:    req.WithSystemLog,
+		IgnoreFiles:      strings.Join(req.IgnoreFiles, ","),
 
 		Version: versionItem.Value,
 		Status:  constant.StatusWaiting,
+		Timeout: req.Timeout,
 	}
 	if err := snapshotRepo.Create(&snap); err != nil {
 		global.LOG.Errorf("create snapshot record to db failed, err: %v", err)
@@ -76,7 +80,7 @@ func (u *SnapshotService) SnapshotCreate(parentTask *task.Task, req dto.Snapshot
 	}
 	if jobID == 0 {
 		go func() {
-			_ = handleSnapshot(req, taskItem, jobID, 3, 0)
+			_ = handleSnapshot(req, taskItem, jobID, 3, snap.Timeout)
 		}()
 		return nil
 	}
@@ -106,28 +110,25 @@ func (u *SnapshotService) SnapshotReCreate(id uint) error {
 		return err
 	}
 	req.TaskID = taskModel.ID
-	taskItem, err := task.NewTaskWithOps(req.Name, task.TaskCreate, task.TaskScopeSnapshot, req.TaskID, req.ID)
+	taskItem, err := task.ReNewTaskWithOps(req.Name, task.TaskCreate, task.TaskScopeSnapshot, req.TaskID, req.ID)
 	if err != nil {
 		global.LOG.Errorf("new task for create snapshot failed, err: %v", err)
 		return err
 	}
+	_ = snapshotRepo.Update(req.ID, map[string]interface{}{"status": constant.StatusWaiting, "message": ""})
 	go func() {
-		_ = handleSnapshot(req, taskItem, 0, 0, 0)
+		_ = handleSnapshot(req, taskItem, 0, 3, 0)
 	}()
 
 	return nil
 }
 
 func handleSnapshot(req dto.SnapshotCreate, taskItem *task.Task, jobID, retry, timeout uint) error {
-	rootDir := path.Join(global.Dir.TmpDir, "system", req.Name)
+	rootDir := path.Join(global.Dir.LocalBackupDir, "tmp/system", req.Name)
 	openrestyDir, _ := settingRepo.GetValueByKey("WEBSITE_DIR")
 	itemHelper := snapHelper{SnapID: req.ID, Task: *taskItem, FileOp: files.NewFileOp(), Ctx: context.Background(), OpenrestyDir: openrestyDir}
 	baseDir := path.Join(rootDir, "base")
 	_ = os.MkdirAll(baseDir, os.ModePerm)
-
-	if timeout == 0 {
-		timeout = 1800
-	}
 	taskItem.AddSubTaskWithAliasAndOps(
 		"SnapDBInfo",
 		func(t *task.Task) error {
@@ -145,7 +146,7 @@ func handleSnapshot(req dto.SnapshotCreate, taskItem *task.Task, jobID, retry, t
 	if len(req.InterruptStep) == 0 || req.InterruptStep == "SnapBaseInfo" {
 		taskItem.AddSubTaskWithAliasAndOps(
 			"SnapBaseInfo",
-			func(t *task.Task) error { return snapBaseData(itemHelper, baseDir) },
+			func(t *task.Task) error { return snapBaseData(itemHelper, baseDir, req.WithDockerConf) },
 			nil, int(retry), time.Duration(timeout)*time.Second,
 		)
 		req.InterruptStep = ""
@@ -233,6 +234,7 @@ func loadDbConn(snap *snapHelper, targetDir string, req dto.SnapshotCreate) erro
 	if err != nil {
 		return err
 	}
+	_ = os.Remove(path.Join(targetDir, "db/session.db"))
 
 	agentDb, err := common.LoadDBConnByPathWithErr(path.Join(targetDir, "db/agent.db"), "agent.db")
 	snap.Task.LogWithStatus(i18n.GetWithName("SnapNewDB", "agent"), err)
@@ -284,7 +286,7 @@ func loadDbConn(snap *snapHelper, targetDir string, req dto.SnapshotCreate) erro
 	return nil
 }
 
-func snapBaseData(snap snapHelper, targetDir string) error {
+func snapBaseData(snap snapHelper, targetDir string, withDockerConf bool) error {
 	snap.Task.Log("---------------------- 2 / 8 ----------------------")
 	snap.Task.LogStart(i18n.GetMsgByKey("SnapBaseInfo"))
 
@@ -321,11 +323,13 @@ func snapBaseData(snap snapHelper, targetDir string) error {
 		return err
 	}
 
-	if snap.FileOp.Stat("/etc/docker/daemon.json") {
-		err = snap.FileOp.CopyFile("/etc/docker/daemon.json", targetDir)
-		snap.Task.LogWithStatus(i18n.GetWithName("SnapCopy", "/etc/docker/daemon.json"), err)
-		if err != nil {
-			return err
+	if withDockerConf {
+		if snap.FileOp.Stat(constant.DaemonJsonPath) {
+			err = snap.FileOp.CopyFile(constant.DaemonJsonPath, targetDir)
+			snap.Task.LogWithStatus(i18n.GetWithName("SnapCopy", constant.DaemonJsonPath), err)
+			if err != nil {
+				return err
+			}
 		}
 	}
 
@@ -377,8 +381,8 @@ func snapAppImage(snap snapHelper, req dto.SnapshotCreate, targetDir string) err
 		}
 	}
 
-	snap.Task.Log(strings.Join(imageList, " "))
 	if len(imageList) != 0 {
+		snap.Task.Log(strings.Join(imageList, " "))
 		snap.Task.Logf("docker save %s | gzip -c > %s", strings.Join(imageList, " "), path.Join(targetDir, "images.tar.gz"))
 		std, err := cmd.NewCommandMgr(cmd.WithTimeout(10*time.Minute)).RunWithStdoutBashCf("docker save %s | gzip -c > %s", strings.Join(imageList, " "), path.Join(targetDir, "images.tar.gz"))
 		if err != nil {
@@ -386,6 +390,8 @@ func snapAppImage(snap snapHelper, req dto.SnapshotCreate, targetDir string) err
 			return errors.New(std)
 		}
 		snap.Task.LogSuccess(i18n.GetMsgByKey("SnapDockerSave"))
+	} else {
+		snap.Task.Log(i18n.GetMsgByKey("SnapInstallAppImageEmpty"))
 	}
 	return nil
 }
@@ -395,7 +401,9 @@ func snapBackupData(snap snapHelper, req dto.SnapshotCreate, targetDir string) e
 	snap.Task.LogStart(i18n.GetMsgByKey("SnapLocalBackup"))
 
 	excludes := loadBackupExcludes(snap, req.BackupData)
+	excludes = append(excludes, req.IgnoreFiles...)
 	excludes = append(excludes, "./system_snapshot")
+	excludes = append(excludes, "./tmp")
 	for _, item := range req.AppData {
 		for _, itemApp := range item.Children {
 			if itemApp.Label == "appBackup" {
@@ -418,7 +426,8 @@ func loadBackupExcludes(snap snapHelper, req []dto.DataTree) []string {
 			if err := snap.snapAgentDB.Where("file_dir = ? AND file_name = ?", strings.TrimPrefix(path.Dir(item.Path), global.Dir.LocalBackupDir+"/"), path.Base(item.Path)).Delete(&model.BackupRecord{}).Error; err != nil {
 				snap.Task.LogWithStatus("delete backup file from database", err)
 			}
-			excludes = append(excludes, "."+strings.TrimPrefix(item.Path, global.Dir.LocalBackupDir))
+			itemDir, _ := filepath.Rel(item.Path, global.Dir.LocalBackupDir)
+			excludes = append(excludes, itemDir)
 		} else {
 			excludes = append(excludes, loadBackupExcludes(snap, item.Children)...)
 		}
@@ -430,7 +439,8 @@ func loadAppBackupExcludes(req []dto.DataTree) []string {
 	for _, item := range req {
 		if len(item.Children) == 0 {
 			if !item.IsCheck {
-				excludes = append(excludes, "."+strings.TrimPrefix(item.Path, path.Join(global.Dir.LocalBackupDir)))
+				itemDir, _ := filepath.Rel(item.Path, global.Dir.LocalBackupDir)
+				excludes = append(excludes, itemDir)
 			}
 		} else {
 			excludes = append(excludes, loadAppBackupExcludes(item.Children)...)
@@ -463,26 +473,21 @@ func snapPanelData(snap snapHelper, req dto.SnapshotCreate, targetDir string) er
 
 	rootDir := global.Dir.DataDir
 	if strings.Contains(global.Dir.LocalBackupDir, rootDir) {
-		excludes = append(excludes, "."+strings.ReplaceAll(global.Dir.LocalBackupDir, rootDir, ""))
+		itemDir, _ := filepath.Rel(rootDir, global.Dir.LocalBackupDir)
+		excludes = append(excludes, itemDir)
 	}
 	if len(snap.OpenrestyDir) != 0 && strings.Contains(snap.OpenrestyDir, rootDir) {
-		excludes = append(excludes, "."+strings.ReplaceAll(snap.OpenrestyDir, rootDir, ""))
-	}
-	ignoreVal, _ := settingRepo.Get(settingRepo.WithByKey("SnapshotIgnore"))
-	rules := strings.Split(ignoreVal.Value, ",")
-	for _, ignore := range rules {
-		if len(ignore) == 0 || cmd.CheckIllegal(ignore) {
-			continue
-		}
-		excludes = append(excludes, "."+strings.ReplaceAll(ignore, rootDir, ""))
+		itemDir, _ := filepath.Rel(rootDir, snap.OpenrestyDir)
+		excludes = append(excludes, itemDir)
 	}
+	excludes = append(excludes, req.IgnoreFiles...)
 	err := snap.FileOp.TarGzCompressPro(false, rootDir, path.Join(targetDir, "1panel_data.tar.gz"), "", strings.Join(excludes, ","))
 	snap.Task.LogWithStatus(i18n.GetMsgByKey("SnapCompressPanel"), err)
 	if err != nil {
 		return err
 	}
 	if len(snap.OpenrestyDir) != 0 {
-		err := snap.FileOp.TarGzCompressPro(false, snap.OpenrestyDir, path.Join(targetDir, "website.tar.gz"), "", "")
+		err := snap.FileOp.TarGzCompressPro(false, snap.OpenrestyDir, path.Join(targetDir, "website.tar.gz"), "", strings.Join(req.IgnoreFiles, ","))
 		snap.Task.LogWithStatus(i18n.GetMsgByKey("SnapWebsite"), err)
 		if err != nil {
 			return err
@@ -496,7 +501,8 @@ func loadPanelExcludes(req []dto.DataTree) []string {
 	for _, item := range req {
 		if len(item.Children) == 0 {
 			if !item.IsCheck {
-				excludes = append(excludes, "."+strings.TrimPrefix(item.Path, path.Join(global.Dir.BaseDir, "1panel")))
+				itemDir, _ := filepath.Rel(item.Path, path.Join(global.Dir.BaseDir, "1panel"))
+				excludes = append(excludes, itemDir)
 			}
 		} else {
 			excludes = append(excludes, loadPanelExcludes(item.Children)...)
@@ -509,7 +515,7 @@ func snapCompress(snap snapHelper, rootDir string, secret string) error {
 	snap.Task.Log("---------------------- 7 / 8 ----------------------")
 	snap.Task.LogStart(i18n.GetMsgByKey("SnapCompress"))
 
-	tmpDir := path.Join(global.Dir.TmpDir, "system")
+	tmpDir := path.Join(global.Dir.LocalBackupDir, "tmp/system")
 	fileName := fmt.Sprintf("%s.tar.gz", path.Base(rootDir))
 	err := snap.FileOp.TarGzCompressPro(true, rootDir, path.Join(tmpDir, fileName), secret, "")
 	snap.Task.LogWithStatus(i18n.GetMsgByKey("SnapCompressFile"), err)
@@ -533,7 +539,7 @@ func snapUpload(snap snapHelper, accounts string, file string) error {
 	snap.Task.Log("---------------------- 8 / 8 ----------------------")
 	snap.Task.LogStart(i18n.GetMsgByKey("SnapUpload"))
 
-	source := path.Join(global.Dir.TmpDir, "system", path.Base(file))
+	source := path.Join(global.Dir.LocalBackupDir, "tmp/system", path.Base(file))
 	accountMap, err := NewBackupClientMap(strings.Split(accounts, ","))
 	snap.Task.LogWithStatus(i18n.GetMsgByKey("SnapLoadBackup"), err)
 	if err != nil {

agent/app/service/snapshot_recover.go

@@ -38,6 +38,18 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"recover_status": constant.StatusFailed, "recover_message": errInfo})
 		return errors.New(errInfo)
 	}
+	if !strings.Contains(snap.Name, "-v2.") {
+		return errors.New("snapshots are currently not supported for recovery across major versions")
+	}
+	if !strings.Contains(snap.Name, "-core") && !strings.Contains(snap.Name, "-agent") {
+		return errors.New("the name of the snapshot file does not conform to the format")
+	}
+	if strings.Contains(snap.Name, "-core") && !global.IsMaster {
+		return errors.New("the snapshot of the master node cannot be restored on the agent nodes")
+	}
+	if strings.Contains(snap.Name, "-agent") && global.IsMaster {
+		return errors.New("the snapshot of the agent node cannot be restored on the master node")
+	}
 	if len(snap.RollbackStatus) != 0 && snap.RollbackStatus != constant.StatusSuccess {
 		req.IsNew = true
 	}
@@ -55,12 +67,18 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 	} else {
 		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"task_recover_id": req.TaskID})
 	}
-	taskItem, err := task.NewTaskWithOps(snap.Name, task.TaskRecover, task.TaskScopeSnapshot, req.TaskID, snap.ID)
+
+	var taskItem *task.Task
+	if req.IsNew {
+		taskItem, err = task.NewTaskWithOps(snap.Name, task.TaskRecover, task.TaskScopeSnapshot, req.TaskID, snap.ID)
+	} else {
+		taskItem, err = task.ReNewTaskWithOps(snap.Name, task.TaskRecover, task.TaskScopeSnapshot, req.TaskID, snap.ID)
+	}
 	if err != nil {
 		global.LOG.Errorf("new task for create snapshot failed, err: %v", err)
 		return err
 	}
-	rootDir := path.Join(global.Dir.TmpDir, "system", snap.Name)
+	rootDir := path.Join(global.Dir.LocalBackupDir, "tmp/system", snap.Name)
 	if _, err := os.Stat(rootDir); err != nil && os.IsNotExist(err) {
 		_ = os.MkdirAll(rootDir, os.ModePerm)
 	}
@@ -84,7 +102,7 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 			taskItem.AddSubTaskWithAlias(
 				"RecoverDecompress",
 				func(t *task.Task) error {
-					itemHelper.Task.Log("---------------------- 2 / 10 ----------------------")
+					itemHelper.Task.Log("---------------------- 2 / 11 ----------------------")
 					itemHelper.Task.LogStart(i18n.GetWithName("RecoverDecompress", snap.Name))
 					err := itemHelper.FileOp.TarGzExtractPro(fmt.Sprintf("%s/%s.tar.gz", rootDir, snap.Name), rootDir, req.Secret)
 					itemHelper.Task.LogWithStatus(i18n.GetMsgByKey("Decompress"), err)
@@ -140,7 +158,7 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 			taskItem.AddSubTaskWithAlias(
 				"RecoverBackups",
 				func(t *task.Task) error {
-					itemHelper.Task.Log("---------------------- 8 / 10 ----------------------")
+					itemHelper.Task.Log("---------------------- 8 / 11 ----------------------")
 					itemHelper.Task.LogStart(i18n.GetWithName("RecoverBackups", snap.Name))
 					err := itemHelper.FileOp.TarGzExtractPro(path.Join(rootDir, snap.Name, "/1panel_backup.tar.gz"), snapJson.BackupDataDir, "")
 					itemHelper.Task.LogWithStatus(i18n.GetMsgByKey("Decompress"), err)
@@ -150,11 +168,30 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 			)
 			req.IsNew = true
 		}
+		if req.IsNew || snap.InterruptStep == "RecoverWebsite" {
+			taskItem.AddSubTaskWithAlias(
+				"RecoverWebsite",
+				func(t *task.Task) error {
+					itemHelper.Task.Log("---------------------- 9 / 11 ----------------------")
+					itemHelper.Task.LogStart(i18n.GetWithName("RecoverWebsite", snap.Name))
+					webFile := path.Join(rootDir, snap.Name, "/website.tar.gz")
+					_ = itemHelper.FileOp.CreateDir(snapJson.OperestyDir, os.ModePerm)
+					var err error
+					if itemHelper.FileOp.Stat(webFile) {
+						err = itemHelper.FileOp.TarGzExtractPro(webFile, snapJson.OperestyDir, "")
+					}
+					itemHelper.Task.LogWithStatus(i18n.GetMsgByKey("Decompress"), err)
+					return err
+				},
+				nil,
+			)
+			req.IsNew = true
+		}
 		if req.IsNew || snap.InterruptStep == "RecoverPanelData" {
 			taskItem.AddSubTaskWithAlias(
 				"RecoverPanelData",
 				func(t *task.Task) error {
-					itemHelper.Task.Log("---------------------- 9 / 10 ----------------------")
+					itemHelper.Task.Log("---------------------- 10 / 11 ----------------------")
 					itemHelper.Task.LogStart(i18n.GetWithName("RecoverPanelData", snap.Name))
 					err := itemHelper.FileOp.TarGzExtractPro(path.Join(rootDir, snap.Name, "/1panel_data.tar.gz"), path.Join(snapJson.BaseDir, "1panel"), "")
 					itemHelper.Task.LogWithStatus(i18n.GetMsgByKey("Decompress"), err)
@@ -195,7 +232,7 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 }
 
 func handleDownloadSnapshot(itemHelper *snapRecoverHelper, snap model.Snapshot, targetDir string) error {
-	itemHelper.Task.Log("---------------------- 1 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 1 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("RecoverDownload"))
 
 	account, client, err := NewBackupClientWithID(snap.DownloadAccountID)
@@ -214,7 +251,7 @@ func handleDownloadSnapshot(itemHelper *snapRecoverHelper, snap model.Snapshot,
 }
 
 func backupBeforeRecover(name string, itemHelper *snapRecoverHelper) error {
-	itemHelper.Task.Log("---------------------- 3 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 3 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("BackupBeforeRecover"))
 
 	rootDir := fmt.Sprintf("%s/1panel_original/original_%s", global.Dir.BaseDir, name)
@@ -273,9 +310,9 @@ func backupBeforeRecover(name string, itemHelper *snapRecoverHelper) error {
 	if err != nil {
 		return err
 	}
-	if itemHelper.FileOp.Stat("/etc/docker/daemon.json") {
-		err = itemHelper.FileOp.CopyFile("/etc/docker/daemon.json", baseDir)
-		itemHelper.Task.LogWithStatus(i18n.GetWithName("SnapCopy", "/etc/docker/daemon.json"), err)
+	if itemHelper.FileOp.Stat(constant.DaemonJsonPath) {
+		err = itemHelper.FileOp.CopyFile(constant.DaemonJsonPath, baseDir)
+		itemHelper.Task.LogWithStatus(i18n.GetWithName("SnapCopy", constant.DaemonJsonPath), err)
 		if err != nil {
 			return err
 		}
@@ -284,7 +321,7 @@ func backupBeforeRecover(name string, itemHelper *snapRecoverHelper) error {
 }
 
 func readFromJson(rootDir string, itemHelper *snapRecoverHelper) (SnapshotJson, error) {
-	itemHelper.Task.Log("---------------------- 4 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 4 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("Readjson"))
 
 	snapJsonPath := path.Join(rootDir, "base/snapshot.json")
@@ -308,7 +345,7 @@ func readFromJson(rootDir string, itemHelper *snapRecoverHelper) (SnapshotJson,
 }
 
 func recoverAppData(src string, itemHelper *snapRecoverHelper) error {
-	itemHelper.Task.Log("---------------------- 5 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 5 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("RecoverApp"))
 
 	if _, err := os.Stat(path.Join(src, "images.tar.gz")); err != nil {
@@ -325,7 +362,7 @@ func recoverAppData(src string, itemHelper *snapRecoverHelper) error {
 }
 
 func recoverBaseData(src string, itemHelper *snapRecoverHelper) error {
-	itemHelper.Task.Log("---------------------- 6 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 6 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("SnapBaseInfo"))
 
 	if global.IsMaster {
@@ -356,27 +393,25 @@ func recoverBaseData(src string, itemHelper *snapRecoverHelper) error {
 		return err
 	}
 
-	daemonJsonPath := "/etc/docker/daemon.json"
-	_, errSrc := os.Stat(path.Join(src, "docker/daemon.json"))
-	_, errPath := os.Stat(daemonJsonPath)
-	if os.IsNotExist(errSrc) && os.IsNotExist(errPath) {
+	if !itemHelper.FileOp.Stat(path.Join(src, "daemon.json")) {
 		itemHelper.Task.Log(i18n.GetMsgByKey("RecoverDaemonJsonEmpty"))
 		return nil
-	}
-	if errSrc == nil {
-		err = itemHelper.FileOp.CopyFile(path.Join(src, "docker/daemon.json"), "/etc/docker")
+	} else {
+		err = itemHelper.FileOp.CopyFile(path.Join(src, "daemon.json"), path.Dir(constant.DaemonJsonPath))
 		itemHelper.Task.Log(i18n.GetMsgByKey("RecoverDaemonJson"))
 		if err != nil {
 			return fmt.Errorf("recover docker daemon.json failed, err: %v", err)
 		}
 	}
 
-	_, _ = cmd.RunDefaultWithStdoutBashC("systemctl restart docker")
+	if err := restartDocker(); err != nil {
+		return err
+	}
 	return nil
 }
 
 func recoverDBData(src string, itemHelper *snapRecoverHelper) error {
-	itemHelper.Task.Log("---------------------- 7 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 7 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("RecoverDBData"))
 	err := itemHelper.FileOp.CopyDirWithExclude(src, global.Dir.DataDir, nil)
 
@@ -385,7 +420,7 @@ func recoverDBData(src string, itemHelper *snapRecoverHelper) error {
 }
 
 func restartCompose(composePath string, itemHelper *snapRecoverHelper) error {
-	itemHelper.Task.Log("---------------------- 10 / 10 ----------------------")
+	itemHelper.Task.Log("---------------------- 11 / 11 ----------------------")
 	itemHelper.Task.LogStart(i18n.GetMsgByKey("RecoverCompose"))
 
 	composes, err := composeRepo.ListRecord()

agent/app/service/snapshot_rollback.go

@@ -76,9 +76,12 @@ func (u *SnapshotService) SnapshotRollback(req dto.SnapshotRecover) error {
 			nil,
 		)
 		taskItem.AddSubTask(
-			i18n.GetWithName("SnapCopy", "/etc/docker/daemon.json"),
+			i18n.GetWithName("SnapCopy", constant.DaemonJsonPath),
 			func(t *task.Task) error {
-				return FileOp.CopyFile(path.Join(baseDir, "daemon.json"), "/etc/docker")
+				if FileOp.Stat(path.Join(baseDir, "daemon.json")) {
+					return FileOp.CopyFile(path.Join(baseDir, "daemon.json"), path.Dir(constant.DaemonJsonPath))
+				}
+				return nil
 			},
 			nil,
 		)

agent/app/service/website.go

@@ -415,6 +415,7 @@ func (w WebsiteService) CreateWebsite(create request.WebsiteCreate) (err error)
 			return err
 		}
 		website.ParentWebsiteID = parentWebsite.ID
+		website.SiteDir = create.SiteDir
 	}
 
 	configNginx := func(t *task.Task) error {
@@ -922,18 +923,12 @@ func (w WebsiteService) GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS,
 		res        response.WebsiteHTTPS
 		httpsPorts []string
 	)
-	websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(websiteId))
-	for _, domain := range websiteDomains {
-		if domain.SSL {
-			httpsPorts = append(httpsPorts, strconv.Itoa(domain.Port))
-		}
-	}
-	if len(httpsPorts) == 0 {
-		nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
-		res.HttpsPort = strconv.Itoa(nginxInstall.HttpsPort)
-	} else {
-		res.HttpsPort = strings.Join(httpsPorts, ",")
+
+	httpsPortsMap := getHttpsPort(websiteId)
+	for port := range httpsPortsMap {
+		httpsPorts = append(httpsPorts, strconv.Itoa(port))
 	}
+	res.HttpsPort = strings.Join(httpsPorts, ",")
 	if website.WebsiteSSLID == 0 {
 		res.Enable = false
 		return res, nil
@@ -981,11 +976,7 @@ func (w WebsiteService) OpWebsiteHTTPS(ctx context.Context, req request.WebsiteH
 		res        response.WebsiteHTTPS
 		websiteSSL model.WebsiteSSL
 	)
-	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
-	if err != nil {
-		return nil, err
-	}
-	if err = ChangeHSTSConfig(req.Hsts, website); err != nil {
+	if err = ChangeHSTSConfig(req.Hsts, req.Http3, website); err != nil {
 		return nil, err
 	}
 	res.Enable = req.Enable
@@ -995,24 +986,27 @@ func (w WebsiteService) OpWebsiteHTTPS(ctx context.Context, req request.WebsiteH
 		website.Protocol = constant.ProtocolHTTP
 		website.WebsiteSSLID = 0
 
-		httpsPorts, err := getHttpsPort(&website)
+		websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(website.ID))
+
+		ports := make(map[int]struct{})
+		for _, domain := range websiteDomains {
+			ports[domain.Port] = struct{}{}
+		}
+		for port := range ports {
+			if err = removeSSLListen(website, []string{strconv.Itoa(port)}); err != nil {
+				return nil, err
+			}
+		}
+		nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
 		if err != nil {
 			return nil, err
 		}
-		if len(httpsPorts) == 1 && httpsPorts[0] == nginxInstall.HttpsPort {
-			httpsPortStr := strconv.Itoa(httpsPorts[0])
+		if _, ok := ports[nginxInstall.HttpsPort]; !ok {
+			httpsPortStr := strconv.Itoa(nginxInstall.HttpsPort)
 			if err = deleteListenAndServerName(website, []string{httpsPortStr, "[::]:" + httpsPortStr}, []string{}); err != nil {
 				return nil, err
 			}
-		} else {
-			for _, port := range httpsPorts {
-				httpsPortStr := strconv.Itoa(port)
-				if err = removeSSLListen(website, []string{httpsPortStr}); err != nil {
-					return nil, err
-				}
-			}
 		}
-
 		nginxParams := getNginxParamsFromStaticFile(dto.SSL, nil)
 		nginxParams = append(nginxParams,
 			dto.NginxParam{

agent/app/service/website_ca.go

@@ -436,14 +436,14 @@ func (w WebsiteCAService) DownloadFile(id uint) (*os.File, error) {
 	if err = fileOp.CreateDir(dir, constant.DirPerm); err != nil {
 		return nil, err
 	}
-	if err = fileOp.WriteFile(path.Join(dir, "ca.csr"), strings.NewReader(ca.CSR), constant.DirPerm); err != nil {
+	if err = fileOp.WriteFile(path.Join(dir, "ca.crt"), strings.NewReader(ca.CSR), constant.DirPerm); err != nil {
 		return nil, err
 	}
-	if err = fileOp.WriteFile(path.Join(dir, "private.key"), strings.NewReader(ca.PrivateKey), constant.DirPerm); err != nil {
+	if err = fileOp.WriteFile(path.Join(dir, "ca.key"), strings.NewReader(ca.PrivateKey), constant.DirPerm); err != nil {
 		return nil, err
 	}
 	fileName := ca.Name + ".zip"
-	if err = fileOp.Compress([]string{path.Join(dir, "ca.csr"), path.Join(dir, "private.key")}, dir, fileName, files.SdkZip, ""); err != nil {
+	if err = fileOp.Compress([]string{path.Join(dir, "ca.crt"), path.Join(dir, "ca.key")}, dir, fileName, files.SdkZip, ""); err != nil {
 		return nil, err
 	}
 	return os.Open(path.Join(dir, fileName))

agent/app/service/website_ssl.go

@@ -524,7 +524,7 @@ func (w WebsiteSSLService) Update(update request.WebsiteSSLUpdate) error {
 	if update.OtherDomains != "" {
 		otherDomainArray := strings.Split(update.OtherDomains, "\n")
 		for _, domain := range otherDomainArray {
-			if !common.IsValidDomain(domain) {
+			if websiteSSL.Provider != constant.SelfSigned && !common.IsValidDomain(domain) {
 				return buserr.WithName("ErrDomainFormat", domain)
 			}
 			domains = append(domains, domain)

agent/app/service/website_utils.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"log"
+	"net"
 	"os"
 	"path"
 	"path/filepath"
@@ -182,8 +183,8 @@ func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain, a
 		return err
 	}
 	configPath := GetSitePath(*website, SiteConf)
-	nginxContent := string(nginx_conf.WebsiteDefault)
-	config, err := parser.NewStringParser(nginxContent).Parse()
+	nginxContent := nginx_conf.GetWebsiteFile("website_default.conf")
+	config, err := parser.NewStringParser(string(nginxContent)).Parse()
 	if err != nil {
 		return err
 	}
@@ -651,22 +652,33 @@ func createPemFile(website model.Website, websiteSSL model.WebsiteSSL) error {
 	return nil
 }
 
-func getHttpsPort(website *model.Website) ([]int, error) {
-	websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(website.ID))
-	var httpsPorts []int
-	for _, domain := range websiteDomains {
-		if domain.SSL {
-			httpsPorts = append(httpsPorts, domain.Port)
+func getHttpsPort(websiteID uint) map[int]struct{} {
+	domains, err := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(websiteID))
+	if err != nil {
+		return nil
+	}
+	httpsPorts := make(map[int]struct{})
+	nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+	hasDefaultPort := false
+	for _, domain := range domains {
+		if domain.Port == nginxInstall.HttpPort {
+			hasDefaultPort = true
 		}
+		if domain.SSL {
+			httpsPorts[domain.Port] = struct{}{}
+		}
+	}
+	if hasDefaultPort {
+		httpsPorts[nginxInstall.HttpsPort] = struct{}{}
 	}
 	if len(httpsPorts) == 0 {
-		nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
-		if err != nil {
-			return nil, err
+		for _, domain := range domains {
+			if !domain.SSL {
+				httpsPorts[domain.Port] = struct{}{}
+			}
 		}
-		httpsPorts = append(httpsPorts, nginxInstall.HttpsPort)
 	}
-	return httpsPorts, nil
+	return httpsPorts
 }
 
 func applySSL(website *model.Website, websiteSSL model.WebsiteSSL, req request.WebsiteHTTPSOp) error {
@@ -678,63 +690,71 @@ func applySSL(website *model.Website, websiteSSL model.WebsiteSSL, req request.W
 	if err != nil {
 		return nil
 	}
-	noDefaultPort := true
 	httpPorts := make(map[int]struct{})
+	httpsPorts := make(map[int]struct{})
+
+	hasDefaultPort := false
 	for _, domain := range domains {
-		if domain.Port == 80 {
-			noDefaultPort = false
+		if domain.Port == nginxFull.Install.HttpPort {
+			hasDefaultPort = true
 		}
-		if domain.Port != 80 && !domain.SSL {
+		if domain.SSL {
+			httpsPorts[domain.Port] = struct{}{}
+		} else {
 			httpPorts[domain.Port] = struct{}{}
 		}
 	}
+	if hasDefaultPort {
+		httpsPorts[nginxFull.Install.HttpsPort] = struct{}{}
+	}
+	if len(httpsPorts) == 0 {
+		for port := range httpPorts {
+			httpsPorts[port] = struct{}{}
+		}
+	}
 	config := nginxFull.SiteConfig.Config
 	server := config.FindServers()[0]
 
-	httpPort := strconv.Itoa(nginxFull.Install.HttpPort)
-	httpsPort, err := getHttpsPort(website)
-	if err != nil {
-		return err
-	}
-	httpPortIPV6 := "[::]:" + httpPort
+	defaultHttpPort := strconv.Itoa(nginxFull.Install.HttpPort)
+	defaultHttpPortIPV6 := "[::]:" + defaultHttpPort
 
-	for _, port := range httpsPort {
-		if _, ok := httpPorts[port]; !ok {
-			server.DeleteListen(strconv.Itoa(port))
-		}
-		setListen(server, strconv.Itoa(port), website.IPV6, req.Http3, website.DefaultServer, true)
+	for port := range httpsPorts {
+		portStr := strconv.Itoa(port)
+		server.RemoveListenByBind(portStr)
+		server.RemoveListenByBind("[::]:" + portStr)
+		setListen(server, portStr, website.IPV6, req.Http3, website.DefaultServer, true)
 	}
 
 	server.UpdateDirective("http2", []string{"on"})
 
 	switch req.HttpConfig {
 	case constant.HTTPSOnly:
-		server.RemoveListenByBind(httpPort)
-		server.RemoveListenByBind(httpPortIPV6)
+		server.RemoveListenByBind(defaultHttpPort)
+		server.RemoveListenByBind(defaultHttpPortIPV6)
 		server.RemoveDirective("if", []string{"($scheme"})
 	case constant.HTTPToHTTPS:
-		if !noDefaultPort {
-			server.UpdateListen(httpPort, website.DefaultServer)
-		}
-		if website.IPV6 {
-			server.UpdateListen(httpPortIPV6, website.DefaultServer)
+		if hasDefaultPort {
+			server.UpdateListen(defaultHttpPort, website.DefaultServer)
+			if website.IPV6 {
+				server.UpdateListen(defaultHttpPortIPV6, website.DefaultServer)
+			}
 		}
 		server.AddHTTP2HTTPS()
 	case constant.HTTPAlso:
-		if !noDefaultPort {
-			server.UpdateListen(httpPort, website.DefaultServer)
+		if hasDefaultPort {
+			server.UpdateListen(defaultHttpPort, website.DefaultServer)
+			if website.IPV6 {
+				server.UpdateListen(defaultHttpPortIPV6, website.DefaultServer)
+			}
 		}
 		server.RemoveDirective("if", []string{"($scheme"})
-		if website.IPV6 {
-			server.UpdateListen(httpPortIPV6, website.DefaultServer)
-		}
 	}
 
 	if !req.Hsts {
 		server.RemoveDirective("add_header", []string{"Strict-Transport-Security", "\"max-age=31536000\""})
 	}
 	if !req.Http3 {
-		for _, port := range httpsPort {
+		for port := range httpsPorts {
 			server.RemoveListen(strconv.Itoa(port), "quic")
 			if website.IPV6 {
 				httpsPortIPV6 := "[::]:" + strconv.Itoa(port)
@@ -1078,7 +1098,7 @@ func getWebsiteDomains(domains []request.WebsiteDomain, defaultPort int, website
 				err = buserr.WithMap("ErrPortExist", errMap, nil)
 				return
 			}
-			if common.ScanPort(port) {
+			if port != 443 && common.ScanPort(port) {
 				err = buserr.WithDetail("ErrPortInUsed", port, nil)
 				return
 			}
@@ -1117,7 +1137,6 @@ func saveCertificateFile(websiteSSL *model.WebsiteSSL, logger *log.Logger) {
 func GetSystemSSL() (bool, uint) {
 	sslSetting, err := settingRepo.Get(settingRepo.WithByKey("SSL"))
 	if err != nil {
-		global.LOG.Errorf("load service ssl from setting failed, err: %v", err)
 		return false, 0
 	}
 	if sslSetting.Value == "enable" {
@@ -1162,7 +1181,7 @@ func UpdateSSLConfig(websiteSSL model.WebsiteSSL) error {
 	return nil
 }
 
-func ChangeHSTSConfig(enable bool, website model.Website) error {
+func ChangeHSTSConfig(enable bool, http3Enable bool, website model.Website) error {
 	includeDir := GetSitePath(website, SiteProxyDir)
 	fileOp := files.NewFileOp()
 	if !fileOp.Stat(includeDir) {
@@ -1193,6 +1212,11 @@ func ChangeHSTSConfig(enable bool, website model.Website) error {
 				} else {
 					location.RemoveDirective("add_header", []string{"Strict-Transport-Security", "\"max-age=31536000\""})
 				}
+				if http3Enable {
+					location.UpdateDirective("add_header", []string{"Alt-Svc", "'h3=\":443\"; ma=2592000'"})
+				} else {
+					location.RemoveDirective("add_header", []string{"Alt-Svc", "'h3=\":443\"; ma=2592000'"})
+				}
 				if err = nginx.WriteConfig(config, nginx.IndentedStyle); err != nil {
 					return buserr.WithErr("ErrUpdateBuWebsite", err)
 				}
@@ -1420,3 +1444,22 @@ func hasDefaultServer(params []string) bool {
 	}
 	return false
 }
+
+func ParseDomain(domain string) (*model.WebsiteDomain, error) {
+	host, portStr, err := net.SplitHostPort(domain)
+	if err != nil {
+		return &model.WebsiteDomain{
+			Domain: domain,
+			Port:   0,
+		}, nil
+	}
+
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid port in domain %s: %v", domain, err)
+	}
+	return &model.WebsiteDomain{
+		Domain: host,
+		Port:   port,
+	}, nil
+}

agent/app/task/task.go

@@ -63,6 +63,7 @@ const (
 	TaskSync      = "TaskSync"
 	TaskBuild     = "TaskBuild"
 	TaskPull      = "TaskPull"
+	TaskCommit    = "TaskCommit"
 	TaskPush      = "TaskPush"
 	TaskHandle    = "TaskHandle"
 )
@@ -142,6 +143,40 @@ func NewTask(name, operate, taskScope, taskID string, resourceID uint) (*Task, e
 	return task, nil
 }
 
+func ReNewTaskWithOps(resourceName, operate, scope, taskID string, resourceID uint) (*Task, error) {
+	return ReNewTask(GetTaskName(resourceName, operate, scope), operate, scope, taskID, resourceID)
+}
+func ReNewTask(name, operate, taskScope, taskID string, resourceID uint) (*Task, error) {
+	if taskID == "" {
+		return NewTask(name, operate, taskScope, taskID, resourceID)
+	}
+	logDir := path.Join(global.Dir.TaskDir, taskScope)
+	if _, err := os.Stat(logDir); err != nil {
+		if err = os.MkdirAll(logDir, constant.DirPerm); err != nil {
+			return nil, fmt.Errorf("failed to create log directory: %w", err)
+		}
+	}
+	logPath := path.Join(global.Dir.TaskDir, taskScope, taskID+".log")
+	file, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, constant.FilePerm)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open log file: %w", err)
+	}
+	writer := bufio.NewWriter(file)
+	logger := log.New(file, "", log.LstdFlags)
+	taskModel := &model.Task{
+		ID:         taskID,
+		Name:       name,
+		Type:       taskScope,
+		LogFile:    logPath,
+		Status:     constant.StatusExecuting,
+		ResourceID: resourceID,
+		Operate:    operate,
+	}
+	taskRepo := repo.NewITaskRepo()
+	task := &Task{Name: name, logFile: file, Logger: logger, taskRepo: taskRepo, Task: taskModel, Writer: writer}
+	return task, nil
+}
+
 func (t *Task) AddSubTask(name string, action ActionFunc, rollback RollbackFunc) {
 	subTask := &SubTask{RootTask: t, Name: name, Retry: 0, Timeout: 30 * time.Minute, Action: action, Rollback: rollback}
 	t.SubTasks = append(t.SubTasks, subTask)
@@ -158,7 +193,7 @@ func (t *Task) AddSubTaskWithOps(name string, action ActionFunc, rollback Rollba
 }
 
 func (t *Task) AddSubTaskWithAliasAndOps(key string, action ActionFunc, rollback RollbackFunc, retry int, timeout time.Duration) {
-	subTask := &SubTask{RootTask: t, Name: i18n.GetMsgByKey(key), Retry: retry, Timeout: timeout, Action: action, Rollback: rollback}
+	subTask := &SubTask{RootTask: t, Name: i18n.GetMsgByKey(key), StepAlias: key, Retry: retry, Timeout: timeout, Action: action, Rollback: rollback}
 	t.SubTasks = append(t.SubTasks, subTask)
 }
 

agent/cmd/server/cmd/debug.go

@@ -0,0 +1,169 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	cpuProfile    string
+	memProfile    string
+	duration      time.Duration
+	showMemStats  bool
+	showGoroutine bool
+)
+
+func init() {
+	RootCmd.AddCommand(debugCmd)
+
+	debugCmd.Flags().StringVar(&cpuProfile, "cpuprofile", "", "write cpu profile to file")
+	debugCmd.Flags().StringVar(&memProfile, "memprofile", "", "write memory profile to file")
+	debugCmd.Flags().DurationVar(&duration, "duration", 30*time.Second, "duration for cpu profiling")
+	debugCmd.Flags().BoolVar(&showMemStats, "memstats", false, "show memory statistics")
+	debugCmd.Flags().BoolVar(&showGoroutine, "goroutine", false, "show goroutine profile")
+}
+
+var debugCmd = &cobra.Command{
+	Use:   "debug",
+	Short: "Performance debugging with pprof",
+	Long: `Debug command provides CPU and memory profiling capabilities using pprof.
+	
+Examples:
+  # CPU profiling for 30 seconds
+  1panel-agent debug --cpuprofile=cpu.prof --duration=30s
+  
+  # Memory profiling
+  1panel-agent debug --memprofile=mem.prof
+  
+  # Show memory statistics
+  1panel-agent debug --memstats
+  
+  # Show goroutine information
+  1panel-agent debug --goroutine
+  
+  # Combined profiling
+  1panel-agent debug --cpuprofile=cpu.prof --memprofile=mem.prof --memstats`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if cpuProfile != "" {
+			if err := startCPUProfile(cpuProfile); err != nil {
+				return fmt.Errorf("failed to start CPU profile: %v", err)
+			}
+			defer stopCPUProfile()
+			time.Sleep(duration)
+			fmt.Printf("CPU profile saved to: %s\n", cpuProfile)
+		}
+
+		if memProfile != "" {
+			if err := writeMemProfile(memProfile); err != nil {
+				return fmt.Errorf("failed to write memory profile: %v", err)
+			}
+			fmt.Printf("Memory profile saved to: %s\n", memProfile)
+		}
+
+		if showMemStats {
+			printMemStats()
+		}
+
+		if showGoroutine {
+			printGoroutineInfo()
+		}
+
+		if cpuProfile == "" && memProfile == "" && !showMemStats && !showGoroutine {
+			printBasicInfo()
+		}
+		return nil
+	},
+}
+
+func startCPUProfile(filename string) error {
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+
+	if err := pprof.StartCPUProfile(f); err != nil {
+		f.Close()
+		return err
+	}
+
+	return nil
+}
+
+func stopCPUProfile() {
+	pprof.StopCPUProfile()
+}
+
+func writeMemProfile(filename string) error {
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	runtime.GC()
+
+	if err := pprof.WriteHeapProfile(f); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func printMemStats() {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	fmt.Println("\n=== Memory Statistics ===")
+	fmt.Printf("Allocated memory: %d KB (%d MB)\n", m.Alloc/1024, m.Alloc/1024/1024)
+	fmt.Printf("Total allocated: %d KB (%d MB)\n", m.TotalAlloc/1024, m.TotalAlloc/1024/1024)
+	fmt.Printf("System memory: %d KB (%d MB)\n", m.Sys/1024, m.Sys/1024/1024)
+	fmt.Printf("Heap allocated: %d KB (%d MB)\n", m.HeapAlloc/1024, m.HeapAlloc/1024/1024)
+	fmt.Printf("Heap system: %d KB (%d MB)\n", m.HeapSys/1024, m.HeapSys/1024/1024)
+	fmt.Printf("Heap idle: %d KB (%d MB)\n", m.HeapIdle/1024, m.HeapIdle/1024/1024)
+	fmt.Printf("Heap in use: %d KB (%d MB)\n", m.HeapInuse/1024, m.HeapInuse/1024/1024)
+	fmt.Printf("Heap released: %d KB (%d MB)\n", m.HeapReleased/1024, m.HeapReleased/1024/1024)
+	fmt.Printf("Heap objects: %d\n", m.HeapObjects)
+	fmt.Printf("GC runs: %d\n", m.NumGC)
+	fmt.Printf("GC pause total: %d ns\n", m.PauseTotalNs)
+	fmt.Printf("Next GC: %d KB (%d MB)\n", m.NextGC/1024, m.NextGC/1024/1024)
+	fmt.Printf("Last GC: %s\n", time.Unix(0, int64(m.LastGC)).Format("2006-01-02 15:04:05"))
+}
+
+func printGoroutineInfo() {
+	fmt.Println("\n=== Goroutine Information ===")
+	fmt.Printf("Number of goroutines: %d\n", runtime.NumGoroutine())
+	fmt.Printf("Number of CPUs: %d\n", runtime.NumCPU())
+	fmt.Printf("GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))
+
+	buf := make([]byte, 1024*1024)
+	stackSize := runtime.Stack(buf, true)
+	fmt.Printf("\nGoroutine stack trace (first 2048 bytes):\n")
+	if stackSize > 2048 {
+		fmt.Printf("%s...\n", buf[:2048])
+		fmt.Printf("(truncated, total size: %d bytes)\n", stackSize)
+	} else {
+		fmt.Printf("%s\n", buf[:stackSize])
+	}
+}
+
+func printBasicInfo() {
+	fmt.Println("=== Performance Debug Info ===")
+	fmt.Printf("Go version: %s\n", runtime.Version())
+	fmt.Printf("OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH)
+	fmt.Printf("CPUs: %d\n", runtime.NumCPU())
+	fmt.Printf("GOMAXPROCS: %d\n", runtime.GOMAXPROCS(0))
+	fmt.Printf("Goroutines: %d\n", runtime.NumGoroutine())
+
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	fmt.Printf("Memory allocated: %d KB\n", m.Alloc/1024)
+	fmt.Printf("Total allocations: %d KB\n", m.TotalAlloc/1024)
+	fmt.Printf("GC runs: %d\n", m.NumGC)
+
+	fmt.Println("\nUse --help to see available profiling options.")
+}

agent/cmd/server/cmd/root.go

@@ -0,0 +1,14 @@
+package cmd
+
+import (
+	"github.com/1Panel-dev/1Panel/agent/server"
+	"github.com/spf13/cobra"
+)
+
+var RootCmd = &cobra.Command{
+	Use: "1panel-agent",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		server.Start()
+		return nil
+	},
+}

agent/cmd/server/conf/app.yaml

@@ -1,6 +1,7 @@
 base:
   install_dir: /opt
   mode: dev
+  is_demo: false
 
 remote_url:
   app_repo: https://apps-assets.fit2cloud.com

agent/cmd/server/main.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	_ "net/http/pprof"
-
-	"github.com/1Panel-dev/1Panel/agent/server"
+	"fmt"
+	"github.com/1Panel-dev/1Panel/agent/cmd/server/cmd"
+	"os"
 )
 
 // @title 1Panel
@@ -15,5 +15,8 @@ import (
 // @host localhost
 // @BasePath /api/v2
 func main() {
-	server.Start()
+	if err := cmd.RootCmd.Execute(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
 }

agent/cmd/server/nginx_conf/nginx_conf.go

@@ -3,14 +3,12 @@ package nginx_conf
 import (
 	"embed"
 	_ "embed"
+	"io"
 )
 
 //go:embed ssl.conf
 var SSL []byte
 
-//go:embed  website_default.conf
-var WebsiteDefault []byte
-
 //go:embed index.html
 var Index []byte
 
@@ -44,8 +42,18 @@ var PathAuth []byte
 //go:embed upstream.conf
 var Upstream []byte
 
-//go:embed php_extensions.json
-var PHPExtensionsJson []byte
-
 //go:embed sse.conf
 var SSE []byte
+
+//go:embed *.json *.conf
+var websitesFiles embed.FS
+
+func GetWebsiteFile(filename string) []byte {
+	file, err := websitesFiles.Open(filename)
+	if err != nil {
+		return nil
+	}
+	defer file.Close()
+	res, _ := io.ReadAll(file)
+	return res
+}

agent/cmd/server/nginx_conf/php-fpm.conf

@@ -0,0 +1,16 @@
+[global]
+error_log = /var/log/php/fpm.error.log
+log_level = notice
+[www]
+user = www-data
+group = www-data
+listen = 0.0.0.0:9000
+pm = dynamic
+pm.max_children = 10
+pm.start_servers = 2
+pm.min_spare_servers = 1
+pm.max_spare_servers = 3
+pm.status_path = /status
+slowlog = /var/log/php/fpm.slow.log
+request_slowlog_timeout = 3
+catch_workers_output = yes

agent/cmd/server/nginx_conf/php_extensions.json

@@ -91,7 +91,7 @@
     "installed": false
   },
   {
-    "name": "Swoole",
+    "name": "swoole",
     "check": "swoole",
     "file": "swoole.so",
     "versions": ["56","70", "71", "72",  "73", "74",  "80", "81", "82", "83","84"],
@@ -369,5 +369,19 @@
     "file": "bcmath.so",
     "versions": ["56","70", "71", "72",  "73", "74",  "80", "81", "82", "83","84"],
     "installed": false
+  },
+  {
+    "name": "pcntl",
+    "check": "pcntl",
+    "file": "pcntl.so",
+    "versions": ["56","70", "71", "72",  "73", "74",  "80", "81", "82", "83","84"],
+    "installed": false
+  },
+  {
+    "name": "sodium",
+    "check": "sodium",
+    "file": "sodium.so",
+    "versions": ["70", "71", "72",  "73", "74",  "80", "81", "82", "83","84"],
+    "installed": false
   }
 ]

agent/cmd/server/nginx_conf/website_default.conf

@@ -15,9 +15,16 @@ server {
 
     access_log /www/sites/domain/log/access.log main;
     error_log /www/sites/domain/log/error.log;
-
+    
+    location ~ ^/(\.user.ini|\.htaccess|\.git|\.env|\.svn|\.project|LICENSE|README.md){
+        return 404;
+    }
     location ^~ /.well-known{
         allow all;
         root /usr/share/nginx/html;
     }
+    if ( $uri ~ "^/\.well-known/.*\.(php|jsp|py|js|css|lua|ts|go|zip|tar\.gz|rar|7z|sql|bak)$" ) {
+        return 403;
+    }
+
 }

agent/constant/alert.go

@@ -10,3 +10,18 @@ const (
 	AlertPushError   = "PushError"
 	AlertPushSuccess = "PushSuccess"
 )
+
+const (
+	CommonConfig = "common"
+	SMSConfig    = "sms"
+	EmailConfig  = "email"
+)
+
+const (
+	WeChat   = "wechat"
+	SMS      = "sms"
+	Email    = "mail"
+	WeCom    = "weCom"
+	DingTalk = "dingTalk"
+	FeiShu   = "feiShu"
+)

agent/constant/app.go

@@ -6,14 +6,17 @@ const (
 	AppNormal   = "Normal"
 	AppTakeDown = "TakeDown"
 
-	AppOpenresty  = "openresty"
-	AppMysql      = "mysql"
-	AppMariaDB    = "mariadb"
-	AppPostgresql = "postgresql"
-	AppRedis      = "redis"
-	AppPostgres   = "postgres"
-	AppMongodb    = "mongodb"
-	AppMemcached  = "memcached"
+	AppOpenresty         = "openresty"
+	AppMysql             = "mysql"
+	AppMariaDB           = "mariadb"
+	AppPostgresql        = "postgresql"
+	AppRedis             = "redis"
+	AppPostgres          = "postgres"
+	AppMongodb           = "mongodb"
+	AppMemcached         = "memcached"
+	AppMysqlCluster      = "mysql-cluster"
+	AppPostgresqlCluster = "postgresql-cluster"
+	AppRedisCluster      = "redis-cluster"
 
 	AppResourceLocal  = "local"
 	AppResourceRemote = "remote"

agent/constant/container.go

@@ -13,6 +13,6 @@ const (
 	ComposeOpStop    = "stop"
 	ComposeOpRestart = "restart"
 	ComposeOpRemove  = "remove"
-
-	DaemonJsonPath = "/etc/docker/daemon.json"
 )
+
+var DaemonJsonPath = "/etc/docker/daemon.json"

agent/constant/runtime.go

@@ -41,11 +41,11 @@ var RuntimeDefaultVolumes = map[string]string{
 
 var PHPDefaultVolumes = map[string]string{
 	"${PANEL_WEBSITE_DIR}":                  "/www/",
-	"./conf":                                "/usr/local/etc/php",
+	"./conf/php.ini":                        "/usr/local/etc/php/php.ini",
 	"./conf/conf.d":                         "/usr/local/etc/php/conf.d",
-	"./conf/php-fpm.conf":                   "/usr/local/etc/php-fpm.d/www.conf",
+	"./conf/php-fpm.conf":                   "/usr/local/etc/php-fpm.conf",
 	"./log":                                 "/var/log/php",
-	"./extensions":                          "${EXTENSION_DIR}",
+	"./extensions":                          "/usr/local/lib/php/extensions",
 	"./supervisor/supervisord.conf":         "/etc/supervisord.conf",
 	"./supervisor/supervisor.d/php-fpm.ini": "/etc/supervisor.d/php-fpm.ini",
 	"./supervisor/supervisor.d":             "/etc/supervisor.d",

agent/cron/job/backup.go

@@ -18,7 +18,7 @@ func NewBackupJob() *backup {
 
 func (b *backup) Run() {
 	var backups []model.BackupAccount
-	_ = global.DB.Where("`type` in (?) AND is_public = 0", []string{constant.OneDrive, constant.ALIYUN, constant.GoogleDrive}).Find(&backups)
+	_ = global.DB.Where("`type` in (?) AND is_public = 0", []string{constant.OneDrive, constant.ALIYUN}).Find(&backups)
 	if len(backups) == 0 {
 		return
 	}
@@ -39,8 +39,6 @@ func (b *backup) Run() {
 		switch backupItem.Type {
 		case constant.OneDrive:
 			refreshToken, err = client.RefreshToken("refresh_token", "refreshToken", varMap)
-		case constant.GoogleDrive:
-			refreshToken, err = client.RefreshGoogleToken("refresh_token", "refreshToken", varMap)
 		case constant.ALIYUN:
 			refreshToken, err = client.RefreshALIToken(varMap)
 		}

agent/global/config.go

@@ -1,9 +1,10 @@
 package global
 
 type ServerConfig struct {
-	Base      Base      `mapstructure:"base"`
-	RemoteURL RemoteURL `mapstructure:"remote_url"`
-	Log       LogConfig `mapstructure:"log"`
+	Base         Base      `mapstructure:"base"`
+	RemoteURL    RemoteURL `mapstructure:"remote_url"`
+	Log          LogConfig `mapstructure:"log"`
+	DockerConfig DockerConfig
 }
 
 type Base struct {
@@ -51,3 +52,7 @@ type LogConfig struct {
 	LogSuffix string `mapstructure:"log_suffix"`
 	MaxBackup int    `mapstructure:"max_backup"`
 }
+
+type DockerConfig struct {
+	Command string
+}

agent/global/global.go

@@ -15,6 +15,7 @@ var (
 	MonitorDB *gorm.DB
 	TaskDB    *gorm.DB
 	CoreDB    *gorm.DB
+	AlertDB   *gorm.DB
 
 	LOG   *logrus.Logger
 	CONF  ServerConfig
@@ -30,4 +31,7 @@ var (
 	IsMaster bool
 
 	I18n *i18n.Localizer
+
+	AlertBaseJobID     cron.EntryID
+	AlertResourceJobID cron.EntryID
 )

agent/go.mod

@@ -40,6 +40,7 @@ require (
 	github.com/shirou/gopsutil/v3 v3.24.5
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/afero v1.11.0
+	github.com/spf13/cobra v1.9.1
 	github.com/spf13/viper v1.19.0
 	github.com/studio-b12/gowebdav v0.9.0
 	github.com/subosito/gotenv v1.6.0
@@ -47,13 +48,13 @@ require (
 	github.com/upyun/go-sdk v2.1.0+incompatible
 	golang.org/x/crypto v0.39.0
 	golang.org/x/net v0.41.0
-	golang.org/x/oauth2 v0.29.0
+	golang.org/x/oauth2 v0.30.0
 	golang.org/x/sys v0.33.0
 	golang.org/x/text v0.26.0
 	google.golang.org/genproto v0.0.0-20241021214115-324edc3d5d38
 	gopkg.in/ini.v1 v1.67.0
 	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/gorm v1.25.11
+	gorm.io/gorm v1.30.0
 )
 
 require (
@@ -64,6 +65,7 @@ require (
 	github.com/alex-ant/gomath v0.0.0-20160516115720-89013a210a82 // indirect
 	github.com/aliyun/alibaba-cloud-sdk-go v1.63.100 // indirect
 	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/baidubce/bce-sdk-go v0.9.223 // indirect
 	github.com/bodgit/plumbing v1.2.0 // indirect
 	github.com/bodgit/sevenzip v1.3.0 // indirect
 	github.com/bodgit/windows v1.0.0 // indirect
@@ -97,7 +99,7 @@ require (
 	github.com/fvbommel/sortorder v1.1.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/glebarez/go-sqlite v1.22.0 // indirect
 	github.com/go-ini/ini v1.67.0 // indirect
 	github.com/go-jose/go-jose/v4 v4.0.5 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
@@ -105,7 +107,7 @@ require (
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
+	github.com/go-viper/mapstructure/v2 v2.3.0 // indirect
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/gofrs/flock v0.12.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
@@ -113,7 +115,6 @@ require (
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect
-	github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1 // indirect
 	github.com/h2non/filetype v1.1.1 // indirect
@@ -161,6 +162,7 @@ require (
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/mozillazg/go-httpheader v0.2.1 // indirect
 	github.com/namedotcom/go v0.0.0-20180403034216-08470befbe04 // indirect
+	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/nrdcg/dnspod-go v0.4.0 // indirect
 	github.com/nrdcg/freemyip v0.3.0 // indirect
 	github.com/nrdcg/mailinabox v0.2.0 // indirect
@@ -183,7 +185,6 @@ require (
 	github.com/shoenig/go-m1cpu v0.1.6 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
-	github.com/spf13/cobra v1.9.1 // indirect
 	github.com/spf13/pflag v1.0.6 // indirect
 	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/common v1.0.1128 // indirect
 	github.com/tencentcloud/tencentcloud-sdk-go/tencentcloud/dnspod v1.0.1128 // indirect
@@ -223,17 +224,17 @@ require (
 	go.uber.org/multierr v1.9.0 // indirect
 	go4.org v0.0.0-20200411211856-f5505b9728dd // indirect
 	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
+	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
 	golang.org/x/mod v0.25.0 // indirect
 	golang.org/x/sync v0.15.0 // indirect
 	golang.org/x/time v0.11.0 // indirect
-	golang.org/x/tools v0.33.0 // indirect
+	golang.org/x/tools v0.34.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20250218202821-56aae31c358a // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4 // indirect
 	google.golang.org/grpc v1.72.2 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
-	modernc.org/libc v1.22.5 // indirect
-	modernc.org/mathutil v1.5.0 // indirect
-	modernc.org/memory v1.5.0 // indirect
-	modernc.org/sqlite v1.23.1 // indirect
+	modernc.org/libc v1.66.1 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.11.0 // indirect
+	modernc.org/sqlite v1.38.0 // indirect
 )

agent/go.sum

@@ -90,6 +90,8 @@ github.com/aws/aws-sdk-go v1.55.0/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQ
 github.com/aws/aws-sdk-go-v2 v1.9.1/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4=
 github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.8.1/go.mod h1:CM+19rL1+4dFWnOQKwDc7H1KwXTz+h61oUSHyhV0b3o=
 github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E=
+github.com/baidubce/bce-sdk-go v0.9.223 h1:vvDeIemf7ePPP59nLHCntQ/vS++ok2HKbRPgmz1VZKU=
+github.com/baidubce/bce-sdk-go v0.9.223/go.mod h1:zbYJMQwE4IZuyrJiFO8tO8NbtYiKTFTbwh4eIsqjVdg=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
@@ -255,8 +257,8 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
 github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
-github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
-github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
+github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
+github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
 github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
 github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/go-acme/lego/v4 v4.23.1 h1:lZ5fGtGESA2L9FB8dNTvrQUq3/X4QOb8ExkKyY7LSV4=
@@ -309,8 +311,8 @@ github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpv
 github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss=
-github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-viper/mapstructure/v2 v2.3.0 h1:27XbWsHIqhbdR5TIC911OfYvgSaW93HM+dX7970Q7jk=
+github.com/go-viper/mapstructure/v2 v2.3.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/go-zookeeper/zk v1.0.2/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
@@ -394,8 +396,8 @@ github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hf
 github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af h1:kmjWCqn2qkEml422C2Rrd27c3VGxi6a/6HNq8QmHRKM=
-github.com/google/pprof v0.0.0-20240525223248-4bfdf5a9a2af/go.mod h1:K1liHPHnj73Fdn/EKuT8nrFqBihUSKXoLYU0BuatOYo=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
@@ -569,9 +571,8 @@ github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6T
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-shellwords v1.0.12 h1:M2zGm7EW6UQJvDeQxo4T51eKPurbeFbe8WtebGE2xrk=
 github.com/mattn/go-shellwords v1.0.12/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
+github.com/mattn/go-sqlite3 v1.14.0 h1:mLyGNKR8+Vv9CAU7PphKa2hkEqxxhn8i32J6FPj1/QA=
 github.com/mattn/go-sqlite3 v1.14.0/go.mod h1:JIl7NbARA7phWnGvh0LKTyg7S9BA+6gx71ShQilpsus=
-github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mholt/archiver/v4 v4.0.0-alpha.8 h1:tRGQuDVPh66WCOelqe6LIGh0gwmfwxUrSSDunscGsRM=
 github.com/mholt/archiver/v4 v4.0.0-alpha.8/go.mod h1:5f7FUYGXdJWUjESffJaYR4R60VhnHxb2X3T1teMyv5A=
@@ -648,6 +649,8 @@ github.com/nats-io/nats.go v1.12.1/go.mod h1:BPko4oXsySz4aSWeFgOHLZs3G4Jq4ZAyE6/
 github.com/nats-io/nkeys v0.2.0/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1tqEu/s=
 github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/nicksnyder/go-i18n/v2 v2.4.0 h1:3IcvPOAvnCKwNm0TB0dLDTuawWEj+ax/RERNC+diLMM=
 github.com/nicksnyder/go-i18n/v2 v2.4.0/go.mod h1:nxYSZE9M0bf3Y70gPQjN9ha7XNHX7gMc814+6wVyEI4=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
@@ -753,7 +756,6 @@ github.com/qiniu/go-sdk/v7 v7.21.1/go.mod h1:8EM2awITynlem2VML2dXGHkMYP2UyECsGLO
 github.com/qiniu/x v1.10.5/go.mod h1:03Ni9tj+N2h2aKnAz+6N0Xfl8FwMEDRC2PAlxekASDs=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
@@ -1002,8 +1004,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=
-golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
 golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -1090,6 +1092,8 @@ golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ
 golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.29.0 h1:WdYw2tdTK1S8olAzWHdgeqfy+Mtm9XNhv/xJsY65d98=
 golang.org/x/oauth2 v0.29.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
+golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
+golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -1259,8 +1263,8 @@ golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1394,8 +1398,8 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/gorm v1.25.11 h1:/Wfyg1B/je1hnDx3sMkX+gAlxrlZpn6X0BXRlwXlvHg=
-gorm.io/gorm v1.25.11/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ=
+gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
+gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
 gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
@@ -1405,14 +1409,32 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
-modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
-modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
-modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
-modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
-modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
-modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM=
-modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk=
+modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
+modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
+modernc.org/fileutil v1.3.3 h1:3qaU+7f7xxTUmvU1pJTZiDLAIoJVdUSSauJNHg9yXoA=
+modernc.org/fileutil v1.3.3/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/goabi0 v0.0.3 h1:y81b9r3asCh6Xtse6Nz85aYGB0cG3M3U6222yap1KWI=
+modernc.org/goabi0 v0.0.3/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
+modernc.org/libc v1.66.1 h1:4uQsntXbVyAgrV+j6NhKvDiUypoJL48BWQx6sy9y8ok=
+modernc.org/libc v1.66.1/go.mod h1:AiZxInURfEJx516LqEaFcrC+X38rt9G7+8ojIXQKHbo=
+modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
+modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
+modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
+modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
+modernc.org/sqlite v1.38.0 h1:+4OrfPQ8pxHKuWG4md1JpR/EYAh3Md7TdejuuzE7EUI=
+modernc.org/sqlite v1.38.0/go.mod h1:1Bj+yES4SVvBZ4cBOpVZ6QgesMCKpJZDq0nxYzOpmNE=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

agent/i18n/i18n.go

@@ -133,6 +133,7 @@ func Init() {
 	_, _ = bundle.LoadMessageFileFS(fs, "lang/ru.yaml")
 	_, _ = bundle.LoadMessageFileFS(fs, "lang/ms.yaml")
 	_, _ = bundle.LoadMessageFileFS(fs, "lang/ko.yaml")
+	_, _ = bundle.LoadMessageFileFS(fs, "lang/tr.yaml")
 	lang := GetLanguageFromDB()
 	global.I18n = i18n.NewLocalizer(bundle, lang)
 }

agent/i18n/lang/en.yaml

@@ -92,6 +92,7 @@ ErrCustomApps: 'There is an installed application, please uninstall it first'
 ErrCustomRuntimes: 'There is an installed runtime environment, please delete it first'
 ErrAppVersionDeprecated: "The {{ .name }} application is not compatible with the current 1Panel version, skipped"
 ErrDockerFailed: "The state of Docker is abnormal, please check the service status"
+ErrDockerComposeCmdNotFound: "The Docker Compose command does not exist, please install this command on the host machine first"
 
 #file
 ErrFileCanNotRead: 'This file does not support preview'
@@ -107,6 +108,7 @@ ErrSourcePathNotFound: 'Source directory does not exist'
 ErrFavoriteExist: 'This path has already been favorited'
 ErrInvalidChar: 'Illegal characters are not allowed'
 ErrPathNotDelete: 'The selected directory cannot be deleted'
+ErrLogFileToLarge: "The log file exceeds 500MB and cannot be opened"
 
 #website
 ErrAliasIsExist: 'Alias already exists'
@@ -175,7 +177,7 @@ ErrPgImagePull: 'Image pull timed out, please configure image acceleration or ma
 #runtime
 ErrFileNotExist: '{{ .detail }} file does not exist! Please check the integrity of the source file!'
 ErrImageBuildErr: 'Image build failed'
-ErrImageExist: 'Image already exists!'
+ErrImageExist: "Image already exists! Please modify the image name."
 ErrDelWithWebsite: 'The operating environment is already associated with a website and cannot be deleted'
 ErrRuntimeStart: 'Startup failed'
 ErrPackageJsonNotFound: 'package.json file does not exist'
@@ -202,6 +204,9 @@ HandleSystemClean: 'System cache cleanup'
 SystemLog: 'System Log'
 CutWebsiteLog: 'Rotate Website Log'
 FileOrDir: 'Directory / File'
+UploadFile: 'Uploading backup file {{ .file }} to {{ .backup }}'
+IgnoreBackupErr: 'Backup failed, error: {{ .detail }}, ignoring this error...'
+IgnoreUploadErr: 'Upload failed, error: {{ .detail }}, ignoring this error...'
 
 #toolbox
 ErrNotExistUser: 'The current user does not exist, please modify and try again!'
@@ -282,6 +287,7 @@ TaskBackup: 'Backup'
 TaskRecover: 'Recover'
 TaskRollback: 'Rollback'
 TaskPull: 'Pull'
+TaskCommit: 'Commit'
 TaskBuild: 'Build'
 TaskPush: 'Push'
 TaskHandle: 'Execute'
@@ -330,6 +336,7 @@ SnapDeleteLoginLog: 'Delete access log'
 SnapDeleteMonitor: 'Delete monitoring data'
 SnapRemoveSystemIP: 'Remove system IP'
 SnapBaseInfo: 'Write 1Panel basic information'
+SnapInstallAppImageEmpty: 'No application images selected, skipping...'
 SnapInstallApp: 'Backup 1Panel installed applications'
 SnapDockerSave: 'Compress installed applications'
 SnapLocalBackup: 'Backup 1Panel local backup directory'
@@ -417,4 +424,18 @@ ErrAlertSync: 'Alarm information synchronization error, please check and try aga
 ErrAlertRemote: 'Alarm message remote error, please check and try again!'
 
 #task - runtime
-ErrInstallExtension: "An installation task is already in progress, please wait for the task to finish"
+ErrInstallExtension: "An installation task is already in progress, please wait for the task to finish"
+
+# alert mail template
+PanelAlertTitle: "Panel Alert Notification"
+TestAlertTitle: "Test Email - Verify Email Connectivity"
+TestAlert: "This is a test email to verify that your email sending configuration is correct."
+LicenseExpirationAlert: "Your 1Panel license will expire in {{ .day }} days. Please log in to the panel for details."
+CronJobFailedAlert: "Your 1Panel scheduled task '{{ .name }}' has failed. Please log in to the panel for details."
+ClamAlert: "Your 1Panel virus scan task has detected {{ .num }} infected files. Please log in to the panel for details."
+WebSiteAlert: "There are {{ .num }} websites on your 1Panel that will expire in {{ .day }} days. Please log in to the panel for details."
+SSLAlert: "There are {{ .num }} SSL certificates on your 1Panel that will expire in {{ .day }} days. Please log in to the panel for details."
+DiskUsedAlert: "Your 1Panel disk '{{ .name }}' has used {{ .used }}. Please log in to the panel for details."
+ResourceAlert: "The average {{ .name }} usage over {{ .time }} minutes on your 1Panel is {{ .used }}. Please log in to the panel for details."
+PanelVersionAlert: "A new version of 1Panel is available. Please log in to the panel to upgrade."
+PanelPwdExpirationAlert: "Your 1Panel password will expire in {{ .day }} days. Please log in to the panel for details."

agent/i18n/lang/ja.yaml

@@ -92,6 +92,7 @@ ErrCustomApps: 'インストールされているアプリケーションがあ
 ErrCustomRuntimes: 'ランタイム環境がインストールされています。まずそれを削除してください'
 ErrAppVersionDeprecated: "{{ .name }} アプリケーションは現在の 1Panel バージョンと互換性がありません、スキップしました"
 ErrDockerFailed: "Docker の状態が異常です。サービス状態を確認してください"
+ErrDockerComposeCmdNotFound: "Docker Compose コマンドは存在しません。ホストマシンにこのコマンドを先にインストールしてください"
 
 #file
 ErrFileCanNotRead: 'このファイルはプレビューをサポートしていません'
@@ -107,6 +108,7 @@ ErrSourcePathNotFound: 'ソース ディレクトリが存在しません'
 ErrFavoriteExist: 'このパスはすでにお気に入りに登録されています'
 ErrInvalidChar: '不正な文字は許可されません'
 ErrPathNotDelete: '選択されたディレクトリは削除できません'
+ErrLogFileToLarge: "ログファイルが500MBを超えており、開くことができません"
 
 #website
 ErrAliasIsExist: 'エイリアスがすでに存在します'
@@ -175,7 +177,7 @@ ErrPgImagePull: 'イメージのプルがタイムアウトしました。イメ
 #runtime
 ErrFileNotExist: '{{ .detail }} ファイルが存在しません。ソース ファイルの整合性を確認してください。'
 ErrImageBuildErr: 'イメージのビルドに失敗しました'
-ErrImageExist: '画像がすでに存在します!'
+ErrImageExist: "イメージはすでに存在します！イメージ名を変更してください。"
 ErrDelWithWebsite: 'オペレーティング環境は既に Web サイトに関連付けられているため、削除できません'
 ErrRuntimeStart: '起動に失敗しました'
 ErrPackageJsonNotFound: 'package.json ファイルが存在しません'
@@ -202,6 +204,9 @@ HandleSystemClean: 'システム キャッシュのクリーンアップ'
 SystemLog: 'システムログ'
 CutWebsiteLog: 'ウェブサイトログのローテーション'
 FileOrDir: 'ディレクトリ / ファイル'
+UploadFile: 'バックアップファイル {{ .file }} を {{ .backup }} にアップロード中'
+IgnoreBackupErr: 'バックアップ失敗、エラー：{{ .detail }}、このエラーを無視します...'
+IgnoreUploadErr: 'アップロード失敗、エラー：{{ .detail }}、このエラーを無視します...'
 
 #toolbox
 ErrNotExistUser: '現在のユーザーは存在しません。変更してもう一度お試しください。'
@@ -282,6 +287,7 @@ TaskBackup: 'バックアップ'
 TaskRecover: '回復'
 TaskRollback: 'ロールバック'
 TaskPull: 'プル'
+TaskCommit: 'コミット'
 TaskBuild: 'ビルド'
 TaskPush: 'プッシュ'
 TaskHandle: '実行'
@@ -320,7 +326,7 @@ CustomAppstore: 'カスタム アプリケーション ウェアハウス'
 OllamaModelPull: 'Ollama モデル {{ .name }} をプルします'
 OllamaModelSize: "Ollama モデル {{ .name }} のサイズを取得します"
 
-#task - snapshot 
+#task - snapshot
 Snapshot: 'スナップショット'
 SnapDBInfo: '1Panel データベース情報を書き込む'
 SnapCopy: 'ファイルとディレクトリ {{ .name }} をコピーします'
@@ -330,7 +336,8 @@ SnapDeleteLoginLog: 'アクセスログを削除する'
 SnapDeleteMonitor: '監視データを削除する'
 SnapRemoveSystemIP: 'システム IP を削除します'
 SnapBaseInfo: '1Panel の基本情報を書き込む'
-SnapInstallApp: '1Panel にインストールされたアプリケーションをバックアップする'
+SnapInstallAppImageEmpty: 'アプリケーションイメージが選択されていないため、スキップします...'
+SnapInstallApp: '1Panelインストール済みアプリケーションのバックアップ'
 SnapDockerSave: 'インストールされたアプリケーションを圧縮する'
 SnapLocalBackup: '1Panel ローカル バックアップ ディレクトリをバックアップします'
 SnapCompressBackup: 'ローカル バックアップ ディレクトリを圧縮する'
@@ -417,4 +424,18 @@ ErrAlertSync: 'アラーム情報の同期エラーです。確認してもう
 ErrAlertRemote: 'アラーム メッセージのリモート エラーです。確認してもう一度お試しください。'
 
 #task - runtime
-ErrInstallExtension: "インストールタスクが進行中です、タスクが終了するのを待ってください"
+ErrInstallExtension: "インストールタスクが進行中です、タスクが終了するのを待ってください"
+
+# alert mail template
+PanelAlertTitle: "パネルアラート通知"
+TestAlertTitle: "テストメール - メール接続の確認"
+TestAlert: "これはテストメールです。メール送信設定が正しく構成されているかを確認します。"
+LicenseExpirationAlert: "お使いの 1Panel ライセンスは {{ .day }} 日後に有効期限が切れます。詳細はパネルにログインしてご確認ください。"
+CronJobFailedAlert: "1Panel のスケジュールタスク '{{ .name }}' の実行に失敗しました。詳細はパネルでご確認ください。"
+ClamAlert: "1Panel のウイルススキャンで {{ .num }} 件の感染ファイルが検出されました。詳細はパネルでご確認ください。"
+WebSiteAlert: "1Panel にある {{ .num }} 件のウェブサイトが {{ .day }} 日後に有効期限を迎えます。詳細はパネルでご確認ください。"
+SSLAlert: "1Panel にある {{ .num }} 枚のSSL証明書が {{ .day }} 日後に有効期限を迎えます。詳細はパネルでご確認ください。"
+DiskUsedAlert: "1Panel のディスク '{{ .name }}' は {{ .used }} 使用されています。詳細はパネルでご確認ください。"
+ResourceAlert: "1Panel の {{ .time }} 分間の平均 {{ .name }} 使用率は {{ .used }} です。詳細はパネルでご確認ください。"
+PanelVersionAlert: "1Panel に新しいバージョンが利用可能です。アップグレードはパネルから行ってください。"
+PanelPwdExpirationAlert: "1Panel のパスワードは {{ .day }} 日後に期限切れとなります。詳細はパネルでご確認ください。"

agent/i18n/lang/ko.yaml

@@ -92,6 +92,7 @@ ErrCustomApps: '설치된 애플리케이션이 있습니다. 먼저 제거해
 ErrCustomRuntimes: '설치된 런타임 환경이 있습니다. 먼저 삭제해 주세요'
 ErrAppVersionDeprecated: "{{ .name }} 응용 프로그램은 현재 1Panel 버전과 호환되지 않아 건너뛰었습니다"
 ErrDockerFailed: "Docker의 상태가 비정상입니다. 서비스 상태를 확인하세요"
+ErrDockerComposeCmdNotFound: "Docker Compose 명령이 없습니다. 호스트 머신에 먼저 이 명령을 설치하세요"
 
 #파일
 ErrFileCanNotRead: '이 파일은 미리보기를 지원하지 않습니다'
@@ -107,6 +108,7 @@ ErrSourcePathNotFound: '소스 디렉토리가 존재하지 않습니다'
 ErrFavoriteExist: '이 경로는 이미 즐겨찾기되었습니다'
 ErrInvalidChar: '불법 문자는 허용되지 않습니다'
 ErrPathNotDelete: '선택한 디렉토리를 삭제할 수 없습니다'
+ErrLogFileToLarge: "로그 파일이 500MB를 초과하여 열 수 없습니다"
 
 #웹사이트
 ErrAliasIsExist: '별칭이 이미 존재합니다'
@@ -175,7 +177,7 @@ ErrPgImagePull: '이미지 풀링 시간이 초과되었습니다. 이미지 가
 #실행 시간
 ErrFileNotExist: '{{ .detail }} 파일이 존재하지 않습니다! 소스 파일의 무결성을 확인하세요!'
 ErrImageBuildErr: '이미지 빌드 실패'
-ErrImageExist: '이미지가 이미 존재합니다!'
+ErrImageExist: "이미지가 이미 존재합니다! 이미지 이름을 수정하세요."
 ErrDelWithWebsite: '운영 환경이 이미 웹사이트와 연결되어 있어 삭제할 수 없습니다'
 ErrRuntimeStart: '시작 실패'
 ErrPackageJsonNotFound: 'package.json 파일이 존재하지 않습니다'
@@ -202,6 +204,9 @@ HandleSystemClean: '시스템 캐시 정리'
 SystemLog: '시스템 로그'
 CutWebsiteLog: '웹사이트 로그 회전'
 FileOrDir: '디렉터리 / 파일'
+UploadFile: '백업 파일 {{ .file }} 을(를) {{ .backup }}(으)로 업로드 중'
+IgnoreBackupErr: 'Sandaran gagal, ralat: {{ .detail }}, abaikan ralat ini...'
+IgnoreUploadErr: 'Muat naik gagal, ralat: {{ .detail }}, abaikan ralat ini...'
 
 #도구상자
 ErrNotExistUser: '현재 사용자가 존재하지 않습니다. 수정한 후 다시 시도하세요!'
@@ -282,6 +287,7 @@ TaskBackup: '백업'
 TaskRecover: '복구'
 TaskRollback: '롤백'
 TaskPull: '당기기'
+TaskCommit: '커밋'
 TaskBuild: '빌드'
 TaskPush: '푸시'
 TaskHandle: '실행'
@@ -330,6 +336,7 @@ SnapDeleteLoginLog: '액세스 로그 삭제'
 SnapDeleteMonitor: '모니터링 데이터 삭제'
 SnapRemoveSystemIP: '시스템 IP 제거'
 SnapBaseInfo: '1패널 기본 정보 쓰기'
+SnapInstallAppImageEmpty: '애플리케이션 이미지가 선택되지 않아 건너뜁니다...'
 SnapInstallApp: '1Panel 설치된 애플리케이션 백업'
 SnapDockerSave: '설치된 애플리케이션 압축'
 SnapLocalBackup: '1Panel 로컬 백업 디렉토리 백업'
@@ -417,4 +424,18 @@ ErrAlertSync: '알람 정보 동기화 오류입니다. 확인하고 다시 시
 ErrAlertRemote: '알람 메시지 원격 오류, 확인하고 다시 시도하세요!'
 
 #task - runtime
-ErrInstallExtension: "이미 설치 작업이 진행 중입니다. 작업이 완료될 때까지 기다려 주세요."
+ErrInstallExtension: "이미 설치 작업이 진행 중입니다. 작업이 완료될 때까지 기다려 주세요."
+
+# alert mail template
+PanelAlertTitle: "패널 알림 통지"
+TestAlertTitle: "테스트 이메일 - 이메일 연결 확인"
+TestAlert: "이것은 테스트 이메일이며 이메일 발송 설정이 올바른지 확인합니다."
+LicenseExpirationAlert: "귀하의 1Panel 라이선스는 {{ .day }}일 후에 만료됩니다. 자세한 내용은 패널에 로그인하세요."
+CronJobFailedAlert: "1Panel 예약 작업 '{{ .name }}' 실행에 실패했습니다. 자세한 내용은 패널에서 확인하세요."
+ClamAlert: "1Panel 바이러스 검사에서 {{ .num }}개의 감염된 파일이 발견되었습니다. 자세한 내용은 패널에서 확인하세요."
+WebSiteAlert: "1Panel 에 있는 {{ .num }}개의 웹사이트가 {{ .day }}일 후에 만료됩니다. 자세한 내용은 패널에서 확인하세요."
+SSLAlert: "1Panel 에 있는 {{ .num }}개의 SSL 인증서가 {{ .day }}일 후에 만료됩니다. 자세한 내용은 패널에서 확인하세요."
+DiskUsedAlert: "1Panel 디스크 '{{ .name }}'의 사용량은 {{ .used }}입니다. 자세한 내용은 패널에서 확인하세요."
+ResourceAlert: "1Panel 의 평균 {{ .time }}분 동안 {{ .name }} 사용률은 {{ .used }}입니다. 자세한 내용은 패널에서 확인하세요."
+PanelVersionAlert: "1Panel 의 새로운 버전이 이용 가능합니다. 패널에 로그인하여 업그레이드하세요."
+PanelPwdExpirationAlert: "1Panel 비밀번호가 {{ .day }}일 후에 만료됩니다. 자세한 내용은 패널에서 확인하세요."

agent/i18n/lang/ms.yaml

@@ -92,6 +92,7 @@ ErrCustomApps: 'Ada aplikasi yang dipasang, sila nyahpasangnya dahulu'
 ErrCustomRuntimes: 'Terdapat persekitaran masa jalan yang dipasang, sila padamkannya dahulu'
 ErrAppVersionDeprecated: "Aplikasi {{ .name }} tidak sesuai dengan versi 1Panel saat ini, dilewati"
 ErrDockerFailed: "Keadaan Docker tidak normal, sila periksa status perkhidmatan"
+ErrDockerComposeCmdNotFound: "Perintah Docker Compose tidak wujud, sila pasang perintah ini di mesin tuan terlebih dahulu"
 
 #fail
 ErrFileCanNotRead: 'Fail ini tidak menyokong pratonton'
@@ -175,7 +176,7 @@ ErrPgImagePull: 'Tarikh imej tamat masa, sila konfigurasikan pecutan imej atau t
 #masa berjalan
 ErrFileNotExist: 'Fail {{ .detail }} tidak wujud! Sila semak integriti fail sumber!'
 ErrImageBuildErr: 'Pembinaan imej gagal'
-ErrImageExist: 'Imej sudah wujud!'
+ErrImageExist: "Imej sudah wujud! Sila ubah nama imej."
 ErrDelWithWebsite: 'Persekitaran pengendalian sudah dikaitkan dengan tapak web dan tidak boleh dipadamkan'
 ErrRuntimeStart: 'Permulaan gagal'
 ErrPackageJsonNotFound: 'fail package.json tidak wujud'
@@ -202,6 +203,9 @@ HandleSystemClean: 'Pembersihan cache sistem'
 SystemLog: 'Log Sistem'
 CutWebsiteLog: 'Putar Log Laman Web'
 FileOrDir: 'Direktori / Fail'
+UploadFile: 'Muat naik fail sandaran {{ .file }} ke {{ .backup }}'
+IgnoreBackupErr: 'Sandaran gagal, ralat: {{ .detail }}, abaikan ralat ini...'
+IgnoreUploadErr: 'Muat naik gagal, ralat: {{ .detail }}, abaikan ralat ini...'
 
 #kotak alat
 ErrNotExistUser: 'Pengguna semasa tidak wujud, sila ubah suai dan cuba lagi!'
@@ -282,6 +286,7 @@ TaskBackup: 'Sandaran'
 TaskRecover: 'Pulihkan'
 TaskRollback: 'Rollback'
 TaskPull: 'Tarik'
+TaskCommit: 'Komit'
 TaskBuild: 'Bina'
 TaskPush: 'Tolak'
 TaskHandle: 'Laksanakan'
@@ -330,7 +335,8 @@ SnapDeleteLoginLog: 'Padam log akses'
 SnapDeleteMonitor: 'Padamkan data pemantauan'
 SnapRemoveSystemIP: 'Alih keluar IP sistem'
 SnapBaseInfo: 'Tulis maklumat asas 1Panel'
-SnapInstallApp: 'Aplikasi yang dipasang sandaran 1Panel'
+SnapInstallAppImageEmpty: 'Tiada imej aplikasi dipilih, dilangkau...'
+SnapInstallApp: 'Sandaran aplikasi terpasang 1Panel'
 SnapDockerSave: 'Mampatkan aplikasi yang dipasang'
 SnapLocalBackup: 'Sandaran 1Panel direktori sandaran tempatan'
 SnapCompressBackup: 'Mampatkan direktori sandaran tempatan'
@@ -417,4 +423,18 @@ ErrAlertSync: 'Ralat penyegerakan maklumat penggera, sila semak dan cuba lagi!'
 ErrAlertRemote: 'Ralat jauh mesej penggera, sila semak dan cuba lagi!'
 
 #task - runtime
-ErrInstallExtension: "Tugas pemasangan sudah sedang berjalan, silakan tunggu tugas selesai"
+ErrInstallExtension: "Tugas pemasangan sudah sedang berjalan, silakan tunggu tugas selesai"
+
+# alert mail template
+PanelAlertTitle: "Notifikasi Amaran Panel"
+TestAlertTitle: "E-mel Ujian - Sahkan Sambungan E-mel"
+TestAlert: "Ini adalah e-mel ujian untuk mengesahkan konfigurasi penghantaran e-mel anda betul."
+LicenseExpirationAlert: "Lesen 1Panel anda akan tamat dalam {{ .day }} hari. Sila log masuk ke panel untuk maklumat lanjut."
+CronJobFailedAlert: "Tugas berjadual 1Panel '{{ .name }}' gagal dilaksanakan. Sila log masuk ke panel untuk butiran lanjut."
+ClamAlert: "Tugas imbasan virus 1Panel menemui {{ .num }} fail yang dijangkiti. Sila log masuk ke panel untuk maklumat lanjut."
+WebSiteAlert: "Terdapat {{ .num }} laman web dalam 1Panel anda yang akan tamat dalam {{ .day }} hari. Sila log masuk ke panel untuk maklumat lanjut."
+SSLAlert: "Terdapat {{ .num }} sijil SSL dalam 1Panel anda yang akan tamat dalam {{ .day }} hari. Sila log masuk ke panel untuk maklumat lanjut."
+DiskUsedAlert: "Cakera '{{ .name }}' dalam 1Panel anda telah menggunakan {{ .used }}. Sila log masuk ke panel untuk maklumat lanjut."
+ResourceAlert: "Penggunaan purata {{ .name }} selama {{ .time }} minit dalam 1Panel anda ialah {{ .used }}. Sila log masuk ke panel untuk maklumat lanjut."
+PanelVersionAlert: "Versi baru 1Panel tersedia. Sila log masuk ke panel untuk menaik taraf."
+PanelPwdExpirationAlert: "Kata laluan 1Panel anda akan tamat dalam {{ .day }} hari. Sila log masuk ke panel untuk maklumat lanjut."