chore: Modify cache cleanup internationalization (#11551)

Refs #11486

aws v2 存在部分兼容性问题 https://github.com/aws/aws-sdk-go-v2/issues/3007

.github/workflows/add-labels-for-pr.yml

@@ -6,6 +6,7 @@ permissions:
 jobs:
   generic_handler:
     name: Add Labels to PR
+    if: github.repository == '1Panel-dev/1Panel'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3

.github/workflows/build-publish-to-oss.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
       - name: Build Release
         uses: goreleaser/goreleaser-action@v6
         with:

.github/workflows/build-publish-to-r2.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
       - name: Build Release
         uses: goreleaser/goreleaser-action@v6
         with:

.github/workflows/sonarcloud-scan.yml

@@ -8,6 +8,7 @@ on:
 jobs:
   sonarcloud:
     name: SonarCloud
+    if: github.repository == '1Panel-dev/1Panel'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3

.github/workflows/sync2gitee.yml

@@ -2,6 +2,7 @@ name: Synchronize to Gitee
 on: [push]
 jobs:
   repo-sync:
+    if: github.repository == '1Panel-dev/1Panel'
     runs-on: ubuntu-latest
     steps:
       - name: Mirror the Github organization repos to Gitee.

.goreleaser.yaml

@@ -33,9 +33,6 @@ builds:
       - ppc64le
       - s390x
       - riscv64
-    hooks:
-      post:
-        - ./ci/script.sh compress_binary {{ .Path }} {{ .Arch }}
 
   - id: core
     dir: core
@@ -59,9 +56,6 @@ builds:
       - ppc64le
       - s390x
       - riscv64
-    hooks:
-      post:
-        - ./ci/script.sh compress_binary {{ .Path }} {{ .Arch }}
 
 archives:
   - formats: [ 'tar.gz' ]
@@ -70,11 +64,12 @@ archives:
     wrap_in_directory: true
     files:
       - 1pctl
+      - install.sh
       - 1panel-core.service
       - 1panel-agent.service
-      - install.sh
-      - GeoIP.mmdb
+      - initscript/*
       - lang/*
+      - GeoIP.mmdb
 
 checksum:
   name_template: 'checksums.txt'

Makefile

@@ -30,20 +30,20 @@ build_frontend:
 
 build_core_on_linux:
 	cd $(CORE_PATH) \
-	&& GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w' -o $(BUILD_PATH)/$(CORE_NAME) $(CORE_MAIN)
+	&& CGO_ENABLED=0 GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w' -o $(BUILD_PATH)/$(CORE_NAME) $(CORE_MAIN)
 
 build_agent_on_linux:
 	cd $(AGENT_PATH) \
-    && GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w' -o $(BUILD_PATH)/$(AGENT_NAME) $(AGENT_MAIN)
+    && CGO_ENABLED=0 GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w' -o $(BUILD_PATH)/$(AGENT_NAME) $(AGENT_MAIN)
 
 build_core_on_darwin:
 	cd $(CORE_PATH) \
-	&& GOOS=linux GOARCH=amd64 $(GOBUILD) -trimpath -ldflags '-s -w'  -o $(BUILD_PATH)/$(CORE_NAME) $(CORE_MAIN)
+	&&  CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -trimpath -ldflags '-s -w'  -o $(BUILD_PATH)/$(CORE_NAME) $(CORE_MAIN)
 
 build_agent_on_darwin:
 	cd $(AGENT_PATH) \
-    && GOOS=linux GOARCH=amd64 $(GOBUILD) -trimpath -ldflags '-s -w'  -o $(BUILD_PATH)/$(AGENT_NAME) $(AGENT_MAIN)
+    &&  CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -trimpath -ldflags '-s -w'  -o $(BUILD_PATH)/$(AGENT_NAME) $(AGENT_MAIN)
 
 build_all: build_frontend build_core_on_linux build_agent_on_linux
 
-build_on_local: clean_assets build_frontend build_core_on_darwin build_agent_on_darwin upx_bin
+build_on_local: clean_assets build_frontend build_core_on_darwin build_agent_on_darwin

agent/app/api/v2/app.go

@@ -1,6 +1,9 @@
 package v2
 
 import (
+	"net/http"
+	"time"
+
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
@@ -26,7 +29,7 @@ func (b *BaseApi) SearchApp(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, list)
+	helper.SuccessWithDataGzipped(c, list)
 }
 
 // @Tags App
@@ -192,3 +195,48 @@ func (b *BaseApi) GetAppListUpdate(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, res)
 }
+
+// @Tags App
+// @Summary Get app icon by app_id
+// @Accept json
+// @Param appId path integer true "app id"
+// @Success 200 {file} file "app icon"
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /apps/icon/:appId [get]
+func (b *BaseApi) GetAppIcon(c *gin.Context) {
+	appID, err := helper.GetIntParamByKey(c, "appID")
+	if err != nil {
+		helper.BadRequest(c, err)
+		return
+	}
+	iconBytes, err := appService.GetAppIcon(appID)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	c.Header("Content-Type", "image/png")
+	c.Header("Cache-Control", "public, max-age=31536000, immutable")
+	c.Header("Last-Modified", time.Now().UTC().Format(http.TimeFormat))
+	c.Data(http.StatusOK, "image/png", iconBytes)
+}
+
+// @Tags App
+// @Summary Search app detail by appkey and version
+// @Accept json
+// @Param appId path integer true "app key"
+// @Param version path string true "app version"
+// @Success 200 {object} response.AppDetailSimpleDTO
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /apps/detail/node/:appKey/:version [get]
+func (b *BaseApi) GetAppDetailForNode(c *gin.Context) {
+	appKey := c.Param("appKey")
+	version := c.Param("version")
+	appDetailDTO, err := appService.GetAppDetailByKey(appKey, version)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, appDetailDTO)
+}

agent/app/api/v2/backup.go

@@ -25,6 +25,23 @@ func (b *BaseApi) CheckBackupUsed(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Backup Account
+// @Summary Check backup account
+// @Accept json
+// @Param request body dto.BackupOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /backups/check [post]
+func (b *BaseApi) CheckBackup(c *gin.Context) {
+	var req dto.BackupOperate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	helper.SuccessWithData(c, backupService.CheckConn(req))
+}
+
 // @Tags Backup Account
 // @Summary Create backup account
 // @Accept json

agent/app/api/v2/compose_template.go

@@ -28,6 +28,28 @@ func (b *BaseApi) CreateComposeTemplate(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Container Compose-template
+// @Summary Bacth compose template
+// @Accept json
+// @Param request body dto.ComposeTemplateBatch true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /containers/template/batch [post]
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"批量导入编排模版","formatEN":"batch import compose templates"}
+func (b *BaseApi) BatchComposeTemplate(c *gin.Context) {
+	var req dto.ComposeTemplateBatch
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := composeTemplateService.Batch(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Container Compose-template
 // @Summary Page compose templates
 // @Accept json

agent/app/api/v2/container.go

@@ -263,6 +263,27 @@ func (b *BaseApi) ContainerListStats(c *gin.Context) {
 	helper.SuccessWithData(c, data)
 }
 
+// @Summary Load container stats size
+// @Accept json
+// @Param request body dto.OperationWithName true "request"
+// @Success 200 {object} dto.ContainerItemStats
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /containers/item/stats [post]
+func (b *BaseApi) ContainerItemStats(c *gin.Context) {
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	data, err := containerService.ContainerItemStats(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, data)
+}
+
 // @Tags Container
 // @Summary Create container
 // @Accept json
@@ -314,7 +335,7 @@ func (b *BaseApi) ContainerCreateByCommand(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/upgrade [post]
-// @x-panel-log {"bodyKeys":["name","image"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新容器镜像 [name][image]","formatEN":"upgrade container image [name][image]"}
+// @x-panel-log {"bodyKeys":["names","image"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新容器镜像 [names][image]","formatEN":"upgrade container image [names][image]"}
 func (b *BaseApi) ContainerUpgrade(c *gin.Context) {
 	var req dto.ContainerUpgrade
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -372,6 +393,28 @@ func (b *BaseApi) CleanContainerLog(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Container
+// @Summary Clean compose log
+// @Accept json
+// @Param request body dto.ComposeLogClean true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /containers/compose/clean/log [post]
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理容器编排 [name] 日志","formatEN":"clean compose [name] logs"}
+func (b *BaseApi) CleanComposeLog(c *gin.Context) {
+	var req dto.ComposeLogClean
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := containerService.ComposeLogClean(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Container
 // @Summary Rename Container
 // @Accept json
@@ -481,7 +524,6 @@ func (b *BaseApi) Inspect(c *gin.Context) {
 	helper.SuccessWithData(c, result)
 }
 
-// @Router /containers/download/log [post]
 func (b *BaseApi) DownloadContainerLogs(c *gin.Context) {
 	var req dto.ContainerLog
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -695,6 +737,7 @@ func (b *BaseApi) ComposeUpdate(c *gin.Context) {
 // @Param since query string false "时间筛选"
 // @Param follow query string false "是否追踪"
 // @Param tail query string false "显示行号"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/search/log [get]

agent/app/api/v2/cronjob.go

@@ -211,7 +211,7 @@ func (b *BaseApi) LoadRecordLog(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /cronjobs/records/clean [post]
-// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"清空计划任务记录 [name]","formatEN":"clean cronjob [name] records"}
+// @x-panel-log {"bodyKeys":["cronjobID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"cronjobID","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"清空计划任务记录 [name]","formatEN":"clean cronjob [name] records"}
 func (b *BaseApi) CleanRecord(c *gin.Context) {
 	var req dto.CronjobClean
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/dashboard.go

@@ -27,7 +27,7 @@ func (b *BaseApi) LoadDashboardOsInfo(c *gin.Context) {
 // @Tags Dashboard
 // @Summary Load app launcher
 // @Accept json
-// @Success 200 {Array} dto.AppLauncher
+// @Success 200 {array} dto.AppLauncher
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /dashboard/app/launcher [get]
@@ -37,14 +37,14 @@ func (b *BaseApi) LoadAppLauncher(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, data)
+	helper.SuccessWithDataGzipped(c, data)
 }
 
 // @Tags Dashboard
 // @Summary Load app launcher options
 // @Accept json
 // @Param request body dto.SearchByFilter true "request"
-// @Success 200 {Array} dto.LauncherOption
+// @Success 200 {array} dto.LauncherOption
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /dashboard/app/launcher/option [post]
@@ -85,7 +85,7 @@ func (b *BaseApi) UpdateAppLauncher(c *gin.Context) {
 
 // @Tags Dashboard
 // @Summary Load quick jump options
-// @Success 200 {Array} dto.QuickJump
+// @Success 200 {array} dto.QuickJump
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /dashboard/quick/option [get]
@@ -179,6 +179,28 @@ func (b *BaseApi) LoadDashboardCurrentInfo(c *gin.Context) {
 	helper.SuccessWithData(c, data)
 }
 
+// @Tags Dashboard
+// @Summary Load top cpu processes
+// @Success 200 {array} dto.Process
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /dashboard/current/top/cpu [get]
+func (b *BaseApi) LoadDashboardTopCPU(c *gin.Context) {
+	data := dashboardService.LoadTopCPU()
+	helper.SuccessWithData(c, data)
+}
+
+// @Tags Dashboard
+// @Summary Load top memory processes
+// @Success 200 {array} dto.Process
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /dashboard/current/top/mem [get]
+func (b *BaseApi) LoadDashboardTopMem(c *gin.Context) {
+	data := dashboardService.LoadTopMem()
+	helper.SuccessWithData(c, data)
+}
+
 // @Tags Dashboard
 // @Summary System restart
 // @Accept json

agent/app/api/v2/database_mysql.go

@@ -195,27 +195,26 @@ func (b *BaseApi) SearchMysql(c *gin.Context) {
 }
 
 // @Tags Database Mysql
-// @Summary List mysql database names
+// @Summary List mysql database format collation options
 // @Accept json
-// @Param request body dto.PageInfo true "request"
-// @Success 200 {array} dto.MysqlOption
+// @Param request body dto.OperationWithName true "request"
+// @Success 200 {array} dto.MysqlFormatCollationOption
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /databases/options [get]
-func (b *BaseApi) ListDBName(c *gin.Context) {
-	list, err := mysqlService.ListDBOption()
-	if err != nil {
-		helper.InternalServer(c, err)
+// @Router /databases/format/options [post]
+func (b *BaseApi) ListDBFormatCollationOptions(c *gin.Context) {
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-
-	helper.SuccessWithData(c, list)
+	helper.SuccessWithData(c, mysqlService.LoadFormatOption(req))
 }
 
 // @Tags Database Mysql
 // @Summary Load mysql database from remote
 // @Accept json
 // @Param request body dto.MysqlLoadDB true "request"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /databases/load [post]

agent/app/api/v2/database_postgresql.go

@@ -167,6 +167,7 @@ func (b *BaseApi) SearchPostgresql(c *gin.Context) {
 // @Summary Load postgresql database from remote
 // @Accept json
 // @Param request body dto.PostgresqlLoadDB true "request"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /databases/pg/:database/load [post]

agent/app/api/v2/device.go

@@ -27,7 +27,7 @@ func (b *BaseApi) LoadDeviceBaseInfo(c *gin.Context) {
 // @Tags Device
 // @Summary list time zone options
 // @Accept json
-// @Success 200 {Array} string
+// @Success 200 {array} string
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /toolbox/device/zone/options [get]

agent/app/api/v2/entry.go

@@ -38,6 +38,7 @@ var (
 	fileService     = service.NewIFileService()
 	sshService      = service.NewISSHService()
 	firewallService = service.NewIFirewallService()
+	iptablesService = service.NewIIptablesService()
 	monitorService  = service.NewIMonitorService()
 	systemService   = service.NewISystemService()
 

agent/app/api/v2/fail2ban.go

@@ -28,7 +28,7 @@ func (b *BaseApi) LoadFail2BanBaseInfo(c *gin.Context) {
 // @Summary Page fail2ban ip list
 // @Accept json
 // @Param request body dto.Fail2BanSearch true "request"
-// @Success 200 {Array} string
+// @Success 200 {array} string
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /toolbox/fail2ban/search [post]
@@ -51,6 +51,7 @@ func (b *BaseApi) SearchFail2Ban(c *gin.Context) {
 // @Summary Operate fail2ban
 // @Accept json
 // @Param request body dto.Operate true "request"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /toolbox/fail2ban/operate [post]
@@ -72,7 +73,8 @@ func (b *BaseApi) OperateFail2Ban(c *gin.Context) {
 // @Tags Fail2ban
 // @Summary Operate sshd of fail2ban
 // @Accept json
-// @Param request body dto.Operate true "request"
+// @Param request body dto.Fail2BanSet true "request"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /toolbox/fail2ban/operate/sshd [post]

agent/app/api/v2/file.go

@@ -90,7 +90,7 @@ func (b *BaseApi) GetFileTree(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, tree)
+	helper.SuccessWithDataGzipped(c, tree)
 }
 
 // @Tags File
@@ -265,6 +265,33 @@ func (b *BaseApi) GetContent(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
+	if info.Size > 2*1024 && info.Size < 5*1024*1024 {
+		helper.SuccessWithDataGzipped(c, info)
+	} else {
+		helper.SuccessWithData(c, info)
+	}
+}
+
+// @Tags File
+// @Summary Preview file content
+// @Accept json
+// @Param request body request.FileContentReq true "request"
+// @Success 200 {object} response.FileInfo
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /files/preview [post]
+// @x-panel-log {"bodyKeys":["path"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"预览文件内容 [path]","formatEN":"Preview file content [path]"}
+func (b *BaseApi) PreviewContent(c *gin.Context) {
+	var req request.FileContentReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	info, err := fileService.GetPreviewContent(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
 	helper.SuccessWithData(c, info)
 }
 
@@ -521,9 +548,14 @@ func (b *BaseApi) Download(c *gin.Context) {
 	file, err := os.Open(filePath)
 	if err != nil {
 		helper.InternalServer(c, err)
+		return
 	}
 	defer file.Close()
-	info, _ := file.Stat()
+	info, err := file.Stat()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
 	c.Header("Content-Length", strconv.FormatInt(info.Size(), 10))
 	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(info.Name()))
 	http.ServeContent(c.Writer, c.Request, info.Name(), info.ModTime(), file)
@@ -841,7 +873,11 @@ func (b *BaseApi) ReadFileByLine(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, res)
+	if res.TotalLines > 100 {
+		helper.SuccessWithDataGzipped(c, res)
+	} else {
+		helper.SuccessWithData(c, res)
+	}
 }
 
 // @Tags File

agent/app/api/v2/firewall.go

@@ -8,12 +8,19 @@ import (
 
 // @Tags Firewall
 // @Summary Load firewall base info
+// @Accept json
+// @Param request body dto.OperationWithName true "request"
 // @Success 200 {object} dto.FirewallBaseInfo
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /hosts/firewall/base [get]
+// @Router /hosts/firewall/base [post]
 func (b *BaseApi) LoadFirewallBaseInfo(c *gin.Context) {
-	data, err := firewallService.LoadBaseInfo()
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	data, err := firewallService.LoadBaseInfo(req.Name)
 	if err != nil {
 		helper.InternalServer(c, err)
 		return
@@ -95,14 +102,14 @@ func (b *BaseApi) OperatePortRule(c *gin.Context) {
 
 // OperateForwardRule
 // @Tags Firewall
-// @Summary Create group
+// @Summary Operate forward rule
 // @Accept json
 // @Param request body dto.ForwardRuleOperate true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /hosts/firewall/forward [post]
-// @x-panel-log {"bodyKeys":["source_port"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新端口转发规则 [source_port]","formatEN":"update port forward rules [source_port]"}
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新端口转发规则","formatEN":"update port forward rules"}
 func (b *BaseApi) OperateForwardRule(c *gin.Context) {
 	var req dto.ForwardRuleOperate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -117,7 +124,7 @@ func (b *BaseApi) OperateForwardRule(c *gin.Context) {
 }
 
 // @Tags Firewall
-// @Summary Create group
+// @Summary Operate Ip rule
 // @Accept json
 // @Param request body dto.AddrRuleOperate true "request"
 // @Success 200
@@ -139,7 +146,7 @@ func (b *BaseApi) OperateIPRule(c *gin.Context) {
 }
 
 // @Tags Firewall
-// @Summary Create group
+// @Summary Batch operate rule
 // @Accept json
 // @Param request body dto.BatchRuleOperate true "request"
 // @Success 200
@@ -181,7 +188,7 @@ func (b *BaseApi) UpdateFirewallDescription(c *gin.Context) {
 }
 
 // @Tags Firewall
-// @Summary Create group
+// @Summary Update port rule
 // @Accept json
 // @Param request body dto.PortRuleUpdate true "request"
 // @Success 200
@@ -202,7 +209,7 @@ func (b *BaseApi) UpdatePortRule(c *gin.Context) {
 }
 
 // @Tags Firewall
-// @Summary Create group
+// @Summary Update Ip rule
 // @Accept json
 // @Param request body dto.AddrRuleUpdate true "request"
 // @Success 200
@@ -221,3 +228,112 @@ func (b *BaseApi) UpdateAddrRule(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags Firewall
+// @Summary search iptables filter rules
+// @Accept json
+// @Param request body dto.SearchPageWithType true "request"
+// @Success 200 {object} dto.PageResult
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/firewall/filter/search [post]
+func (b *BaseApi) SearchFilterRules(c *gin.Context) {
+	var req dto.SearchPageWithType
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	total, list, err := iptablesService.Search(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Items: list,
+		Total: total,
+	})
+}
+
+// @Tags Firewall
+// @Summary Operate iptables filter rule
+// @Accept json
+// @Param request body dto.IptablesRuleOp true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/firewall/filter/rule/operate [post]
+// @x-panel-log {"bodyKeys":["operation","chain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] filter规则到 [chain]","formatEN":"[operation] filter rule to [chain]"}
+func (b *BaseApi) OperateFilterRule(c *gin.Context) {
+	var req dto.IptablesRuleOp
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := iptablesService.OperateRule(req, true); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.Success(c)
+}
+
+// @Tags Firewall
+// @Summary Batch operate iptables filter rules
+// @Accept json
+// @Param request body dto.IptablesBatchOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/firewall/filter/rule/batch [post]
+func (b *BaseApi) BatchOperateFilterRule(c *gin.Context) {
+	var req dto.IptablesBatchOperate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := iptablesService.BatchOperate(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.Success(c)
+}
+
+// @Tags Firewall
+// @Summary Apply/Unload/Init iptables filter
+// @Accept json
+// @Param request body dto.IptablesOp true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/firewall/filter/operate [post]
+// @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] iptables filter 防火墙","formatEN":"[operate] iptables filter firewall"}
+func (b *BaseApi) OperateFilterChain(c *gin.Context) {
+	var req dto.IptablesOp
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := iptablesService.Operate(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.Success(c)
+}
+
+// @Tags Firewall
+// @Summary load chain status with name
+// @Accept json
+// @Param request body dto.OperationWithName true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/firewall/filter/chain/status [post]
+func (b *BaseApi) LoadChainStatus(c *gin.Context) {
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	helper.SuccessWithData(c, iptablesService.LoadChainStatus(req))
+}

agent/app/api/v2/ftp.go

@@ -54,6 +54,7 @@ func (b *BaseApi) LoadFtpLogInfo(c *gin.Context) {
 // @Summary Operate FTP
 // @Accept json
 // @Param request body dto.Operate true "request"
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /toolbox/ftp/operate [post]

agent/app/api/v2/helper/helper.go

@@ -1,10 +1,14 @@
 package helper
 
 import (
+	"compress/gzip"
 	"context"
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"strconv"
+	"strings"
+	"sync"
 
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"gorm.io/gorm"
@@ -46,6 +50,42 @@ func SuccessWithData(ctx *gin.Context, data interface{}) {
 	ctx.Abort()
 }
 
+var gzipWriterPool = sync.Pool{
+	New: func() interface{} {
+		return gzip.NewWriter(nil)
+	},
+}
+
+func SuccessWithDataGzipped(ctx *gin.Context, data interface{}) {
+	if !strings.Contains(ctx.GetHeader("Accept-Encoding"), "gzip") {
+		SuccessWithData(ctx, data)
+		return
+	}
+	if data == nil {
+		data = gin.H{}
+	}
+	res := dto.Response{
+		Code: http.StatusOK,
+		Data: data,
+	}
+	jsonBytes, err := json.Marshal(res)
+	if err != nil {
+		ErrorWithDetail(ctx, http.StatusInternalServerError, "ErrInternalServer", err)
+		return
+	}
+
+	ctx.Header("Content-Encoding", "gzip")
+	ctx.Header("Content-Type", "application/json; charset=utf-8")
+	ctx.Status(http.StatusOK)
+
+	gz := gzipWriterPool.Get().(*gzip.Writer)
+	gz.Reset(ctx.Writer)
+	_, _ = gz.Write(jsonBytes)
+	_ = gz.Close()
+	gzipWriterPool.Put(gz)
+	ctx.Abort()
+}
+
 func Success(ctx *gin.Context) {
 	res := dto.Response{
 		Code:    http.StatusOK,

agent/app/api/v2/monitor.go

@@ -28,6 +28,27 @@ func (b *BaseApi) LoadMonitor(c *gin.Context) {
 		helper.InternalServer(c, err)
 		return
 	}
+	helper.SuccessWithDataGzipped(c, data)
+}
+
+// @Tags Monitor
+// @Summary Load monitor data
+// @Param request body dto.MonitorGPUSearch true "request"
+// @Success 200 {object} dto.MonitorGPUData
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/monitor/gpu/search [post]
+func (b *BaseApi) LoadGPUMonitor(c *gin.Context) {
+	var req dto.MonitorGPUSearch
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	data, err := monitorService.LoadGPUMonitorData(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
 	helper.SuccessWithData(c, data)
 }
 
@@ -105,3 +126,7 @@ func (b *BaseApi) GetIOOptions(c *gin.Context) {
 	sort.Strings(options)
 	helper.SuccessWithData(c, options)
 }
+
+func (b *BaseApi) GetCPUOptions(c *gin.Context) {
+	helper.SuccessWithData(c, monitorService.LoadGPUOptions())
+}

agent/app/api/v2/nginx.go

@@ -161,13 +161,13 @@ func (b *BaseApi) GetNginxModules(c *gin.Context) {
 // @Tags OpenResty
 // @Summary Operate default HTTPs
 // @Accept json
-// @Param request body request.NginxOperateReq true "request"
+// @Param request body request.NginxDefaultHTTPSUpdate true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /openresty/https [post]
 func (b *BaseApi) OperateDefaultHTTPs(c *gin.Context) {
-	var req request.NginxOperateReq
+	var req request.NginxDefaultHTTPSUpdate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}

agent/app/api/v2/process.go

@@ -40,7 +40,7 @@ func (b *BaseApi) StopProcess(c *gin.Context) {
 // @Tags Process
 // @Summary Get Process Info By PID
 // @Param pid path int true "PID"
-// @Success 200 {object} websocket.PsProcessData
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /process/{pid} [get]

agent/app/api/v2/setting.go

@@ -84,9 +84,31 @@ func (b *BaseApi) CheckLocalConn(c *gin.Context) {
 	helper.SuccessWithData(c, err == nil)
 }
 
+// @Tags System Setting
+// @Summary Update local is conn
+// @Accept json
+// @Param request body dto.SSHDefaultConn true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /settings/ssh/conn/default [post]
+// @x-panel-log {"bodyKeys":["defaultConn"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"本地终端默认连接 [defaultConn]","formatEN":"update system default conn [defaultConn]"}
+func (b *BaseApi) SetDefaultIsConn(c *gin.Context) {
+	var req dto.SSHDefaultConn
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := settingService.SetDefaultIsConn(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags System Setting
 // @Summary Check local conn info
-// @Success 200 {bool} isOk
+// @Success 200 {boolean} isOk
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /settings/ssh/check/info [post]
@@ -155,3 +177,24 @@ func (b *BaseApi) GetSettingByKey(c *gin.Context) {
 	value := settingService.GetSettingByKey(key)
 	helper.SuccessWithData(c, value)
 }
+
+// @Tags System Setting
+// @Summary Save common description
+// @Accept json
+// @Param request body dto.CommonDescription true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /settings/description/save [post]
+func (b *BaseApi) SaveDescription(c *gin.Context) {
+	var req dto.CommonDescription
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := settingService.SaveDescription(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}

agent/app/api/v2/ssh.go

@@ -53,7 +53,7 @@ func (b *BaseApi) OperateSSH(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /hosts/ssh/update [post]
-// @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置 [key] => [value]","formatEN":"update SSH setting [key] => [value]"}
+// @x-panel-log {"bodyKeys":["key","newValue"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置 [key] => [newValue]","formatEN":"update SSH setting [key] => [newValue]"}
 func (b *BaseApi) UpdateSSH(c *gin.Context) {
 	var req dto.SSHUpdate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/system.go

@@ -9,7 +9,7 @@ import (
 // @Tags Host
 // @Summary Check if a system component exists
 // @Accept json
-// @Param name query string true "Component name to check (e.g., rsync, docker)"
+// @Param name path string true "Component name to check (e.g., rsync, docker)"
 // @Success 200 {object} response.ComponentInfo
 // @Security ApiKeyAuth
 // @Security Timestamp

agent/app/api/v2/terminal.go

@@ -228,8 +228,8 @@ func wshandleError(ws *websocket.Conn, err error) bool {
 }
 
 var upGrader = websocket.Upgrader{
-	ReadBufferSize:  1024,
-	WriteBufferSize: 1024 * 1024 * 10,
+	ReadBufferSize:  4096,
+	WriteBufferSize: 16384,
 	CheckOrigin: func(r *http.Request) bool {
 		return true
 	},

agent/app/api/v2/website.go

@@ -73,7 +73,7 @@ func (b *BaseApi) GetWebsiteOptions(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /websites [post]
-// @x-panel-log {"bodyKeys":["primaryDomain"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 [primaryDomain]","formatEN":"Create website [primaryDomain]"}
+// @x-panel-log {"bodyKeys":["alias"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建网站 [alias]","formatEN":"Create website [alias]"}
 func (b *BaseApi) CreateWebsite(c *gin.Context) {
 	var req request.WebsiteCreate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -672,7 +672,7 @@ func (b *BaseApi) UpdateAntiLeech(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /websites/redirect/update [post]
-// @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改网站 [domain] 重定向理配置 ","formatEN":"Update domain [domain] redirect config"}
+// @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改网站 [domain] 重定向配置 ","formatEN":"Update domain [domain] redirect config"}
 func (b *BaseApi) UpdateRedirectConfig(c *gin.Context) {
 	var req request.NginxRedirectReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -1145,7 +1145,7 @@ func (b *BaseApi) ExecComposer(c *gin.Context) {
 // @Tags Website
 // @Summary Batch operate websites
 // @Accept json
-// @Param request body request.BatchOpWebsite true "request"
+// @Param request body request.BatchWebsiteOp true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
@@ -1162,6 +1162,26 @@ func (b *BaseApi) BatchOpWebsites(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Website
+// @Summary Batch set website group
+// @Accept json
+// @Param request body request.BatchWebsiteGroup true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /websites/batch/group [post]
+func (b *BaseApi) BatchSetWebsiteGroup(c *gin.Context) {
+	var req request.BatchWebsiteGroup
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := websiteService.BatchSetGroup(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Website
 // @Summary Get CORS Config
 // @Accept json
@@ -1203,3 +1223,43 @@ func (b *BaseApi) UpdateCORSConfig(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags Website
+// @Summary Update Stream Config
+// @Accept json
+// @Param request body request.StreamUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /websites/stream/update [post]
+func (b *BaseApi) UpdateStreamConfig(c *gin.Context) {
+	var req request.StreamUpdate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := websiteService.UpdateStream(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+// @Tags Website
+// @Summary Batch set HTTPS for websites
+// @Accept json
+// @Param request body request.BatchWebsiteHttps true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /websites/batch/https [post]
+func (b *BaseApi) BatchSetHttps(c *gin.Context) {
+	var req request.BatchWebsiteHttps
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := websiteService.BatchSetHttps(c, req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}

agent/app/api/v2/website_ssl.go

@@ -1,7 +1,6 @@
 package v2
 
 import (
-	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"io"
 	"mime/multipart"
 	"net/http"
@@ -9,6 +8,8 @@ import (
 	"reflect"
 	"strconv"
 
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
@@ -34,7 +35,7 @@ func (b *BaseApi) PageWebsiteSSL(c *gin.Context) {
 			helper.InternalServer(c, err)
 			return
 		}
-		helper.SuccessWithData(c, dto.PageResult{
+		helper.SuccessWithDataGzipped(c, dto.PageResult{
 			Total: total,
 			Items: accounts,
 		})
@@ -44,7 +45,7 @@ func (b *BaseApi) PageWebsiteSSL(c *gin.Context) {
 			helper.InternalServer(c, err)
 			return
 		}
-		helper.SuccessWithData(c, list)
+		helper.SuccessWithDataGzipped(c, list)
 	}
 }
 
@@ -235,7 +236,6 @@ func (b *BaseApi) UploadWebsiteSSL(c *gin.Context) {
 func (b *BaseApi) UploadSSLFile(c *gin.Context) {
 	var req request.WebsiteSSLFileUpload
 
-	req.Type = c.PostForm("type")
 	req.Description = c.PostForm("description")
 	sslID := c.PostForm("sslID")
 	if sslID != "" {
@@ -279,7 +279,7 @@ func (b *BaseApi) UploadSSLFile(c *gin.Context) {
 		return
 	}
 
-	helper.SuccessWithData(c, nil)
+	helper.Success(c)
 }
 
 func readUploadedFile(fileHeader *multipart.FileHeader) ([]byte, error) {

agent/app/dto/alert.go

@@ -317,7 +317,7 @@ type AlertCommonConfig struct {
 
 type AlertSmsConfig struct {
 	Phone         string `json:"phone"`
-	AlertDailyNum uint   `json:"alertDailyNum"`
+	AlertDailyNum string `json:"alertDailyNum"`
 }
 
 type AlertEmailConfig struct {

agent/app/dto/app.go

@@ -12,6 +12,8 @@ type AppDatabase struct {
 	DbUser       string `json:"PANEL_DB_USER"`
 	Password     string `json:"PANEL_DB_USER_PASSWORD"`
 	DatabaseName string `json:"DATABASE_NAME"`
+	Format       string `json:"format"`
+	Collation    string `json:"collation"`
 }
 
 type AuthParam struct {
@@ -82,25 +84,26 @@ type ExtraProperties struct {
 }
 
 type AppProperty struct {
-	Name               string   `json:"name"`
-	Type               string   `json:"type"`
-	Tags               []string `json:"tags"`
-	ShortDescZh        string   `json:"shortDescZh" yaml:"shortDescZh"`
-	ShortDescEn        string   `json:"shortDescEn" yaml:"shortDescEn"`
-	Description        Locale   `json:"description"`
-	Key                string   `json:"key"`
-	Required           []string `json:"Required"`
-	CrossVersionUpdate bool     `json:"crossVersionUpdate"`
-	Limit              int      `json:"limit"`
-	Recommend          int      `json:"recommend"`
-	Website            string   `json:"website"`
-	Github             string   `json:"github"`
-	Document           string   `json:"document"`
-	Architectures      []string `json:"architectures"`
-	MemoryRequired     int      `json:"memoryRequired"`
-	GpuSupport         bool     `json:"gpuSupport"`
-	Version            float64  `json:"version"`
-	Deprecated         float64  `json:"deprecated"`
+	Name                string   `json:"name"`
+	Type                string   `json:"type"`
+	Tags                []string `json:"tags"`
+	ShortDescZh         string   `json:"shortDescZh" yaml:"shortDescZh"`
+	ShortDescEn         string   `json:"shortDescEn" yaml:"shortDescEn"`
+	Description         Locale   `json:"description"`
+	Key                 string   `json:"key"`
+	Required            []string `json:"Required"`
+	CrossVersionUpdate  bool     `json:"crossVersionUpdate" yaml:"crossVersionUpdate"`
+	Limit               int      `json:"limit" yaml:"limit"`
+	Recommend           int      `json:"recommend" yaml:"recommend"`
+	Website             string   `json:"website"`
+	Github              string   `json:"github"`
+	Document            string   `json:"document"`
+	Architectures       []string `json:"architectures"`
+	MemoryRequired      int      `json:"memoryRequired" yaml:"memoryRequired"`
+	GpuSupport          bool     `json:"gpuSupport" yaml:"gpuSupport"`
+	Version             float64  `json:"version"`
+	Deprecated          float64  `json:"deprecated"`
+	BatchInstallSupport bool     `json:"batchInstallSupport"`
 }
 
 type AppConfigVersion struct {

agent/app/dto/backup.go

@@ -33,6 +33,12 @@ type BackupInfo struct {
 	RememberAuth bool `json:"rememberAuth"`
 }
 
+type BackupCheckRes struct {
+	IsOk  bool   `json:"isOk"`
+	Msg   string `json:"msg"`
+	Token string `json:"token"`
+}
+
 type ForBuckets struct {
 	Type       string `json:"type" validate:"required"`
 	AccessKey  string `json:"accessKey"`
@@ -77,6 +83,7 @@ type CommonRecover struct {
 	Secret            string `json:"secret"`
 	TaskID            string `json:"taskID"`
 	BackupRecordID    uint   `json:"backupRecordID"`
+	Timeout           int    `json:"timeout"`
 }
 
 type RecordSearch struct {

agent/app/dto/compose_template.go

@@ -8,6 +8,10 @@ type ComposeTemplateCreate struct {
 	Content     string `json:"content"`
 }
 
+type ComposeTemplateBatch struct {
+	Templates []ComposeTemplateCreate `json:"templates" validate:"required"`
+}
+
 type ComposeTemplateUpdate struct {
 	ID          uint   `json:"id"`
 	Description string `json:"description"`

agent/app/dto/container.go

@@ -15,8 +15,9 @@ type PageContainer struct {
 }
 
 type InspectReq struct {
-	ID   string `json:"id" validate:"required"`
-	Type string `json:"type" validate:"required"`
+	ID     string `json:"id" validate:"required"`
+	Type   string `json:"type" validate:"required"`
+	Detail string `json:"detail"`
 }
 
 type ContainerInfo struct {
@@ -37,6 +38,9 @@ type ContainerInfo struct {
 	AppName        string   `json:"appName"`
 	AppInstallName string   `json:"appInstallName"`
 	Websites       []string `json:"websites"`
+
+	IsPinned    bool   `json:"isPinned"`
+	Description string `json:"description"`
 }
 
 type ContainerOptions struct {
@@ -45,14 +49,13 @@ type ContainerOptions struct {
 }
 
 type ContainerStatus struct {
-	All        uint `json:"all"`
-	Created    uint `json:"created"`
-	Running    uint `json:"running"`
-	Paused     uint `json:"paused"`
-	Restarting uint `json:"restarting"`
-	Removing   uint `json:"removing"`
-	Exited     uint `json:"exited"`
-	Dead       uint `json:"dead"`
+	Created    int `json:"created"`
+	Running    int `json:"running"`
+	Paused     int `json:"paused"`
+	Restarting int `json:"restarting"`
+	Removing   int `json:"removing"`
+	Exited     int `json:"exited"`
+	Dead       int `json:"dead"`
 
 	ContainerCount       int `json:"containerCount"`
 	ComposeCount         int `json:"composeCount"`
@@ -61,8 +64,6 @@ type ContainerStatus struct {
 	NetworkCount         int `json:"networkCount"`
 	VolumeCount          int `json:"volumeCount"`
 	RepoCount            int `json:"repoCount"`
-
-	ImageSize uint64 `json:"imageSize"`
 }
 type ResourceLimit struct {
 	CPU    int    `json:"cpu"`
@@ -70,17 +71,16 @@ type ResourceLimit struct {
 }
 
 type ContainerOperate struct {
-	TaskID          string         `json:"taskID"`
-	ForcePull       bool           `json:"forcePull"`
-	Name            string         `json:"name" validate:"required"`
-	Image           string         `json:"image" validate:"required"`
-	Network         string         `json:"network"`
-	Hostname        string         `json:"hostname"`
-	DomainName      string         `json:"domainName"`
-	MacAddr         string         `json:"macAddr"`
-	DNS             []string       `json:"dns"`
-	Ipv4            string         `json:"ipv4"`
-	Ipv6            string         `json:"ipv6"`
+	TaskID    string `json:"taskID"`
+	ForcePull bool   `json:"forcePull"`
+	Name      string `json:"name" validate:"required"`
+	Image     string `json:"image" validate:"required"`
+
+	Hostname   string             `json:"hostname"`
+	DomainName string             `json:"domainName"`
+	DNS        []string           `json:"dns"`
+	Networks   []ContainerNetwork `json:"networks"`
+
 	PublishAllPorts bool           `json:"publishAllPorts"`
 	ExposedPorts    []PortHelper   `json:"exposedPorts"`
 	Tty             bool           `json:"tty"`
@@ -99,6 +99,12 @@ type ContainerOperate struct {
 	Env             []string       `json:"env"`
 	RestartPolicy   string         `json:"restartPolicy"`
 }
+type ContainerNetwork struct {
+	Network string `json:"network"`
+	Ipv4    string `json:"ipv4"`
+	Ipv6    string `json:"ipv6"`
+	MacAddr string `json:"macAddr"`
+}
 
 type ContainerCreateByCommand struct {
 	TaskID  string `json:"taskID"`
@@ -112,6 +118,19 @@ type ContainerUpgrade struct {
 	ForcePull bool     `json:"forcePull"`
 }
 
+type ContainerItemStats struct {
+	SizeRw     int64 `json:"sizeRw"`
+	SizeRootFs int64 `json:"sizeRootFs"`
+
+	ContainerUsage        int64 `json:"containerUsage"`
+	ContainerReclaimable  int64 `json:"containerReclaimable"`
+	ImageUsage            int64 `json:"imageUsage"`
+	ImageReclaimable      int64 `json:"imageReclaimable"`
+	VolumeUsage           int64 `json:"volumeUsage"`
+	VolumeReclaimable     int64 `json:"volumeReclaimable"`
+	BuildCacheUsage       int64 `json:"buildCacheUsage"`
+	BuildCacheReclaimable int64 `json:"buildCacheReclaimable"`
+}
 type ContainerListStats struct {
 	ContainerID string `json:"containerID"`
 
@@ -153,6 +172,7 @@ type PortHelper struct {
 }
 
 type ContainerOperation struct {
+	TaskID    string   `json:"taskID"`
 	Names     []string `json:"names" validate:"required"`
 	Operation string   `json:"operation" validate:"required,oneof=up start stop restart kill pause unpause remove"`
 }
@@ -242,35 +262,42 @@ type ComposeInfo struct {
 	Workdir        string             `json:"workdir"`
 	Path           string             `json:"path"`
 	Containers     []ComposeContainer `json:"containers"`
-	Env            []string           `json:"env"`
+	Env            string             `json:"env"`
 }
 type ComposeContainer struct {
-	ContainerID string `json:"containerID"`
-	Name        string `json:"name"`
-	CreateTime  string `json:"createTime"`
-	State       string `json:"state"`
+	ContainerID string   `json:"containerID"`
+	Name        string   `json:"name"`
+	CreateTime  string   `json:"createTime"`
+	State       string   `json:"state"`
+	Ports       []string `json:"ports"`
 }
 type ComposeCreate struct {
-	TaskID   string   `json:"taskID"`
-	Name     string   `json:"name"`
-	From     string   `json:"from" validate:"required,oneof=edit path template"`
-	File     string   `json:"file"`
-	Path     string   `json:"path"`
-	Template uint     `json:"template"`
-	Env      []string `json:"env"`
+	TaskID   string `json:"taskID"`
+	Name     string `json:"name"`
+	From     string `json:"from" validate:"required,oneof=edit path template"`
+	File     string `json:"file"`
+	Path     string `json:"path"`
+	Template uint   `json:"template"`
+	Env      string `json:"env"`
 }
 type ComposeOperation struct {
 	Name      string `json:"name" validate:"required"`
 	Path      string `json:"path"`
 	Operation string `json:"operation" validate:"required,oneof=up start restart stop down delete"`
 	WithFile  bool   `json:"withFile"`
-	Force     bool   `josn:"force"`
+	Force     bool   `json:"force"`
 }
 type ComposeUpdate struct {
-	Name    string   `json:"name" validate:"required"`
-	Path    string   `json:"path" validate:"required"`
-	Content string   `json:"content" validate:"required"`
-	Env     []string `json:"env"`
+	Name       string `json:"name" validate:"required"`
+	Path       string `json:"path" validate:"required"`
+	DetailPath string `json:"detailPath"`
+	Content    string `json:"content" validate:"required"`
+	Env        string `json:"env"`
+}
+type ComposeLogClean struct {
+	Name       string `json:"name" validate:"required"`
+	Path       string `json:"path" validate:"required"`
+	DetailPath string `json:"detailPath"`
 }
 
 type ContainerLog struct {

agent/app/dto/cronjob.go

@@ -53,6 +53,12 @@ type CronjobOperate struct {
 	AlertCount  uint   `json:"alertCount"`
 	AlertTitle  string `json:"alertTitle"`
 	AlertMethod string `json:"alertMethod"`
+
+	CleanLogConfig
+}
+
+type CleanLogConfig struct {
+	Scopes []string `json:"scopes"`
 }
 
 type SnapshotRule struct {

agent/app/dto/dashboard.go

@@ -13,15 +13,17 @@ type DashboardBase struct {
 	Platform             string `json:"platform"`
 	PlatformFamily       string `json:"platformFamily"`
 	PlatformVersion      string `json:"platformVersion"`
+	PrettyDistro         string `json:"prettyDistro"`
 	KernelArch           string `json:"kernelArch"`
 	KernelVersion        string `json:"kernelVersion"`
 	VirtualizationSystem string `json:"virtualizationSystem"`
 	IpV4Addr             string `json:"ipV4Addr"`
 	SystemProxy          string `json:"systemProxy"`
 
-	CPUCores        int    `json:"cpuCores"`
-	CPULogicalCores int    `json:"cpuLogicalCores"`
-	CPUModelName    string `json:"cpuModelName"`
+	CPUCores        int     `json:"cpuCores"`
+	CPULogicalCores int     `json:"cpuLogicalCores"`
+	CPUModelName    string  `json:"cpuModelName"`
+	CPUMhz          float64 `json:"cpuMhz"`
 
 	QuickJumps  []QuickJump      `json:"quickJump"`
 	CurrentInfo DashboardCurrent `json:"currentInfo"`
@@ -48,6 +50,7 @@ type OsInfo struct {
 	PlatformFamily string `json:"platformFamily"`
 	KernelArch     string `json:"kernelArch"`
 	KernelVersion  string `json:"kernelVersion"`
+	PrettyDistro   string `json:"prettyDistro"`
 
 	DiskSize int64 `json:"diskSize"`
 }
@@ -58,9 +61,10 @@ type NodeCurrent struct {
 	Load15           float64 `json:"load15"`
 	LoadUsagePercent float64 `json:"loadUsagePercent"`
 
-	CPUUsedPercent float64 `json:"cpuUsedPercent"`
-	CPUUsed        float64 `json:"cpuUsed"`
-	CPUTotal       int     `json:"cpuTotal"`
+	CPUUsedPercent     float64   `json:"cpuUsedPercent"`
+	CPUUsed            float64   `json:"cpuUsed"`
+	CPUTotal           int       `json:"cpuTotal"`
+	CPUDetailedPercent []float64 `json:"cpuDetailedPercent"`
 
 	MemoryTotal       uint64  `json:"memoryTotal"`
 	MemoryAvailable   uint64  `json:"memoryAvailable"`
@@ -84,10 +88,11 @@ type DashboardCurrent struct {
 	Load15           float64 `json:"load15"`
 	LoadUsagePercent float64 `json:"loadUsagePercent"`
 
-	CPUPercent     []float64 `json:"cpuPercent"`
-	CPUUsedPercent float64   `json:"cpuUsedPercent"`
-	CPUUsed        float64   `json:"cpuUsed"`
-	CPUTotal       int       `json:"cpuTotal"`
+	CPUPercent         []float64 `json:"cpuPercent"`
+	CPUUsedPercent     float64   `json:"cpuUsedPercent"`
+	CPUUsed            float64   `json:"cpuUsed"`
+	CPUTotal           int       `json:"cpuTotal"`
+	CPUDetailedPercent []float64 `json:"cpuDetailedPercent"`
 
 	MemoryTotal       uint64  `json:"memoryTotal"`
 	MemoryUsed        uint64  `json:"memoryUsed"`
@@ -116,6 +121,9 @@ type DashboardCurrent struct {
 	GPUData []GPUInfo `json:"gpuData"`
 	XPUData []XPUInfo `json:"xpuData"`
 
+	TopCPUItems []Process `json:"topCPUItems"`
+	TopMemItems []Process `json:"topMemItems"`
+
 	ShotTime time.Time `json:"shotTime"`
 }
 

agent/app/dto/database.go

@@ -38,6 +38,7 @@ type MysqlDBInfo struct {
 	From        string    `json:"from"`
 	MysqlName   string    `json:"mysqlName"`
 	Format      string    `json:"format"`
+	Collation   string    `json:"collation"`
 	Username    string    `json:"username"`
 	Password    string    `json:"password"`
 	Permission  string    `json:"permission"`
@@ -57,13 +58,19 @@ type MysqlDBCreate struct {
 	Name        string `json:"name" validate:"required"`
 	From        string `json:"from" validate:"required,oneof=local remote"`
 	Database    string `json:"database" validate:"required"`
-	Format      string `json:"format" validate:"required,oneof=utf8mb4 utf8 gbk big5"`
+	Format      string `json:"format" validate:"required"`
+	Collation   string `json:"collation"`
 	Username    string `json:"username" validate:"required"`
 	Password    string `json:"password" validate:"required"`
 	Permission  string `json:"permission" validate:"required"`
 	Description string `json:"description"`
 }
 
+type MysqlFormatCollationOption struct {
+	Format     string   `json:"format"`
+	Collations []string `json:"collations"`
+}
+
 type BindUser struct {
 	Database   string `json:"database" validate:"required"`
 	DB         string `json:"db" validate:"required"`
@@ -251,6 +258,7 @@ type DatabaseInfo struct {
 	Version   string    `json:"version"`
 	Address   string    `json:"address"`
 	Port      uint      `json:"port"`
+	InitialDB string    `json:"initialDB"`
 	Username  string    `json:"username"`
 	Password  string    `json:"password"`
 
@@ -281,14 +289,15 @@ type DatabaseItem struct {
 }
 
 type DatabaseCreate struct {
-	Name     string `json:"name" validate:"required,max=256"`
-	Type     string `json:"type" validate:"required"`
-	From     string `json:"from" validate:"required,oneof=local remote"`
-	Version  string `json:"version" validate:"required"`
-	Address  string `json:"address"`
-	Port     uint   `json:"port"`
-	Username string `json:"username" validate:"required"`
-	Password string `json:"password"`
+	Name      string `json:"name" validate:"required,max=256"`
+	Type      string `json:"type" validate:"required"`
+	From      string `json:"from" validate:"required,oneof=local remote"`
+	Version   string `json:"version" validate:"required"`
+	Address   string `json:"address"`
+	Port      uint   `json:"port"`
+	InitialDB string `json:"initialDB"`
+	Username  string `json:"username" validate:"required"`
+	Password  string `json:"password"`
 
 	SSL        bool   `json:"ssl"`
 	RootCert   string `json:"rootCert"`
@@ -301,13 +310,14 @@ type DatabaseCreate struct {
 }
 
 type DatabaseUpdate struct {
-	ID       uint   `json:"id"`
-	Type     string `json:"type" validate:"required"`
-	Version  string `json:"version" validate:"required"`
-	Address  string `json:"address"`
-	Port     uint   `json:"port"`
-	Username string `json:"username" validate:"required"`
-	Password string `json:"password"`
+	ID        uint   `json:"id"`
+	Type      string `json:"type" validate:"required"`
+	Version   string `json:"version" validate:"required"`
+	Address   string `json:"address"`
+	Port      uint   `json:"port"`
+	InitialDB string `json:"initialDB"`
+	Username  string `json:"username" validate:"required"`
+	Password  string `json:"password"`
 
 	SSL        bool   `json:"ssl"`
 	RootCert   string `json:"rootCert"`

agent/app/dto/firewall.go

@@ -4,6 +4,8 @@ type FirewallBaseInfo struct {
 	Name       string `json:"name"`
 	IsExist    bool   `json:"isExist"`
 	IsActive   bool   `json:"isActive"`
+	IsInit     bool   `json:"isInit"`
+	IsBind     bool   `json:"isBind"`
 	Version    string `json:"version"`
 	PingStatus string `json:"pingStatus"`
 }
@@ -17,12 +19,14 @@ type RuleSearch struct {
 }
 
 type FirewallOperation struct {
-	Operation         string `json:"operation" validate:"required,oneof=start stop restart disablePing enablePing"`
+	Operation         string `json:"operation" validate:"required,oneof=start stop restart disableBanPing enableBanPing"`
 	WithDockerRestart bool   `json:"withDockerRestart"`
 }
 
 type PortRuleOperate struct {
+	ID        uint   `json:"id"`
 	Operation string `json:"operation" validate:"required,oneof=add remove"`
+	Chain     string `json:"chain"`
 	Address   string `json:"address"`
 	Port      string `json:"port" validate:"required"`
 	Protocol  string `json:"protocol" validate:"required,oneof=tcp udp tcp/udp"`
@@ -46,8 +50,11 @@ type ForwardRuleOperate struct {
 
 type UpdateFirewallDescription struct {
 	Type     string `json:"type"`
-	Address  string `json:"address"`
-	Port     string `json:"port"`
+	Chain    string `json:"chain"`
+	SrcIP    string `json:"srcIP"`
+	DstIP    string `json:"dstIP"`
+	SrcPort  string `json:"srcPort"`
+	DstPort  string `json:"dstPort"`
 	Protocol string `json:"protocol"`
 	Strategy string `json:"strategy" validate:"required,oneof=accept drop"`
 
@@ -55,6 +62,7 @@ type UpdateFirewallDescription struct {
 }
 
 type AddrRuleOperate struct {
+	ID        uint   `json:"id"`
 	Operation string `json:"operation" validate:"required,oneof=add remove"`
 	Address   string `json:"address"  validate:"required"`
 	Strategy  string `json:"strategy" validate:"required,oneof=accept drop"`
@@ -76,3 +84,30 @@ type BatchRuleOperate struct {
 	Type  string            `json:"type" validate:"required"`
 	Rules []PortRuleOperate `json:"rules"`
 }
+
+type IptablesOp struct {
+	Name    string `json:"name" validate:"required,oneof=1PANEL_INPUT 1PANEL_OUTPUT 1PANEL_BASIC"`
+	Operate string `json:"operate" validate:"required,oneof=init-base init-forward init-advance bind-base unbind-base bind unbind"`
+}
+
+type IptablesRuleOp struct {
+	Operation   string `json:"operation" validate:"required,oneof=add remove"`
+	ID          uint   `json:"id"`
+	Chain       string `json:"chain" validate:"required,oneof=1PANEL_BASIC 1PANEL_BASIC_BEFORE 1PANEL_INPUT 1PANEL_OUTPUT"`
+	Protocol    string `json:"protocol"`
+	SrcIP       string `json:"srcIP"`
+	SrcPort     uint   `json:"srcPort"`
+	DstIP       string `json:"dstIP"`
+	DstPort     uint   `json:"dstPort"`
+	Strategy    string `json:"strategy" validate:"required,oneof=accept drop reject"`
+	Description string `json:"description"`
+}
+
+type IptablesBatchOperate struct {
+	Rules []IptablesRuleOp `json:"rules"`
+}
+
+type IptablesChainStatus struct {
+	IsBind          bool   `json:"isBind"`
+	DefaultStrategy string `json:"defaultStrategy"`
+}

agent/app/dto/image.go

@@ -15,10 +15,14 @@ type ImageInfo struct {
 	IsUsed    bool      `json:"isUsed"`
 	Tags      []string  `json:"tags"`
 	Size      int64     `json:"size"`
+
+	IsPinned    bool   `json:"isPinned"`
+	Description string `json:"description"`
 }
 
 type ImageLoad struct {
-	Path string `json:"path" validate:"required"`
+	TaskID string `json:"taskID"`
+	Path   string `json:"path" validate:"required"`
 }
 
 type ImageBuild struct {
@@ -27,6 +31,7 @@ type ImageBuild struct {
 	Name       string   `json:"name" validate:"required"`
 	Dockerfile string   `json:"dockerfile" validate:"required"`
 	Tags       []string `json:"tags"`
+	Args       []string `json:"args"`
 }
 
 type ImagePull struct {
@@ -48,6 +53,7 @@ type ImagePush struct {
 }
 
 type ImageSave struct {
+	TaskID  string `json:"taskID"`
 	TagName string `json:"tagName" validate:"required"`
 	Path    string `json:"path" validate:"required"`
 	Name    string `json:"name" validate:"required"`

agent/app/dto/monitor.go

@@ -4,25 +4,78 @@ import "time"
 
 type MonitorSearch struct {
 	Param     string    `json:"param" validate:"required,oneof=all cpu memory load io network"`
-	Info      string    `json:"info"`
+	IO        string    `json:"io"`
+	Network   string    `json:"network"`
 	StartTime time.Time `json:"startTime"`
 	EndTime   time.Time `json:"endTime"`
 }
 
 type MonitorData struct {
-	Param string        `json:"param" validate:"required,oneof=cpu memory load io network"`
+	Param string        `json:"param"`
 	Date  []time.Time   `json:"date"`
 	Value []interface{} `json:"value"`
 }
 
+type Process struct {
+	Name    string  `json:"name"`
+	Pid     int32   `json:"pid"`
+	Percent float64 `json:"percent"`
+	Memory  uint64  `json:"memory"`
+	Cmd     string  `json:"cmd"`
+	User    string  `json:"user"`
+}
+
 type MonitorSetting struct {
 	MonitorStatus    string `json:"monitorStatus"`
 	MonitorStoreDays string `json:"monitorStoreDays"`
 	MonitorInterval  string `json:"monitorInterval"`
 	DefaultNetwork   string `json:"defaultNetwork"`
+	DefaultIO        string `json:"defaultIO"`
 }
 
 type MonitorSettingUpdate struct {
-	Key   string `json:"key" validate:"required,oneof=MonitorStatus MonitorStoreDays MonitorInterval DefaultNetwork"`
+	Key   string `json:"key" validate:"required,oneof=MonitorStatus MonitorStoreDays MonitorInterval DefaultNetwork DefaultIO"`
 	Value string `json:"value"`
 }
+
+type MonitorGPUOptions struct {
+	GPUType   string         `json:"gpuType"`
+	ChartHide []GPUChartHide `json:"chartHide"`
+	Options   []string       `json:"options"`
+}
+type GPUChartHide struct {
+	ProductName string `json:"productName"`
+	Process     bool   `json:"process"`
+	GPU         bool   `json:"gpu"`
+	Memory      bool   `json:"memory"`
+	Power       bool   `json:"power"`
+	Temperature bool   `json:"temperature"`
+	Speed       bool   `json:"speed"`
+}
+type MonitorGPUSearch struct {
+	ProductName string    `json:"productName"`
+	StartTime   time.Time `json:"startTime"`
+	EndTime     time.Time `json:"endTime"`
+}
+type MonitorGPUData struct {
+	Date             []time.Time `json:"date"`
+	GPUValue         []float64   `json:"gpuValue"`
+	TemperatureValue []float64   `json:"temperatureValue"`
+	PowerTotal       []float64   `json:"powerTotal"`
+	PowerUsed        []float64   `json:"powerUsed"`
+	PowerPercent     []float64   `json:"powerPercent"`
+	MemoryTotal      []float64   `json:"memoryTotal"`
+	MemoryUsed       []float64   `json:"memoryUsed"`
+	MemoryPercent    []float64   `json:"memoryPercent"`
+	SpeedValue       []int       `json:"speedValue"`
+
+	ProcessCount []int          `json:"processCount"`
+	GPUProcesses [][]GPUProcess `json:"gpuProcesses"`
+}
+
+type GPUProcess struct {
+	Pid         string `json:"pid"`
+	Type        string `json:"type"`
+	ProcessName string `json:"processName"`
+	UsedMemory  string `json:"usedMemory"`
+}

agent/app/dto/nginx.go

@@ -73,12 +73,13 @@ type NginxUpstream struct {
 }
 
 type NginxUpstreamServer struct {
-	Server      string `json:"server"`
-	Weight      int    `json:"weight"`
-	FailTimeout string `json:"failTimeout"`
-	MaxFails    int    `json:"maxFails"`
-	MaxConns    int    `json:"maxConns"`
-	Flag        string `json:"flag"`
+	Server          string `json:"server"`
+	Weight          int    `json:"weight"`
+	FailTimeout     int    `json:"failTimeout"`
+	FailTimeoutUnit string `json:"failTimeoutUnit"`
+	MaxFails        int    `json:"maxFails"`
+	MaxConns        int    `json:"maxConns"`
+	Flag            string `json:"flag"`
 }
 
 var LBAlgorithms = map[string]struct{}{"ip_hash": {}, "least_conn": {}}

agent/app/dto/request/app.go

@@ -22,7 +22,16 @@ type AppInstallCreate struct {
 	Name        string                 `json:"name" validate:"required"`
 	Services    map[string]string      `json:"services"`
 	TaskID      string                 `json:"taskID"`
+
 	AppContainerConfig
+	NodePushConfig
+}
+
+type NodePushConfig struct {
+	Nodes    []string `json:"nodes"`
+	PushNode bool     `json:"pushNode"`
+	AppKey   string   `json:"appKey"`
+	Version  string   `json:"version"`
 }
 
 type AppContainerConfig struct {

agent/app/dto/request/disk.go

@@ -13,6 +13,7 @@ type DiskMountRequest struct {
 	MountPoint string `json:"mountPoint" validate:"required"`
 	Filesystem string `json:"filesystem" validate:"required,oneof=ext4 xfs"`
 	AutoMount  bool   `json:"autoMount"`
+	NoFail     bool   `json:"noFail"`
 }
 
 type DiskUnmountRequest struct {

agent/app/dto/request/file.go

@@ -13,7 +13,6 @@ type FileContentReq struct {
 	Path     string `json:"path" validate:"required"`
 	IsDetail bool   `json:"isDetail"`
 }
-
 type SearchUploadWithPage struct {
 	dto.PageInfo
 	Path string `json:"path" validate:"required"`

agent/app/dto/request/nginx.go

@@ -130,3 +130,8 @@ type NginxModuleUpdate struct {
 type NginxOperateReq struct {
 	Operate string `json:"operate" validate:"required,oneof=enable disable"`
 }
+
+type NginxDefaultHTTPSUpdate struct {
+	Operate            string `json:"operate" validate:"required,oneof=enable disable"`
+	SSLRejectHandshake bool   `json:"sslRejectHandshake"`
+}

agent/app/dto/request/runtime.go

@@ -32,6 +32,7 @@ type NodeConfig struct {
 	ExposedPorts []ExposedPort `json:"exposedPorts"`
 	Environments []Environment `json:"environments"`
 	Volumes      []Volume      `json:"volumes"`
+	ExtraHosts   []ExtraHost   `json:"extraHosts"`
 }
 
 type Environment struct {
@@ -49,6 +50,11 @@ type ExposedPort struct {
 	HostIP        string `json:"hostIP"`
 }
 
+type ExtraHost struct {
+	Hostname string `json:"hostname"`
+	IP       string `json:"ip"`
+}
+
 type RuntimeDelete struct {
 	ID          uint `json:"id"`
 	ForceDelete bool `json:"forceDelete"`
@@ -135,6 +141,7 @@ type PHPContainerConfig struct {
 	ExposedPorts  []ExposedPort `json:"exposedPorts"`
 	Environments  []Environment `json:"environments"`
 	Volumes       []Volume      `json:"volumes"`
+	ExtraHosts    []ExtraHost   `json:"extraHosts"`
 }
 
 type RuntimeRemark struct {

agent/app/dto/request/tensorrt_llm.go

@@ -14,6 +14,8 @@ type TensorRTLLMCreate struct {
 	ModelDir      string `json:"modelDir" validate:"required"`
 	Image         string `json:"image"  validate:"required"`
 	Command       string `json:"command" validate:"required"`
+	ModelType     string `json:"modelType"`
+	ModelSpeedup  bool   `json:"modelSpeedup"`
 	DockerConfig
 }
 

agent/app/dto/request/website.go

@@ -38,6 +38,22 @@ type WebsiteCreate struct {
 	FtpConfig
 	DataBaseConfig
 	SSLConfig
+	StreamConfig
+}
+
+type StreamConfig struct {
+	StreamPorts string `json:"streamPorts"`
+	Name        string `json:"name"`
+	Algorithm   string `json:"algorithm"`
+	UDP         bool   `json:"udp"`
+
+	Servers []dto.NginxUpstreamServer `json:"servers"`
+}
+
+type StreamUpdate struct {
+	WebsiteID uint `json:"websiteID" validate:"required"`
+
+	StreamConfig
 }
 
 type WebsiteOptionReq struct {
@@ -109,6 +125,30 @@ type BatchWebsiteOp struct {
 	TaskID  string `json:"taskID" validate:"required"`
 }
 
+type BatchWebsiteGroup struct {
+	IDs     []uint `json:"ids" validate:"required"`
+	GroupID uint   `json:"groupID" validate:"required"`
+}
+
+type BatchWebsiteHttps struct {
+	IDs                   []uint   `json:"ids" validate:"required"`
+	TaskID                string   `json:"taskID" validate:"required"`
+	WebsiteSSLID          uint     `json:"websiteSSLId"`
+	Type                  string   `json:"type"  validate:"oneof=existed auto manual"`
+	PrivateKey            string   `json:"privateKey"`
+	Certificate           string   `json:"certificate"`
+	PrivateKeyPath        string   `json:"privateKeyPath"`
+	CertificatePath       string   `json:"certificatePath"`
+	ImportType            string   `json:"importType"`
+	HttpConfig            string   `json:"httpConfig"  validate:"oneof=HTTPSOnly HTTPAlso HTTPToHTTPS"`
+	SSLProtocol           []string `json:"SSLProtocol"`
+	Algorithm             string   `json:"algorithm"`
+	Hsts                  bool     `json:"hsts"`
+	HstsIncludeSubDomains bool     `json:"hstsIncludeSubDomains"`
+	HttpsPorts            []int    `json:"httpsPorts"`
+	Http3                 bool     `json:"http3"`
+}
+
 type WebsiteRedirectUpdate struct {
 	WebsiteID uint   `json:"websiteId" validate:"required"`
 	Key       string `json:"key" validate:"required"`
@@ -271,6 +311,7 @@ type WebsiteHtmlReq struct {
 type WebsiteHtmlUpdate struct {
 	Type    string `json:"type" validate:"required"`
 	Content string `json:"content" validate:"required"`
+	Sync    bool   `json:"sync"`
 }
 
 type WebsiteLBCreate struct {

agent/app/dto/request/website_ssl.go

@@ -31,6 +31,7 @@ type WebsiteSSLCreate struct {
 	Shell         string `json:"shell"`
 	PushNode      bool   `json:"pushNode"`
 	Nodes         string `json:"nodes"`
+	IsIp          bool   `json:"isIp"`
 }
 
 type WebsiteDNSReq struct {

agent/app/dto/response/app.go

@@ -29,22 +29,18 @@ type AppDTO struct {
 }
 
 type AppItem struct {
-	Name        string   `json:"name"`
-	Key         string   `json:"key"`
-	ID          uint     `json:"id"`
-	Description string   `json:"description"`
-	Icon        string   `json:"icon"`
-	Type        string   `json:"type"`
-	Status      string   `json:"status"`
-	Resource    string   `json:"resource"`
-	Installed   bool     `json:"installed"`
-	Versions    []string `json:"versions"`
-	Limit       int      `json:"limit"`
-	Tags        []TagDTO `json:"tags"`
-	Github      string   `json:"github"`
-	Website     string   `json:"website"`
-	GpuSupport  bool     `json:"gpuSupport"`
-	Recommend   int      `json:"recommend"`
+	Name                string   `json:"name"`
+	Key                 string   `json:"key"`
+	ID                  uint     `json:"id"`
+	Description         string   `json:"description"`
+	Status              string   `json:"status"`
+	Installed           bool     `json:"installed"`
+	Limit               int      `json:"limit"`
+	Tags                []string `json:"tags"`
+	GpuSupport          bool     `json:"gpuSupport"`
+	Recommend           int      `json:"recommend"`
+	Type                string   `json:"type"`
+	BatchInstallSupport bool     `json:"batchInstallSupport"`
 }
 
 type TagDTO struct {
@@ -80,6 +76,10 @@ type AppDetailDTO struct {
 	GpuSupport     bool        `json:"gpuSupport"`
 }
 
+type AppDetailSimpleDTO struct {
+	ID uint `json:"id"`
+}
+
 type IgnoredApp struct {
 	Icon     string `json:"icon"`
 	Name     string `json:"name"`
@@ -128,6 +128,9 @@ type AppInstallDTO struct {
 	Favorite      bool      `json:"favorite"`
 	App           AppDetail `json:"app"`
 	Container     string    `json:"container"`
+	IsEdit        bool      `json:"isEdit"`
+	LinkDB        bool      `json:"linkDB"`
+	ServiceName   string    `json:"serviceName"`
 }
 
 type AppInstallInfo struct {
@@ -139,6 +142,8 @@ type AppInstallInfo struct {
 	HttpPort    int    `json:"HttpPort"`
 	Container   string `json:"container"`
 	ComposePath string `json:"composePath"`
+	AppKey      string `json:"appKey"`
+	AppPorts    []int  `json:"appPorts"`
 
 	Env map[string]interface{} `json:"env"`
 }
@@ -176,6 +181,7 @@ type AppParam struct {
 }
 
 type AppConfig struct {
-	Params []AppParam `json:"params"`
+	Params     []AppParam `json:"params"`
+	RawCompose string     `json:"rawCompose"`
 	request.AppContainerConfig
 }

agent/app/dto/response/disk.go

@@ -24,7 +24,7 @@ type DiskBasicInfo struct {
 type CompleteDiskInfo struct {
 	Disks              []DiskInfo      `json:"disks"`
 	UnpartitionedDisks []DiskBasicInfo `json:"unpartitionedDisks"`
-	SystemDisk         *DiskInfo       `json:"systemDisk"`
+	SystemDisks        []DiskInfo      `json:"systemDisks"`
 	TotalDisks         int             `json:"totalDisks"`
 	TotalCapacity      int64           `json:"totalCapacity"`
 }

agent/app/dto/response/nginx.go

@@ -82,5 +82,6 @@ type NginxBuildConfig struct {
 }
 
 type NginxConfigRes struct {
-	Https bool `json:"https"`
+	Https              bool `json:"https"`
+	SSLRejectHandshake bool `json:"sslRejectHandshake"`
 }

agent/app/dto/response/runtime.go

@@ -28,6 +28,7 @@ type RuntimeDTO struct {
 	ExposedPorts    []request.ExposedPort  `json:"exposedPorts"`
 	Environments    []request.Environment  `json:"environments"`
 	Volumes         []request.Volume       `json:"volumes"`
+	ExtraHosts      []request.ExtraHost    `json:"extraHosts"`
 	ContainerStatus string                 `json:"containerStatus"`
 	Container       string                 `json:"container"`
 	Remark          string                 `json:"remark"`

agent/app/dto/response/website.go

@@ -3,6 +3,7 @@ package response
 import (
 	"time"
 
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 )
 
@@ -16,6 +17,10 @@ type WebsiteDTO struct {
 	RuntimeType   string `json:"runtimeType"`
 	SiteDir       string `json:"siteDir"`
 	OpenBaseDir   bool   `json:"openBaseDir"`
+	Algorithm     string `json:"algorithm"`
+	UDP           bool   `json:"udp"`
+
+	Servers []dto.NginxUpstreamServer `json:"servers"`
 }
 
 type WebsiteRes struct {

agent/app/dto/setting.go

@@ -10,6 +10,7 @@ type SettingInfo struct {
 	NtpSite   string `json:"ntpSite"`
 
 	DefaultNetwork string `json:"defaultNetwork"`
+	DefaultIO      string `json:"defaultIO"`
 	LastCleanTime  string `json:"lastCleanTime"`
 	LastCleanSize  string `json:"lastCleanSize"`
 	LastCleanData  string `json:"lastCleanData"`
@@ -36,6 +37,7 @@ type SyncTime struct {
 
 type CleanData struct {
 	SystemClean    []CleanTree `json:"systemClean"`
+	BackupClean    []CleanTree `json:"backupClean"`
 	UploadClean    []CleanTree `json:"uploadClean"`
 	DownloadClean  []CleanTree `json:"downloadClean"`
 	SystemLogClean []CleanTree `json:"systemLogClean"`
@@ -61,6 +63,10 @@ type Clean struct {
 	Size     uint64 `json:"size"`
 }
 
+type SSHDefaultConn struct {
+	WithReset   bool   `json:"withReset"`
+	DefaultConn string `json:"defaultConn"`
+}
 type SSHConnData struct {
 	Addr       string `json:"addr" validate:"required"`
 	Port       uint   `json:"port" validate:"required,number,max=65535,min=1"`
@@ -80,3 +86,11 @@ type SystemProxy struct {
 	User     string `json:"user"`
 	Password string `json:"password"`
 }
+
+type CommonDescription struct {
+	ID          string `json:"id" validate:"required"`
+	Type        string `json:"type" validate:"required"`
+	DetailType  string `json:"detailType"`
+	IsPinned    bool   `json:"isPinned"`
+	Description string `json:"description"`
+}

agent/app/dto/snapshot.go

@@ -52,6 +52,7 @@ type DataTree struct {
 	Label     string `json:"label"`
 	Key       string `json:"key"`
 	Name      string `json:"name"`
+	IsLocal   bool   `json:"isLocal"`
 	Size      uint64 `json:"size"`
 	IsCheck   bool   `json:"isCheck"`
 	IsDisable bool   `json:"isDisable"`

agent/app/model/app.go

@@ -34,6 +34,7 @@ type App struct {
 	MemoryRequired       int     `json:"memoryRequired"`
 	GpuSupport           bool    `json:"gpuSupport"`
 	RequiredPanelVersion float64 `json:"requiredPanelVersion"`
+	BatchInstallSupport  bool    `json:"batchInstallSupport" yaml:"batchInstallSupport"`
 
 	Details []AppDetail `json:"-" gorm:"-:migration"`
 	TagsKey []string    `json:"tags" yaml:"tags" gorm:"-"`

agent/app/model/cronjob.go

@@ -43,6 +43,8 @@ type Cronjob struct {
 	EntryIDs    string       `json:"entryIDs"`
 	Records     []JobRecords `json:"records"`
 	Secret      string       `json:"secret"`
+
+	Config string `json:"config"`
 }
 
 type JobRecords struct {

agent/app/model/database.go

@@ -9,6 +9,7 @@ type Database struct {
 	From         string `json:"from" gorm:"not null"`
 	Address      string `json:"address" gorm:"not null"`
 	Port         uint   `json:"port" gorm:"not null"`
+	InitialDB    string `json:"initialDB"`
 	Username     string `json:"username"`
 	Password     string `json:"password"`
 

agent/app/model/database_mysql.go

@@ -6,6 +6,7 @@ type DatabaseMysql struct {
 	From        string `json:"from" gorm:"not null;default:local"`
 	MysqlName   string `json:"mysqlName" gorm:"not null"`
 	Format      string `json:"format" gorm:"not null"`
+	Collation   string `json:"collation"`
 	Username    string `json:"username" gorm:"not null"`
 	Password    string `json:"password" gorm:"not null"`
 	Permission  string `json:"permission" gorm:"not null"`

agent/app/model/firewall.go

@@ -3,20 +3,16 @@ package model
 type Firewall struct {
 	BaseModel
 
-	Type        string `gorm:"not null" json:"type"`
-	Port        string `gorm:"not null" json:"port"`
-	Protocol    string `gorm:"not null" json:"protocol"`
-	Address     string `gorm:"not null" json:"address"`
+	Type    string `json:"type"`
+	Port    string `json:"port"`    // Deprecated
+	Address string `json:"address"` // Deprecated
+
+	Chain       string `json:"chain"`
+	Protocol    string `json:"protocol"`
+	SrcIP       string `json:"srcIP"`
+	SrcPort     string `json:"srcPort"`
+	DstIP       string `json:"dstIP"`
+	DstPort     string `json:"dstPort"`
 	Strategy    string `gorm:"not null" json:"strategy"`
-	Description string `gorm:"not null" json:"description"`
-}
-
-type Forward struct {
-	BaseModel
-
-	Protocol   string `gorm:"not null" json:"protocol"`
-	Port       string `gorm:"not null" json:"port"`
-	TargetIP   string `gorm:"not null" json:"targetIP"`
-	TargetPort string `gorm:"not null" json:"targetPort"`
-	Interface  string `json:"interface"`
+	Description string `json:"description"`
 }

agent/app/model/monitor.go

@@ -2,14 +2,18 @@ package model
 
 type MonitorBase struct {
 	BaseModel
-	Cpu float64 `json:"cpu"`
+	Cpu         float64     `json:"cpu"`
+	TopCPU      string      `json:"topCPU"`
+	TopCPUItems interface{} `gorm:"-" json:"topCPUItems"`
+
+	Memory      float64     `json:"memory"`
+	TopMem      string      `json:"topMem"`
+	TopMemItems interface{} `gorm:"-" json:"topMemItems"`
 
 	LoadUsage float64 `json:"loadUsage"`
 	CpuLoad1  float64 `json:"cpuLoad1"`
 	CpuLoad5  float64 `json:"cpuLoad5"`
 	CpuLoad15 float64 `json:"cpuLoad15"`
-
-	Memory float64 `json:"memory"`
 }
 
 type MonitorIO struct {
@@ -27,3 +31,16 @@ type MonitorNetwork struct {
 	Up   float64 `json:"up"`
 	Down float64 `json:"down"`
 }
+
+type MonitorGPU struct {
+	BaseModel
+	ProductName   string  `json:"productName"`
+	GPUUtil       float64 `json:"gpuUtil"`
+	Temperature   float64 `json:"temperature"`
+	PowerDraw     float64 `json:"powerDraw"`
+	MaxPowerLimit float64 `json:"maxPowerLimit"`
+	MemUsed       float64 `json:"memUsed"`
+	MemTotal      float64 `json:"memTotal"`
+	FanSpeed      int     `json:"fanSpeed"`
+	Processes     string  `json:"processes"`
+}

agent/app/model/setting.go

@@ -7,6 +7,14 @@ type Setting struct {
 	About string `json:"about"`
 }
 
+type CommonDescription struct {
+	ID          string `json:"id"`
+	Type        string `json:"type"`
+	DetailType  string `json:"detailType"`
+	IsPinned    bool   `json:"isPinned"`
+	Description string `json:"description"`
+}
+
 type NodeInfo struct {
 	Scope     string `json:"scope"`
 	BaseDir   string `json:"baseDir"`

agent/app/model/tensorrt_llm.go

@@ -6,8 +6,9 @@ type TensorRTLLM struct {
 	DockerCompose string `json:"dockerCompose"`
 	ContainerName string `json:"containerName"`
 	Message       string `json:"message"`
-	//Port          int    `json:"port"`
-	Status string `json:"status"`
-	Env    string `json:"env"`
-	TaskID string `json:"taskID"`
+	Status        string `json:"status"`
+	Env           string `json:"env"`
+	TaskID        string `json:"taskID"`
+	ModelType     string `json:"modelType"`
+	ModelSpeedup  bool   `json:"modelSpeedup"`
 }

agent/app/model/website.go

@@ -37,6 +37,8 @@ type Website struct {
 
 	Favorite bool `json:"favorite"`
 
+	StreamPorts string `json:"streamPorts"`
+
 	Domains    []WebsiteDomain `json:"domains" gorm:"-:migration"`
 	WebsiteSSL WebsiteSSL      `json:"webSiteSSL" gorm:"-:migration"`
 }

agent/app/model/website_ssl.go

@@ -41,6 +41,7 @@ type WebsiteSSL struct {
 	PushNode       bool      `json:"pushNode"`
 	PrivateKeyPath string    `json:"privateKeyPath"`
 	CertPath       string    `json:"certPath"`
+	IsIp           bool      `json:"isIP"`
 
 	AcmeAccount WebsiteAcmeAccount `json:"acmeAccount" gorm:"-:migration"`
 	DnsAccount  WebsiteDnsAccount  `json:"dnsAccount" gorm:"-:migration"`

agent/app/repo/app.go

@@ -27,14 +27,13 @@ type IAppRepo interface {
 	GetFirst(opts ...DBOption) (model.App, error)
 	GetBy(opts ...DBOption) ([]model.App, error)
 	BatchCreate(ctx context.Context, apps []model.App) error
-	GetByKey(ctx context.Context, key string) (model.App, error)
 	Create(ctx context.Context, app *model.App) error
 	Save(ctx context.Context, app *model.App) error
 	BatchDelete(ctx context.Context, apps []model.App) error
 	DeleteByIDs(ctx context.Context, ids []uint) error
 	DeleteBy(opts ...DBOption) error
 
-	GetTopRecomment() ([]string, error)
+	GetTopRecommend() ([]string, error)
 }
 
 func NewIAppRepo() IAppRepo {
@@ -125,7 +124,7 @@ func (a AppRepo) GetBy(opts ...DBOption) ([]model.App, error) {
 	return apps, nil
 }
 
-func (a AppRepo) GetTopRecomment() ([]string, error) {
+func (a AppRepo) GetTopRecommend() ([]string, error) {
 	var (
 		apps  []model.App
 		names []string
@@ -144,14 +143,6 @@ func (a AppRepo) BatchCreate(ctx context.Context, apps []model.App) error {
 	return getTx(ctx).Omit(clause.Associations).Create(&apps).Error
 }
 
-func (a AppRepo) GetByKey(ctx context.Context, key string) (model.App, error) {
-	var app model.App
-	if err := getTx(ctx).Where("key = ?", key).First(&app).Error; err != nil {
-		return app, err
-	}
-	return app, nil
-}
-
 func (a AppRepo) Create(ctx context.Context, app *model.App) error {
 	return getTx(ctx).Omit(clause.Associations).Create(app).Error
 }

agent/app/repo/backup.go

@@ -20,6 +20,7 @@ type IBackupRepo interface {
 	WithByPublic(isPublic bool) DBOption
 
 	ListRecord(opts ...DBOption) ([]model.BackupRecord, error)
+	GetRecord(opts ...DBOption) (*model.BackupRecord, error)
 	PageRecord(page, size int, opts ...DBOption) (int64, []model.BackupRecord, error)
 	CreateRecord(record *model.BackupRecord) error
 	DeleteRecord(ctx context.Context, opts ...DBOption) error
@@ -160,7 +161,7 @@ func (u *BackupRepo) WithByCronID(cronjobID uint) DBOption {
 }
 
 func (u *BackupRepo) GetRecord(opts ...DBOption) (*model.BackupRecord, error) {
-	var record *model.BackupRecord
+	record := &model.BackupRecord{}
 	db := global.DB.Model(&model.BackupRecord{})
 	for _, opt := range opts {
 		db = opt(db)

agent/app/repo/common.go

@@ -77,6 +77,11 @@ func WithByType(tp string) DBOption {
 		return g.Where("`type` = ?", tp)
 	}
 }
+func WithByDetailType(tp string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("`detail_type` = ?", tp)
+	}
+}
 
 func WithTypes(types []string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {

agent/app/repo/cronjob.go

@@ -173,7 +173,7 @@ func (u *CronjobRepo) AddFailedRecord(cronjobID uint, message string) {
 	var record model.JobRecords
 	record.StartTime = time.Now()
 	record.CronjobID = cronjobID
-	record.Status = constant.StatusFailed
+	record.Status = constant.StatusUnexecuted
 	record.Message = message
 	if err := global.DB.Create(&record).Error; err != nil {
 		global.LOG.Errorf("create record status failed, err: %v", err)

agent/app/repo/host.go

@@ -4,16 +4,16 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
+	"gorm.io/gorm"
 )
 
 type HostRepo struct{}
 
 type IHostRepo interface {
 	GetFirewallRecord(opts ...DBOption) (model.Firewall, error)
-	ListFirewallRecord() ([]model.Firewall, error)
+	ListFirewallRecord(opts ...DBOption) ([]model.Firewall, error)
 	SaveFirewallRecord(firewall *model.Firewall) error
 	DeleteFirewallRecordByID(id uint) error
-	DeleteFirewallRecord(fType, port, protocol, address, strategy string) error
 
 	SyncCert(data []model.RootCert) error
 	GetCert(opts ...DBOption) (model.RootCert, error)
@@ -22,6 +22,8 @@ type IHostRepo interface {
 	SaveCert(cert *model.RootCert) error
 	UpdateCert(id uint, vars map[string]interface{}) error
 	DeleteCert(opts ...DBOption) error
+
+	WithByChain(chain string) DBOption
 }
 
 func NewIHostRepo() IHostRepo {
@@ -38,12 +40,16 @@ func (h *HostRepo) GetFirewallRecord(opts ...DBOption) (model.Firewall, error) {
 	return firewall, err
 }
 
-func (h *HostRepo) ListFirewallRecord() ([]model.Firewall, error) {
-	var datas []model.Firewall
-	if err := global.DB.Find(&datas).Error; err != nil {
-		return datas, nil
+func (h *HostRepo) ListFirewallRecord(opts ...DBOption) ([]model.Firewall, error) {
+	var firewalls []model.Firewall
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
 	}
-	return datas, nil
+	if err := global.DB.Find(&firewalls).Error; err != nil {
+		return firewalls, nil
+	}
+	return firewalls, nil
 }
 
 func (h *HostRepo) SaveFirewallRecord(firewall *model.Firewall) error {
@@ -51,16 +57,27 @@ func (h *HostRepo) SaveFirewallRecord(firewall *model.Firewall) error {
 		return global.DB.Save(firewall).Error
 	}
 	var data model.Firewall
-	if firewall.Type == "port" {
-		_ = global.DB.Where("type = ? AND port = ? AND protocol = ? AND address = ? AND strategy = ?", "port", firewall.Port, firewall.Protocol, firewall.Address, firewall.Strategy).First(&data)
-		if data.ID != 0 {
-			firewall.ID = data.ID
-		}
-	} else {
-		_ = global.DB.Where("type = ? AND address = ? AND strategy = ?", "address", firewall.Address, firewall.Strategy).First(&data)
-		if data.ID != 0 {
-			firewall.ID = data.ID
-		}
+	switch firewall.Type {
+	case "port":
+		_ = global.DB.Where("type = ? AND dst_port = ? AND protocol = ? AND src_ip = ? AND strategy = ?", "port",
+			firewall.DstPort,
+			firewall.Protocol,
+			firewall.SrcIP,
+			firewall.Strategy,
+		).First(&data).Error
+	case "ip":
+		_ = global.DB.Where("type = ? AND src_ip = ? AND strategy = ?", "address", firewall.SrcIP, firewall.Strategy).First(&data)
+	default:
+		_ = global.DB.Where("type = ? AND chain = ? AND src_port = ? AND dst_port = ? AND protocol = ? AND src_ip = ? AND dst_ip = ? AND strategy = ?",
+			firewall.Type,
+			firewall.Chain,
+			firewall.SrcPort,
+			firewall.DstPort,
+			firewall.Protocol,
+			firewall.SrcIP,
+			firewall.DstIP,
+			firewall.Strategy,
+		).First(&data).Error
 	}
 	return global.DB.Save(firewall).Error
 }
@@ -69,10 +86,6 @@ func (h *HostRepo) DeleteFirewallRecordByID(id uint) error {
 	return global.DB.Where("id = ?", id).Delete(&model.Firewall{}).Error
 }
 
-func (h *HostRepo) DeleteFirewallRecord(fType, port, protocol, address, strategy string) error {
-	return global.DB.Where("type = ? AND port = ? AND protocol = ? AND address = ? AND strategy = ?", fType, port, protocol, address, strategy).Delete(&model.Firewall{}).Error
-}
-
 func (u *HostRepo) GetCert(opts ...DBOption) (model.RootCert, error) {
 	var cert model.RootCert
 	db := global.DB
@@ -151,3 +164,9 @@ func (u *HostRepo) SyncCert(data []model.RootCert) error {
 	tx.Commit()
 	return nil
 }
+
+func (u *HostRepo) WithByChain(chain string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("chain = ?", chain)
+	}
+}

agent/app/repo/monitor.go

@@ -5,21 +5,27 @@ import (
 
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"gorm.io/gorm"
 )
 
 type MonitorRepo struct{}
 
 type IMonitorRepo interface {
 	GetBase(opts ...DBOption) ([]model.MonitorBase, error)
+	GetGPU(opts ...DBOption) ([]model.MonitorGPU, error)
 	GetIO(opts ...DBOption) ([]model.MonitorIO, error)
 	GetNetwork(opts ...DBOption) ([]model.MonitorNetwork, error)
 
 	CreateMonitorBase(model model.MonitorBase) error
+	BatchCreateMonitorGPU(list []model.MonitorGPU) error
 	BatchCreateMonitorIO(ioList []model.MonitorIO) error
 	BatchCreateMonitorNet(ioList []model.MonitorNetwork) error
 	DelMonitorBase(timeForDelete time.Time) error
+	DelMonitorGPU(timeForDelete time.Time) error
 	DelMonitorIO(timeForDelete time.Time) error
 	DelMonitorNet(timeForDelete time.Time) error
+
+	WithByProductName(name string) DBOption
 }
 
 func NewIMonitorRepo() IMonitorRepo {
@@ -53,10 +59,22 @@ func (u *MonitorRepo) GetNetwork(opts ...DBOption) ([]model.MonitorNetwork, erro
 	err := db.Find(&data).Error
 	return data, err
 }
+func (u *MonitorRepo) GetGPU(opts ...DBOption) ([]model.MonitorGPU, error) {
+	var data []model.MonitorGPU
+	db := global.GPUMonitorDB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.Find(&data).Error
+	return data, err
+}
 
 func (u *MonitorRepo) CreateMonitorBase(model model.MonitorBase) error {
 	return global.MonitorDB.Create(&model).Error
 }
+func (s *MonitorRepo) BatchCreateMonitorGPU(list []model.MonitorGPU) error {
+	return global.GPUMonitorDB.CreateInBatches(&list, len(list)).Error
+}
 func (u *MonitorRepo) BatchCreateMonitorIO(ioList []model.MonitorIO) error {
 	return global.MonitorDB.CreateInBatches(ioList, len(ioList)).Error
 }
@@ -72,3 +90,12 @@ func (u *MonitorRepo) DelMonitorIO(timeForDelete time.Time) error {
 func (u *MonitorRepo) DelMonitorNet(timeForDelete time.Time) error {
 	return global.MonitorDB.Where("created_at < ?", timeForDelete).Delete(&model.MonitorNetwork{}).Error
 }
+func (s *MonitorRepo) DelMonitorGPU(timeForDelete time.Time) error {
+	return global.GPUMonitorDB.Where("created_at < ?", timeForDelete).Delete(&model.MonitorGPU{}).Error
+}
+
+func (s *MonitorRepo) WithByProductName(name string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("product_name = ?", name)
+	}
+}

agent/app/repo/setting.go

@@ -2,7 +2,6 @@ package repo
 
 import (
 	"errors"
-	"time"
 
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/global"
@@ -19,13 +18,14 @@ type ISettingRepo interface {
 	Update(key, value string) error
 	WithByKey(key string) DBOption
 
-	CreateMonitorBase(model model.MonitorBase) error
-	BatchCreateMonitorIO(ioList []model.MonitorIO) error
-	BatchCreateMonitorNet(ioList []model.MonitorNetwork) error
-	DelMonitorBase(timeForDelete time.Time) error
-	DelMonitorIO(timeForDelete time.Time) error
-	DelMonitorNet(timeForDelete time.Time) error
 	UpdateOrCreate(key, value string) error
+
+	GetDescription(opts ...DBOption) (model.CommonDescription, error)
+	GetDescriptionList(opts ...DBOption) ([]model.CommonDescription, error)
+	CreateDescription(data *model.CommonDescription) error
+	UpdateDescription(id string, val map[string]interface{}) error
+	DelDescription(id string) error
+	WithByDescriptionID(id string) DBOption
 }
 
 func NewISettingRepo() ISettingRepo {
@@ -78,25 +78,6 @@ func (s *SettingRepo) Update(key, value string) error {
 	return global.DB.Model(&model.Setting{}).Where("key = ?", key).Updates(map[string]interface{}{"value": value}).Error
 }
 
-func (s *SettingRepo) CreateMonitorBase(model model.MonitorBase) error {
-	return global.MonitorDB.Create(&model).Error
-}
-func (s *SettingRepo) BatchCreateMonitorIO(ioList []model.MonitorIO) error {
-	return global.MonitorDB.CreateInBatches(ioList, len(ioList)).Error
-}
-func (s *SettingRepo) BatchCreateMonitorNet(ioList []model.MonitorNetwork) error {
-	return global.MonitorDB.CreateInBatches(ioList, len(ioList)).Error
-}
-func (s *SettingRepo) DelMonitorBase(timeForDelete time.Time) error {
-	return global.MonitorDB.Where("created_at < ?", timeForDelete).Delete(&model.MonitorBase{}).Error
-}
-func (s *SettingRepo) DelMonitorIO(timeForDelete time.Time) error {
-	return global.MonitorDB.Where("created_at < ?", timeForDelete).Delete(&model.MonitorIO{}).Error
-}
-func (s *SettingRepo) DelMonitorNet(timeForDelete time.Time) error {
-	return global.MonitorDB.Where("created_at < ?", timeForDelete).Delete(&model.MonitorNetwork{}).Error
-}
-
 func (s *SettingRepo) UpdateOrCreate(key, value string) error {
 	var setting model.Setting
 	result := global.DB.Where("key = ?", key).First(&setting)
@@ -108,3 +89,36 @@ func (s *SettingRepo) UpdateOrCreate(key, value string) error {
 	}
 	return global.DB.Model(&setting).UpdateColumn("value", value).Error
 }
+
+func (s *SettingRepo) GetDescriptionList(opts ...DBOption) ([]model.CommonDescription, error) {
+	var lists []model.CommonDescription
+	db := global.DB.Model(&model.CommonDescription{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.Find(&lists).Error
+	return lists, err
+}
+func (s *SettingRepo) GetDescription(opts ...DBOption) (model.CommonDescription, error) {
+	var data model.CommonDescription
+	db := global.DB.Model(&model.CommonDescription{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.First(&data).Error
+	return data, err
+}
+func (s *SettingRepo) CreateDescription(data *model.CommonDescription) error {
+	return global.DB.Create(data).Error
+}
+func (s *SettingRepo) UpdateDescription(id string, val map[string]interface{}) error {
+	return global.DB.Model(&model.CommonDescription{}).Where("id = ?", id).Updates(val).Error
+}
+func (s *SettingRepo) DelDescription(id string) error {
+	return global.DB.Where("id = ?", id).Delete(&model.CommonDescription{}).Error
+}
+func (s *SettingRepo) WithByDescriptionID(id string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("id = ?", id)
+	}
+}

agent/app/service/ai.go

@@ -134,9 +134,8 @@ func (u *AIToolService) Close(name string) error {
 	if err != nil {
 		return err
 	}
-	stdout, err := cmd.RunDefaultWithStdoutBashCf("docker exec %s ollama stop %s", containerName, name)
-	if err != nil {
-		return fmt.Errorf("handle ollama stop %s failed, stdout: %s, err: %v", name, stdout, err)
+	if err := cmd.RunDefaultBashCf("docker exec %s ollama stop %s", containerName, name); err != nil {
+		return fmt.Errorf("handle ollama stop %s failed, %v", name, err)
 	}
 	return nil
 }
@@ -193,9 +192,8 @@ func (u *AIToolService) Delete(req dto.ForceDelete) error {
 	}
 	for _, item := range ollamaList {
 		if item.Status != constant.StatusDeleted {
-			stdout, err := cmd.RunDefaultWithStdoutBashCf("docker exec %s ollama rm %s", containerName, item.Name)
-			if err != nil && !req.ForceDelete {
-				return fmt.Errorf("handle ollama rm %s failed, stdout: %s, err: %v", item.Name, stdout, err)
+			if err := cmd.RunDefaultBashCf("docker exec %s ollama rm %s", containerName, item.Name); err != nil && !req.ForceDelete {
+				return fmt.Errorf("handle ollama rm %s failed, %v", item.Name, err)
 			}
 		}
 		_ = aiRepo.Delete(repo.WithByID(item.ID))

agent/app/service/alert.go

@@ -486,9 +486,10 @@ func (a AlertService) TestAlertConfig(req dto.AlertConfigTest) (bool, error) {
 	cfg := email.SMTPConfig{
 		Host:       req.Host,
 		Port:       req.Port,
+		Sender:     req.Sender,
 		Username:   username,
 		Password:   req.Password,
-		From:       fmt.Sprintf("%s <%s>", req.DisplayName, req.Sender),
+		From:       fmt.Sprintf(`"%s" <%s>`, req.DisplayName, req.Sender),
 		Encryption: req.Encryption,
 		Recipient:  req.Recipient,
 	}

agent/app/service/alert_helper.go

@@ -9,6 +9,7 @@ import (
 	"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/1Panel-dev/1Panel/agent/utils/psutil"
 	versionUtil "github.com/1Panel-dev/1Panel/agent/utils/version"
 	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
 	"github.com/shirou/gopsutil/v4/cpu"
@@ -352,7 +353,7 @@ func loadLoadInfo(alert dto.AlertDTO) {
 		return
 	}
 	var loadValue float64
-	CPUTotal, _ := cpu.Counts(true)
+	CPUTotal, _ := psutil.CPUInfo.GetLogicalCores(false)
 	switch alert.Cycle {
 	case 1:
 		loadValue = avgStat.Load1 / (float64(CPUTotal*2) * 0.75) * 100
@@ -839,7 +840,7 @@ func processSingleDisk(alert dto.AlertDTO) error {
 }
 
 func checkAndCreateDiskAlert(alert dto.AlertDTO, path string) (bool, error) {
-	usageStat, err := disk.Usage(path)
+	usageStat, err := psutil.DISK.GetUsage(path, false)
 	if err != nil {
 		global.LOG.Errorf("error getting disk usage for %s, err: %v", path, err)
 		return false, err

agent/app/service/app.go

@@ -37,7 +37,7 @@ type AppService struct {
 }
 
 type IAppService interface {
-	PageApp(ctx *gin.Context, req request.AppSearch) (interface{}, error)
+	PageApp(ctx *gin.Context, req request.AppSearch) (*response.AppRes, error)
 	GetAppTags(ctx *gin.Context) ([]response.TagDTO, error)
 	GetApp(ctx *gin.Context, key string) (*response.AppDTO, error)
 	GetAppDetail(appId uint, version, appType string) (response.AppDetailDTO, error)
@@ -46,13 +46,15 @@ type IAppService interface {
 	GetAppUpdate() (*response.AppUpdateRes, error)
 	GetAppDetailByID(id uint) (*response.AppDetailDTO, error)
 	SyncAppListFromLocal(taskID string)
+	GetAppIcon(appID uint) ([]byte, error)
+	GetAppDetailByKey(appKey, version string) (response.AppDetailSimpleDTO, error)
 }
 
 func NewIAppService() IAppService {
 	return &AppService{}
 }
 
-func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{}, error) {
+func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (*response.AppRes, error) {
 	var opts []repo.DBOption
 	opts = append(opts, appRepo.OrderByRecommend())
 	if req.Name != "" {
@@ -98,7 +100,7 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 		}
 		opts = append(opts, repo.WithByIDs(appIds))
 	}
-	var res response.AppRes
+	res := &response.AppRes{}
 
 	total, apps, err := appRepo.Page(req.Page, req.PageSize, opts...)
 	if err != nil {
@@ -117,25 +119,24 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 			}
 		}
 		appDTO := &response.AppItem{
-			ID:          ap.ID,
-			Name:        ap.Name,
-			Key:         ap.Key,
-			Type:        ap.Type,
-			Icon:        ap.Icon,
-			Resource:    ap.Resource,
-			Limit:       ap.Limit,
-			Website:     ap.Website,
-			Github:      ap.Github,
-			GpuSupport:  ap.GpuSupport,
-			Recommend:   ap.Recommend,
-			Description: ap.GetDescription(ctx),
+			ID:                  ap.ID,
+			Name:                ap.Name,
+			Key:                 ap.Key,
+			Limit:               ap.Limit,
+			GpuSupport:          ap.GpuSupport,
+			Recommend:           ap.Recommend,
+			Description:         ap.GetDescription(ctx),
+			Type:                ap.Type,
+			BatchInstallSupport: ap.BatchInstallSupport,
 		}
 		appDTOs = append(appDTOs, appDTO)
 		tags, err := getAppTags(ap.ID, lang)
 		if err != nil {
 			continue
 		}
-		appDTO.Tags = tags
+		for _, tag := range tags {
+			appDTO.Tags = append(appDTO.Tags, tag.Name)
+		}
 		if ap.Type == constant.RuntimePHP || ap.Type == constant.RuntimeGo || ap.Type == constant.RuntimeNode || ap.Type == constant.RuntimePython || ap.Type == constant.RuntimeJava || ap.Type == constant.RuntimeDotNet {
 			details, _ := appDetailRepo.GetBy(appDetailRepo.WithAppId(ap.ID))
 			var ids []uint
@@ -195,24 +196,7 @@ func (a AppService) GetApp(ctx *gin.Context, key string) (*response.AppDTO, erro
 	if err != nil {
 		return nil, err
 	}
-	var versionsRaw []string
-	hasLatest := false
-	latestVersion := ""
-	for _, detail := range details {
-		if strings.Contains(detail.Version, "latest") {
-			hasLatest = true
-			latestVersion = detail.Version
-			continue
-		}
-		if key == "openresty" && !common.CompareAppVersion(detail.Version, "1.27") {
-			continue
-		}
-		versionsRaw = append(versionsRaw, detail.Version)
-	}
-	appDTO.Versions = common.GetSortedVersions(versionsRaw)
-	if hasLatest {
-		appDTO.Versions = append([]string{latestVersion}, appDTO.Versions...)
-	}
+	appDTO.Versions = getAppVersions(key, details)
 	tags, err := getAppTags(app.ID, strings.ToLower(common.GetLang(ctx)))
 	if err != nil {
 		return nil, err
@@ -221,6 +205,20 @@ func (a AppService) GetApp(ctx *gin.Context, key string) (*response.AppDTO, erro
 	return &appDTO, nil
 }
 
+func (a AppService) GetAppDetailByKey(appKey, version string) (response.AppDetailSimpleDTO, error) {
+	var appDetailDTO response.AppDetailSimpleDTO
+	app, err := appRepo.GetFirst(appRepo.WithKey(appKey))
+	if err != nil {
+		return appDetailDTO, err
+	}
+	appDetail, err := appDetailRepo.GetFirst(appDetailRepo.WithAppId(app.ID), appDetailRepo.WithVersion(version))
+	if err != nil {
+		return appDetailDTO, err
+	}
+	appDetailDTO.ID = appDetail.ID
+	return appDetailDTO, nil
+}
+
 func (a AppService) GetAppDetail(appID uint, version, appType string) (response.AppDetailDTO, error) {
 	var (
 		appDetailDTO response.AppDetailDTO
@@ -404,11 +402,21 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 		App:         app,
 	}
 	composeMap := make(map[string]interface{})
+	var composeRes []byte
 	if req.EditCompose {
 		if err = yaml.Unmarshal([]byte(req.DockerCompose), &composeMap); err != nil {
 			return
 		}
 	} else {
+		if appDetail.DockerCompose == "" {
+			dockerComposeUrl := fmt.Sprintf("%s/%s/1panel/%s/%s/docker-compose.yml", global.CONF.RemoteURL.AppRepo, global.CONF.Base.Mode, app.Key, appDetail.Version)
+			_, composeRes, err = req_helper.HandleRequest(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
+			if err != nil {
+				return
+			}
+			appDetail.DockerCompose = string(composeRes)
+			_ = appDetailRepo.Update(context.Background(), appDetail)
+		}
 		if err = yaml.Unmarshal([]byte(appDetail.DockerCompose), &composeMap); err != nil {
 			return
 		}
@@ -450,10 +458,11 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 		}
 		index++
 	}
-	if app.Limit == 0 && appInstall.Name != serviceName && len(servicesMap) == 1 {
-		servicesMap[appInstall.Name] = servicesMap[serviceName]
+	newServiceName := strings.ToLower(appInstall.Name)
+	if app.Limit == 0 && newServiceName != serviceName && len(servicesMap) == 1 {
+		servicesMap[newServiceName] = servicesMap[serviceName]
 		delete(servicesMap, serviceName)
-		serviceName = appInstall.Name
+		serviceName = newServiceName
 	}
 	appInstall.ServiceName = serviceName
 
@@ -863,13 +872,15 @@ func getAppList() (*dto.AppList, error) {
 		return nil, err
 	}
 	listFile := filepath.Join(global.Dir.ResourceDir, "1panel.json")
-	content, err := os.ReadFile(listFile)
+	file, err := os.Open(listFile)
 	if err != nil {
 		return nil, err
 	}
-	if err = json.Unmarshal(content, list); err != nil {
+	defer file.Close()
+	if err = json.NewDecoder(file).Decode(list); err != nil {
 		return nil, err
 	}
+
 	return list, nil
 }
 
@@ -1152,7 +1163,7 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 	}, nil)
 
 	go func() {
-		if err = syncTask.Execute(); err != nil {
+		if err := syncTask.Execute(); err != nil {
 			_ = NewISettingService().Update("AppStoreLastModified", "0")
 			_ = NewISettingService().Update("AppStoreSyncStatus", constant.StatusError)
 		}
@@ -1160,3 +1171,15 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 
 	return nil
 }
+
+func (a AppService) GetAppIcon(appID uint) ([]byte, error) {
+	app, err := appRepo.GetFirst(repo.WithByID(appID))
+	if err != nil {
+		return nil, err
+	}
+	iconBytes, err := base64.StdEncoding.DecodeString(app.Icon)
+	if err != nil {
+		return nil, err
+	}
+	return iconBytes, nil
+}

agent/app/service/app_install.go

@@ -515,6 +515,7 @@ func (a *AppInstallService) GetServices(key string) ([]response.AppService, erro
 			} else {
 				service.From = constant.AppResourceRemote
 				service.Status = constant.StatusRunning
+				service.Config = map[string]string{"PANEL_DB_ROOT_PASSWORD": db.Password, "PANEL_DB_ROOT_USER": db.Username}
 			}
 			res = append(res, service)
 		}
@@ -796,6 +797,9 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	res.RestartPolicy = getRestartPolicy(install.DockerCompose)
 	res.WebUI = install.WebUI
 	res.Type = install.App.Type
+	if rawCompose, err := getUpgradeCompose(install, detail); err == nil {
+		res.RawCompose = rawCompose
+	}
 	return &res, nil
 }
 
@@ -940,8 +944,26 @@ func (a *AppInstallService) GetAppInstallInfo(installID uint) (*response.AppInst
 		HttpPort:    appInstall.HttpPort,
 		Status:      appInstall.Status,
 		Message:     appInstall.Message,
+		AppKey:      appInstall.App.Key,
 		Env:         envMap,
 		ComposePath: appInstall.GetComposePath(),
 	}
+	for k, v := range envMap {
+		if strings.Contains(strings.ToUpper(k), "PANEL_APP_PORT") {
+			var port int
+			switch val := v.(type) {
+			case int:
+				port = val
+			case string:
+				port, err = strconv.Atoi(val)
+				if err != nil {
+					continue
+				}
+			default:
+				continue
+			}
+			res.AppPorts = append(res.AppPorts, port)
+		}
+	}
 	return res, nil
 }

agent/app/service/app_utils.go

@@ -6,7 +6,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"log"
 	"maps"
 	"math"
 	"net/http"
@@ -15,7 +14,6 @@ import (
 	"path"
 	"path/filepath"
 	"reflect"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -40,11 +38,13 @@ import (
 	"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/re"
 	"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/sirupsen/logrus"
 	"github.com/subosito/gotenv"
 	"gopkg.in/yaml.v3"
 )
@@ -134,6 +134,76 @@ var ToolKeys = map[string]uint{
 	"minio": 9001,
 }
 
+func CreateDB(ctx context.Context, app model.App, appInstall *model.AppInstall, params map[string]interface{}) error {
+	database := &model.Database{
+		AppInstallID: appInstall.ID,
+		Name:         appInstall.Name,
+		Type:         app.Key,
+		Version:      appInstall.Version,
+		From:         "local",
+		Address:      appInstall.ServiceName,
+		Port:         DatabaseKeys[app.Key],
+	}
+	detail, err := appDetailRepo.GetFirst(repo.WithByID(appInstall.AppDetailId))
+	if err != nil {
+		return err
+	}
+	formFields := &dto.AppForm{}
+	if err := json.Unmarshal([]byte(detail.Params), formFields); err != nil {
+		return err
+	}
+	for _, form := range formFields.FormFields {
+		if form.EnvKey == "PANEL_APP_PORT_HTTP" {
+			portFloat, ok := form.Default.(float64)
+			if ok {
+				database.Port = uint(int(portFloat))
+			}
+			break
+		}
+	}
+
+	switch app.Key {
+	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" || app.Key == constant.AppMysqlCluster {
+					database.Username = "root"
+				}
+				if rootUser, ok := params["PANEL_DB_ROOT_USER"]; ok {
+					database.Username = rootUser.(string)
+				}
+				authParam := dto.AuthParam{
+					RootPassword: password.(string),
+					RootUser:     database.Username,
+				}
+				authByte, err := json.Marshal(authParam)
+				if err != nil {
+					return err
+				}
+				appInstall.Param = string(authByte)
+
+			}
+		}
+	case constant.AppRedis, constant.AppRedisCluster:
+		if password, ok := params["PANEL_REDIS_ROOT_PASSWORD"]; ok {
+			authParam := dto.RedisAuthParam{
+				RootPassword: "",
+			}
+			if password != "" {
+				authParam.RootPassword = password.(string)
+				database.Password = password.(string)
+			}
+			authByte, err := json.Marshal(authParam)
+			if err != nil {
+				return err
+			}
+			appInstall.Param = string(authByte)
+		}
+	}
+	return databaseRepo.Create(ctx, database)
+}
+
 func createLink(ctx context.Context, installTask *task.Task, app model.App, appInstall *model.AppInstall, params map[string]interface{}) error {
 	deleteAppLink := func(t *task.Task) {
 		del := dto.DelAppLink{
@@ -145,74 +215,7 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 	}
 	if DatabaseKeys[app.Key] > 0 {
 		handleDataBaseApp := func(task *task.Task) error {
-			database := &model.Database{
-				AppInstallID: appInstall.ID,
-				Name:         appInstall.Name,
-				Type:         app.Key,
-				Version:      appInstall.Version,
-				From:         "local",
-				Address:      appInstall.ServiceName,
-				Port:         DatabaseKeys[app.Key],
-			}
-			detail, err := appDetailRepo.GetFirst(repo.WithByID(appInstall.AppDetailId))
-			if err != nil {
-				return err
-			}
-
-			formFields := &dto.AppForm{}
-			if err := json.Unmarshal([]byte(detail.Params), formFields); err != nil {
-				return err
-			}
-			for _, form := range formFields.FormFields {
-				if form.EnvKey == "PANEL_APP_PORT_HTTP" {
-					portFloat, ok := form.Default.(float64)
-					if ok {
-						database.Port = uint(int(portFloat))
-					}
-					break
-				}
-			}
-
-			switch app.Key {
-			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" || app.Key == constant.AppMysqlCluster {
-							database.Username = "root"
-						}
-						if rootUser, ok := params["PANEL_DB_ROOT_USER"]; ok {
-							database.Username = rootUser.(string)
-						}
-						authParam := dto.AuthParam{
-							RootPassword: password.(string),
-							RootUser:     database.Username,
-						}
-						authByte, err := json.Marshal(authParam)
-						if err != nil {
-							return err
-						}
-						appInstall.Param = string(authByte)
-
-					}
-				}
-			case constant.AppRedis, constant.AppRedisCluster:
-				if password, ok := params["PANEL_REDIS_ROOT_PASSWORD"]; ok {
-					authParam := dto.RedisAuthParam{
-						RootPassword: "",
-					}
-					if password != "" {
-						authParam.RootPassword = password.(string)
-						database.Password = password.(string)
-					}
-					authByte, err := json.Marshal(authParam)
-					if err != nil {
-						return err
-					}
-					appInstall.Param = string(authByte)
-				}
-			}
-			return databaseRepo.Create(ctx, database)
+			return CreateDB(ctx, app, appInstall, params)
 		}
 		installTask.AddSubTask(i18n.GetMsgByKey("HandleDatabaseApp"), handleDataBaseApp, deleteAppLink)
 	}
@@ -297,10 +300,11 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
 						createMysql.Name = dbConfig.DbName
 						createMysql.Username = dbConfig.DbUser
 						createMysql.Database = database.Name
-						createMysql.Format = "utf8mb4"
+						createMysql.Format = dbConfig.Format
 						createMysql.Permission = "%"
 						createMysql.Password = dbConfig.Password
 						createMysql.From = database.From
+						createMysql.Collation = dbConfig.Collation
 						mysqldb, err := NewIMysqlService().Create(ctx, createMysql)
 						if err != nil {
 							return err
@@ -537,8 +541,18 @@ func handleUpgradeCompose(install model.AppInstall, detail model.AppDetail) (map
 	if !ok || oldValue == nil {
 		return nil, buserr.New("ErrFileParse")
 	}
-	oldValueMap := oldValue.(map[string]interface{})
-	oldServiceValue := oldValueMap[install.ServiceName].(map[string]interface{})
+	oldValueMap, ok := oldValue.(map[string]interface{})
+	if !ok {
+		return nil, buserr.New("ErrFileParse")
+	}
+	oldServiceValueInterface, ok := oldValueMap[install.ServiceName]
+	if !ok || oldServiceValueInterface == nil {
+		return nil, buserr.New("ErrFileParse")
+	}
+	oldServiceValue, ok := oldServiceValueInterface.(map[string]interface{})
+	if !ok {
+		return nil, buserr.New("ErrFileParse")
+	}
 	if oldServiceValue["deploy"] != nil {
 		serviceValue["deploy"] = oldServiceValue["deploy"]
 	}
@@ -945,7 +959,7 @@ func handleMap(params map[string]interface{}, envParams map[string]string) {
 	}
 }
 
-func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.AppInstall, logger *log.Logger) (err error) {
+func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.AppInstall, logger *logrus.Logger) (err error) {
 	if app.IsLocalApp() || app.IsCustomApp() {
 		return nil
 	}
@@ -1082,11 +1096,7 @@ func runScript(task *task.Task, appInstall *model.AppInstall, operate string) er
 	task.LogStart(logStr)
 
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10*time.Minute), cmd.WithWorkDir(workDir))
-	out, err := cmdMgr.RunWithStdoutBashC(scriptPath)
-	if err != nil {
-		if out != "" {
-			err = errors.New(out)
-		}
+	if err := cmdMgr.RunBashC(scriptPath); err != nil {
 		task.LogFailedWithErr(logStr, err)
 		return err
 	}
@@ -1302,6 +1312,7 @@ func getApps(oldApps []model.App, items []dto.AppDefine, systemVersion string, t
 		app.MemoryRequired = config.MemoryRequired
 		app.Architectures = strings.Join(config.Architectures, ",")
 		app.GpuSupport = config.GpuSupport
+		app.BatchInstallSupport = config.BatchInstallSupport
 		apps[key] = app
 	}
 	return apps
@@ -1413,6 +1424,9 @@ func handleLocalApp(appDir string) (app *model.App, err error) {
 	desc, _ := json.Marshal(appDefine.Description)
 	app.Description = string(desc)
 	app.Key = "local" + appDefine.Key
+	app.Architectures = strings.Join(appDefine.Architectures, ",")
+	app.GpuSupport = appDefine.GpuSupport
+	app.MemoryRequired = appDefine.MemoryRequired
 
 	app.Resource = constant.AppResourceLocal
 	app.Status = constant.AppNormal
@@ -1554,7 +1568,6 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 			Message:     installed.Message,
 			HttpPort:    installed.HttpPort,
 			HttpsPort:   installed.HttpsPort,
-			Icon:        installed.App.Icon,
 			AppName:     installed.App.Name,
 			AppKey:      installed.App.Key,
 			AppType:     installed.App.Type,
@@ -1566,41 +1579,41 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 				Website:  installed.App.Website,
 				Document: installed.App.Document,
 			},
-			Favorite:  installed.Favorite,
-			Container: installed.ContainerName,
+			Favorite:    installed.Favorite,
+			Container:   installed.ContainerName,
+			ServiceName: strings.ToLower(installed.ServiceName),
 		}
-		if updated {
-			installDTO.DockerCompose = installed.DockerCompose
+		if !updated {
+			installDTO.LinkDB = hasLinkDB(installed.ID)
+			res = append(res, installDTO)
+			continue
 		}
-		app, err := appRepo.GetFirst(repo.WithByID(installed.AppId))
-		if err != nil {
-			return nil, err
+		if installed.Version == "latest" {
+			continue
 		}
-		details, err := appDetailRepo.GetBy(appDetailRepo.WithAppId(app.ID))
+		installDTO.DockerCompose = installed.DockerCompose
+		installDTO.IsEdit = isEditCompose(installed)
+		details, err := appDetailRepo.GetBy(appDetailRepo.WithAppId(installed.App.ID))
 		if err != nil {
 			return nil, err
 		}
 		var versions []string
-		for _, detail := range details {
-			ignores, _ := appIgnoreUpgradeRepo.List(runtimeRepo.WithDetailId(detail.ID), appIgnoreUpgradeRepo.WithScope("version"))
-			if len(ignores) > 0 || installed.Version == "latest" {
+		for _, appDetail := range details {
+			ignores, _ := appIgnoreUpgradeRepo.List(runtimeRepo.WithDetailId(appDetail.ID), appIgnoreUpgradeRepo.WithScope("version"))
+			if len(ignores) > 0 {
 				continue
 			}
-			if common.IsCrossVersion(installed.Version, detail.Version) && !app.CrossVersionUpdate {
+			if common.IsCrossVersion(installed.Version, appDetail.Version) && !installed.App.CrossVersionUpdate {
 				continue
 			}
-			versions = append(versions, detail.Version)
+			versions = append(versions, appDetail.Version)
 		}
-		versions = common.GetSortedVersions(versions)
 		if len(versions) == 0 {
-			if !updated {
-				installDTO.CanUpdate = false
-				res = append(res, installDTO)
-			}
 			continue
 		}
+		versions = common.GetSortedVersions(versions)
 		lastVersion := versions[0]
-		if app.Key == constant.AppMysql || app.Key == constant.AppMysqlCluster {
+		if installed.App.Key == constant.AppMysql || installed.App.Key == constant.AppMysqlCluster {
 			for _, version := range versions {
 				majorVersion := getMajorVersion(installed.Version)
 				if !strings.HasPrefix(version, majorVersion) {
@@ -1612,15 +1625,11 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 			}
 		}
 		if common.IsCrossVersion(installed.Version, lastVersion) {
-			installDTO.CanUpdate = app.CrossVersionUpdate
+			installDTO.CanUpdate = installed.App.CrossVersionUpdate
 		} else {
 			installDTO.CanUpdate = common.CompareVersion(lastVersion, installed.Version)
 		}
-		if updated {
-			if installDTO.CanUpdate {
-				res = append(res, installDTO)
-			}
-		} else {
+		if installDTO.CanUpdate {
 			res = append(res, installDTO)
 		}
 	}
@@ -1824,8 +1833,7 @@ func getAppCommonConfig(envs map[string]interface{}) request.AppContainerConfig
 		config.CpuQuota = 0
 	}
 	if memLimit, ok := envs[constant.MemoryLimit]; ok {
-		re := regexp.MustCompile(`(\d+)([A-Za-z]+)`)
-		matches := re.FindStringSubmatch(memLimit.(string))
+		matches := re.GetRegex(re.NumberAlphaPattern).FindStringSubmatch(memLimit.(string))
 		if len(matches) == 3 {
 			num, err := strconv.ParseFloat(matches[1], 64)
 			if err == nil {
@@ -1999,7 +2007,7 @@ func handleOpenrestyFile(appInstall *model.AppInstall) error {
 			break
 		}
 	}
-	if err := handleSSLConfig(appInstall, hasDefaultWebsite); err != nil {
+	if err := handleSSLConfig(appInstall, hasDefaultWebsite, true); err != nil {
 		return err
 	}
 	if len(websites) == 0 {
@@ -2028,34 +2036,37 @@ func handleDefaultServer(appInstall *model.AppInstall) error {
 	return nil
 }
 
-func handleSSLConfig(appInstall *model.AppInstall, hasDefaultWebsite bool) error {
+func handleSSLConfig(appInstall *model.AppInstall, hasDefaultWebsite bool, sslRejectHandshake bool) error {
 	sslDir := path.Join(appInstall.GetPath(), "conf", "ssl")
 	fileOp := files.NewFileOp()
 	if !fileOp.Stat(sslDir) {
 		return errors.New("ssl dir not found")
 	}
-	ca, _ := websiteCARepo.GetFirst(repo.WithByName("1Panel"))
-	if ca.ID == 0 {
-		global.LOG.Errorf("create openresty default ssl failed ca not found")
-		return nil
+	hasDefaultSSL := fileOp.Stat(path.Join(sslDir, "fullchain.pem")) && fileOp.Stat(path.Join(sslDir, "privkey.pem")) && fileOp.Stat(path.Join(sslDir, "root_ssl.conf"))
+	if !hasDefaultSSL {
+		ca, _ := websiteCARepo.GetFirst(repo.WithByName("1Panel"))
+		if ca.ID == 0 {
+			global.LOG.Errorf("create openresty default ssl failed ca not found")
+			return nil
+		}
+		caService := NewIWebsiteCAService()
+		caRequest := request.WebsiteCAObtain{
+			ID:      ca.ID,
+			Domains: "localhost",
+			KeyType: "4096",
+			Time:    99,
+			Unit:    "year",
+			Dir:     sslDir,
+			PushDir: true,
+		}
+		websiteSSL, err := caService.ObtainSSL(caRequest)
+		if err != nil {
+			return err
+		}
+		defer func() {
+			_ = NewIWebsiteSSLService().Delete([]uint{websiteSSL.ID})
+		}()
 	}
-	caService := NewIWebsiteCAService()
-	caRequest := request.WebsiteCAObtain{
-		ID:      ca.ID,
-		Domains: "localhost",
-		KeyType: "4096",
-		Time:    99,
-		Unit:    "year",
-		Dir:     sslDir,
-		PushDir: true,
-	}
-	websiteSSL, err := caService.ObtainSSL(caRequest)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		_ = NewIWebsiteSSLService().Delete([]uint{websiteSSL.ID})
-	}()
 	defaultConfigPath := path.Join(appInstall.GetPath(), "conf", "default", "00.default.conf")
 	content, err := os.ReadFile(defaultConfigPath)
 	if err != nil {
@@ -2070,6 +2081,11 @@ func handleSSLConfig(appInstall *model.AppInstall, hasDefaultWebsite bool) error
 	updateDefaultServer(defaultServer, appInstall.HttpPort, appInstall.HttpsPort, !hasDefaultWebsite, true)
 	defaultServer.UpdateDirective("include", []string{"/usr/local/openresty/nginx/conf/ssl/root_ssl.conf"})
 	defaultServer.UpdateDirective("http2", []string{"on"})
+	if sslRejectHandshake {
+		defaultServer.UpdateDirective("ssl_reject_handshake", []string{"on"})
+	} else {
+		defaultServer.RemoveDirective("ssl_reject_handshake", []string{})
+	}
 	if err = nginx.WriteConfig(defaultConfig, nginx.IndentedStyle); err != nil {
 		return err
 	}
@@ -2131,3 +2147,56 @@ func needsUpdate(localTag *model.Tag, remoteTag dto.Tag, translations string) bo
 		localTag.Sort != remoteTag.Sort ||
 		localTag.Translations != translations
 }
+
+func hasLinkDB(installID uint) bool {
+	resources, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithAppInstallId(installID))
+	hasDB := false
+	if len(resources) > 0 {
+		for _, resource := range resources {
+			if resource.Key == constant.AppPostgres || resource.Key == constant.AppMysql ||
+				resource.Key == constant.AppMariaDB || resource.Key == constant.AppMysqlCluster ||
+				resource.Key == constant.AppPostgresql || resource.Key == constant.AppPostgresqlCluster {
+				hasDB = true
+				break
+			}
+		}
+	}
+	return hasDB
+}
+
+func isEditCompose(installed model.AppInstall) bool {
+	detail, _ := appDetailRepo.GetFirst(repo.WithByID(installed.AppDetailId))
+	rawCompose, err := getUpgradeCompose(installed, detail)
+	if rawCompose == "" || err != nil {
+		return false
+	}
+	if rawCompose != installed.DockerCompose {
+		return true
+	}
+	return false
+}
+
+func getAppVersions(key string, details []model.AppDetail) []string {
+	var (
+		versionsRaw []string
+		versions    []string
+	)
+	hasLatest := false
+	latestVersion := ""
+	for _, detail := range details {
+		if key != "mssql" && strings.Contains(detail.Version, "latest") {
+			hasLatest = true
+			latestVersion = detail.Version
+			continue
+		}
+		if key == "openresty" && !common.CompareAppVersion(detail.Version, "1.27") {
+			continue
+		}
+		versionsRaw = append(versionsRaw, detail.Version)
+	}
+	versions = common.GetSortedVersions(versionsRaw)
+	if hasLatest {
+		versions = append([]string{latestVersion}, versions...)
+	}
+	return versions
+}

agent/app/service/backup.go

@@ -34,6 +34,7 @@ type IBackupService interface {
 	LoadBackupOptions() ([]dto.BackupOption, error)
 	SearchWithPage(search dto.SearchPageWithType) (int64, interface{}, error)
 	Create(backupDto dto.BackupOperate) error
+	CheckConn(req dto.BackupOperate) dto.BackupCheckRes
 	GetBuckets(backupDto dto.ForBuckets) ([]interface{}, error)
 	Update(req dto.BackupOperate) error
 	Delete(id uint) error
@@ -123,6 +124,43 @@ func (u *BackupService) SearchWithPage(req dto.SearchPageWithType) (int64, inter
 	return count, data, nil
 }
 
+func (u *BackupService) CheckConn(req dto.BackupOperate) dto.BackupCheckRes {
+	var res dto.BackupCheckRes
+	var backup model.BackupAccount
+	if err := copier.Copy(&backup, &req); err != nil {
+		res.Msg = i18n.GetMsgWithDetail("ErrStructTransform", err.Error())
+		return res
+	}
+	itemAccessKey, err := base64.StdEncoding.DecodeString(backup.AccessKey)
+	if err != nil {
+		res.Msg = err.Error()
+		return res
+	}
+	backup.AccessKey = string(itemAccessKey)
+	itemCredential, err := base64.StdEncoding.DecodeString(backup.Credential)
+	if err != nil {
+		res.Msg = err.Error()
+		return res
+	}
+	backup.Credential = string(itemCredential)
+
+	if req.Type == constant.OneDrive || req.Type == constant.GoogleDrive {
+		refreshToken, err := loadRefreshTokenByCode(&backup)
+		if err != nil {
+			res.Msg = err.Error()
+			return res
+		}
+		res.Token = base64.StdEncoding.EncodeToString([]byte(refreshToken))
+	}
+	isOk, err := u.checkBackupConn(&backup)
+	if err != nil {
+		res.Msg = err.Error()
+		return res
+	}
+	res.IsOk = isOk
+	return res
+}
+
 func (u *BackupService) Create(req dto.BackupOperate) error {
 	if req.Type == constant.Local {
 		return buserr.New("ErrBackupLocalCreate")
@@ -147,19 +185,6 @@ func (u *BackupService) Create(req dto.BackupOperate) error {
 		return err
 	}
 	backup.Credential = string(itemCredential)
-
-	if req.Type == constant.OneDrive || req.Type == constant.GoogleDrive || req.Type == constant.ALIYUN {
-		if err := loadRefreshTokenByCode(&backup); err != nil {
-			return err
-		}
-	}
-	if req.Type != constant.Local {
-		isOk, err := u.checkBackupConn(&backup)
-		if err != nil || !isOk {
-			return buserr.WithMap("ErrBackupCheck", map[string]interface{}{"err": err.Error()}, err)
-		}
-	}
-
 	backup.AccessKey, err = encrypt.StringEncrypt(backup.AccessKey)
 	if err != nil {
 		return err
@@ -248,16 +273,7 @@ func (u *BackupService) Update(req dto.BackupOperate) error {
 		global.Dir.LocalBackupDir = newBackup.BackupPath
 	}
 
-	if newBackup.Type == constant.OneDrive || newBackup.Type == constant.GoogleDrive || newBackup.Type == constant.ALIYUN {
-		if err := loadRefreshTokenByCode(&newBackup); err != nil {
-			return err
-		}
-	}
 	if backup.Type != constant.Local {
-		isOk, err := u.checkBackupConn(&newBackup)
-		if err != nil || !isOk {
-			return buserr.WithMap("ErrBackupCheck", map[string]interface{}{"err": err.Error()}, err)
-		}
 		newBackup.AccessKey, err = encrypt.StringEncrypt(newBackup.AccessKey)
 		if err != nil {
 			return err
@@ -514,37 +530,34 @@ func newClient(account *model.BackupAccount, isEncrypt bool) (cloud_storage.Clou
 	return client, nil
 }
 
-func loadRefreshTokenByCode(backup *model.BackupAccount) error {
+func loadRefreshTokenByCode(backup *model.BackupAccount) (string, error) {
 	varMap := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
-		return fmt.Errorf("unmarshal backup vars failed, err: %v", err)
+		return "", fmt.Errorf("unmarshal backup vars failed, err: %v", err)
+	}
+	if _, ok := varMap["refresh_token"]; ok {
+		return "", nil
 	}
 	refreshToken := ""
 	var err error
-	if backup.Type == constant.GoogleDrive {
+	switch backup.Type {
+	case constant.GoogleDrive:
 		refreshToken, err = client.RefreshGoogleToken("authorization_code", "refreshToken", varMap)
 		if err != nil {
-			return err
+			return "", err
 		}
-	}
-	if backup.Type == constant.OneDrive {
+	case constant.OneDrive:
 		refreshToken, err = client.RefreshToken("authorization_code", "refreshToken", varMap)
 		if err != nil {
-			return err
+			return "", err
 		}
 	}
 	if backup.Type != constant.ALIYUN {
-		delete(varMap, "code")
 		varMap["refresh_token"] = refreshToken
 	}
-	varMap["refresh_status"] = constant.StatusSuccess
-	varMap["refresh_time"] = time.Now().Format(constant.DateTimeLayout)
-	itemVars, err := json.Marshal(varMap)
-	if err != nil {
-		return fmt.Errorf("json marshal var map failed, err: %v", err)
-	}
+	itemVars, _ := json.Marshal(varMap)
 	backup.Vars = string(itemVars)
-	return nil
+	return refreshToken, nil
 }
 
 func loadBackupNamesByID(accountIDs string, downloadID uint) ([]string, string, error) {

agent/app/service/backup_app.go

@@ -102,7 +102,7 @@ func backupDatabaseWithTask(parentTask *task.Task, resourceKey, tmpDir, name str
 		}
 		parentTask.LogStart(task.GetTaskName(db.Name, task.TaskBackup, task.TaskScopeDatabase))
 		databaseHelper := DatabaseHelper{Database: db.MysqlName, DBType: resourceKey, Name: db.Name}
-		if err := handleMysqlBackup(databaseHelper, parentTask, 0, tmpDir, fmt.Sprintf("%s.sql.gz", name), ""); err != nil {
+		if err := handleMysqlBackup(databaseHelper, parentTask, 0, tmpDir, fmt.Sprintf("%s.sql.gz", name), "", ""); err != nil {
 			return err
 		}
 		parentTask.LogSuccess(task.GetTaskName(db.Name, task.TaskBackup, task.TaskScopeDatabase))
@@ -113,7 +113,7 @@ func backupDatabaseWithTask(parentTask *task.Task, resourceKey, tmpDir, name str
 		}
 		parentTask.LogStart(task.GetTaskName(db.Name, task.TaskBackup, task.TaskScopeDatabase))
 		databaseHelper := DatabaseHelper{Database: db.PostgresqlName, DBType: resourceKey, Name: db.Name}
-		if err := handlePostgresqlBackup(databaseHelper, parentTask, 0, tmpDir, fmt.Sprintf("%s.sql.gz", name), ""); err != nil {
+		if err := handlePostgresqlBackup(databaseHelper, parentTask, 0, tmpDir, fmt.Sprintf("%s.sql.gz", name), "", ""); err != nil {
 			return err
 		}
 		parentTask.LogSuccess(task.GetTaskName(db.Name, task.TaskBackup, task.TaskScopeDatabase))
@@ -260,7 +260,7 @@ func handleAppRecover(install *model.AppInstall, parentTask *task.Task, recoverF
 					Name:       newDB.MysqlName,
 					DetailName: newDB.Name,
 					File:       fmt.Sprintf("%s/%s.sql.gz", tmpPath, install.Name),
-				}, parentTask, true, ""); err != nil {
+				}, parentTask, true); err != nil {
 					t.LogFailedWithErr(taskName, err)
 					return err
 				}

agent/app/service/backup_mysql.go

@@ -8,17 +8,14 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-
-	"github.com/1Panel-dev/1Panel/agent/constant"
-	"github.com/1Panel-dev/1Panel/agent/i18n"
-
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-
 	"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/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/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
 	"github.com/1Panel-dev/1Panel/agent/utils/mysql/client"
@@ -48,7 +45,7 @@ func (u *BackupService) MysqlBackup(req dto.CommonBackup) error {
 	}
 
 	databaseHelper := DatabaseHelper{Database: req.Name, DBType: req.Type, Name: req.DetailName}
-	if err := handleMysqlBackup(databaseHelper, nil, record.ID, targetDir, fileName, req.TaskID); err != nil {
+	if err := handleMysqlBackup(databaseHelper, nil, record.ID, targetDir, fileName, req.TaskID, req.Secret); err != nil {
 		backupRepo.UpdateRecordByMap(record.ID, map[string]interface{}{"status": constant.StatusFailed, "message": err.Error()})
 		return err
 	}
@@ -56,23 +53,23 @@ func (u *BackupService) MysqlBackup(req dto.CommonBackup) error {
 }
 
 func (u *BackupService) MysqlRecover(req dto.CommonRecover) error {
-	return handleMysqlRecover(req, nil, false, req.TaskID)
+	return handleMysqlRecover(req, nil, false)
 }
 
 func (u *BackupService) MysqlRecoverByUpload(req dto.CommonRecover) error {
-	recoveFile, err := loadSqlFile(req.File)
+	recoverFile, err := loadSqlFile(req.File)
 	if err != nil {
 		return err
 	}
-	req.File = recoveFile
+	req.File = recoverFile
 
-	if err := handleMysqlRecover(req, nil, false, req.TaskID); err != nil {
+	if err := handleMysqlRecover(req, nil, false); err != nil {
 		return err
 	}
 	return nil
 }
 
-func handleMysqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint, targetDir, fileName, taskID string) error {
+func handleMysqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint, targetDir, fileName, taskID, secret string) error {
 	var (
 		err        error
 		backupTask *task.Task
@@ -90,11 +87,11 @@ func handleMysqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint,
 		}
 	}
 
-	itemHandler := func() error { return doMysqlBackup(db, targetDir, fileName) }
+	itemHandler := func() error { return doMysqlBackup(db, targetDir, fileName, secret) }
 	if parentTask != nil {
 		return itemHandler()
 	}
-	backupTask.AddSubTaskWithOps(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeBackup), func(t *task.Task) error { return itemHandler() }, nil, 3, time.Hour)
+	backupTask.AddSubTaskWithOps(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeBackup), func(t *task.Task) error { return itemHandler() }, nil, 0, 3*time.Hour)
 	go func() {
 		if err := backupTask.Execute(); err != nil {
 			backupRepo.UpdateRecordByMap(recordID, map[string]interface{}{"status": constant.StatusFailed, "message": err.Error()})
@@ -105,7 +102,7 @@ func handleMysqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint,
 	return nil
 }
 
-func handleMysqlRecover(req dto.CommonRecover, parentTask *task.Task, isRollback bool, taskID string) error {
+func handleMysqlRecover(req dto.CommonRecover, parentTask *task.Task, isRollback bool) error {
 	var (
 		err      error
 		itemTask *task.Task
@@ -117,7 +114,7 @@ func handleMysqlRecover(req dto.CommonRecover, parentTask *task.Task, isRollback
 	}
 	itemName := fmt.Sprintf("%s[%s] - %s", req.Name, req.Type, req.DetailName)
 	if parentTask == nil {
-		itemTask, err = task.NewTaskWithOps(itemName, task.TaskRecover, task.TaskScopeBackup, taskID, dbInfo.ID)
+		itemTask, err = task.NewTaskWithOps(itemName, task.TaskRecover, task.TaskScopeBackup, req.TaskID, dbInfo.ID)
 		if err != nil {
 			return err
 		}
@@ -170,6 +167,15 @@ func handleMysqlRecover(req dto.CommonRecover, parentTask *task.Task, isRollback
 				}
 			}()
 		}
+		if len(req.Secret) != 0 {
+			err = files.OpensslDecrypt(req.File, req.Secret)
+			if err != nil {
+				return err
+			}
+			req.File = path.Join(path.Dir(req.File), "tmp_"+path.Base(req.File))
+			defer os.Remove(req.File)
+			t.LogWithStatus(i18n.GetMsgByKey("Decrypt"), err)
+		}
 		if err := cli.Recover(client.RecoverInfo{
 			Name:       req.DetailName,
 			Type:       req.Type,
@@ -187,14 +193,23 @@ func handleMysqlRecover(req dto.CommonRecover, parentTask *task.Task, isRollback
 		return recoverDatabase(parentTask)
 	}
 
-	itemTask.AddSubTaskWithOps(i18n.GetMsgByKey("TaskRecover"), recoverDatabase, nil, 3, time.Hour)
+	var timeout time.Duration
+	switch req.Timeout {
+	case -1:
+		timeout = 0
+	case 0:
+		timeout = 3 * time.Hour
+	default:
+		timeout = time.Duration(req.Timeout) * time.Second
+	}
+	itemTask.AddSubTaskWithOps(i18n.GetMsgByKey("TaskRecover"), recoverDatabase, nil, 0, timeout)
 	go func() {
 		_ = itemTask.Execute()
 	}()
 	return nil
 }
 
-func doMysqlBackup(db DatabaseHelper, targetDir, fileName string) error {
+func doMysqlBackup(db DatabaseHelper, targetDir, fileName, secret string) error {
 	dbInfo, err := mysqlRepo.Get(repo.WithByName(db.Name), mysqlRepo.WithByMysqlName(db.Database))
 	if err != nil {
 		return err
@@ -211,7 +226,13 @@ func doMysqlBackup(db DatabaseHelper, targetDir, fileName string) error {
 		TargetDir: targetDir,
 		FileName:  fileName,
 	}
-	return cli.Backup(backupInfo)
+	if err := cli.Backup(backupInfo); err != nil {
+		return err
+	}
+	if len(secret) != 0 {
+		return files.OpensslEncrypt(path.Join(targetDir, fileName), secret)
+	}
+	return nil
 }
 
 func loadSqlFile(file string) (string, error) {

agent/app/service/backup_postgresql.go

@@ -6,19 +6,15 @@ import (
 	"path"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-
-	"github.com/1Panel-dev/1Panel/agent/constant"
-	"github.com/1Panel-dev/1Panel/agent/i18n"
-
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-	"github.com/1Panel-dev/1Panel/agent/utils/common"
-	pgclient "github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
-
 	"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/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/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
 	"github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
 )
@@ -46,7 +42,7 @@ func (u *BackupService) PostgresqlBackup(req dto.CommonBackup) error {
 	}
 
 	databaseHelper := DatabaseHelper{Database: req.Name, DBType: req.Type, Name: req.DetailName}
-	if err := handlePostgresqlBackup(databaseHelper, nil, record.ID, targetDir, fileName, req.TaskID); err != nil {
+	if err := handlePostgresqlBackup(databaseHelper, nil, record.ID, targetDir, fileName, req.TaskID, req.Secret); err != nil {
 		return err
 	}
 	return nil
@@ -59,11 +55,11 @@ func (u *BackupService) PostgresqlRecover(req dto.CommonRecover) error {
 }
 
 func (u *BackupService) PostgresqlRecoverByUpload(req dto.CommonRecover) error {
-	recoveFile, err := loadSqlFile(req.File)
+	recoverFile, err := loadSqlFile(req.File)
 	if err != nil {
 		return err
 	}
-	req.File = recoveFile
+	req.File = recoverFile
 	if err := handlePostgresqlRecover(req, nil, false); err != nil {
 		return err
 	}
@@ -71,7 +67,7 @@ func (u *BackupService) PostgresqlRecoverByUpload(req dto.CommonRecover) error {
 	return nil
 }
 
-func handlePostgresqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint, targetDir, fileName, taskID string) error {
+func handlePostgresqlBackup(db DatabaseHelper, parentTask *task.Task, recordID uint, targetDir, fileName, taskID, secret string) error {
 	var (
 		err        error
 		backupTask *task.Task
@@ -85,11 +81,11 @@ func handlePostgresqlBackup(db DatabaseHelper, parentTask *task.Task, recordID u
 		}
 	}
 
-	itemHandler := func() error { return doPostgresqlgBackup(db, targetDir, fileName) }
+	itemHandler := func() error { return doPostgresqlBackup(db, targetDir, fileName, secret, backupTask) }
 	if parentTask != nil {
 		return itemHandler()
 	}
-	backupTask.AddSubTaskWithOps(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeBackup), func(t *task.Task) error { return itemHandler() }, nil, 3, time.Hour)
+	backupTask.AddSubTaskWithOps(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeBackup), func(t *task.Task) error { return itemHandler() }, nil, 0, 3*time.Hour)
 	go func() {
 		if err := backupTask.Execute(); err != nil {
 			backupRepo.UpdateRecordByMap(recordID, map[string]interface{}{"status": constant.StatusFailed, "message": err.Error()})
@@ -133,10 +129,12 @@ func handlePostgresqlRecover(req dto.CommonRecover, parentTask *task.Task, isRol
 		if !isRollback {
 			rollbackFile := path.Join(global.Dir.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format(constant.DateTimeSlimLayout)))
 			if err := cli.Backup(client.BackupInfo{
+				Database:  req.Name,
 				Name:      req.DetailName,
 				TargetDir: path.Dir(rollbackFile),
 				FileName:  path.Base(rollbackFile),
 
+				Task:    t,
 				Timeout: 300,
 			}); err != nil {
 				return fmt.Errorf("backup postgresql db %s for rollback before recover failed, err: %v", req.DetailName, err)
@@ -145,9 +143,11 @@ func handlePostgresqlRecover(req dto.CommonRecover, parentTask *task.Task, isRol
 				if !isOk {
 					global.LOG.Info("recover failed, start to rollback now")
 					if err := cli.Recover(client.RecoverInfo{
+						Database:   req.Name,
 						Name:       req.DetailName,
 						SourceFile: rollbackFile,
 
+						Task:    t,
 						Timeout: 300,
 					}); err != nil {
 						global.LOG.Errorf("rollback postgresql db %s from %s failed, err: %v", req.DetailName, rollbackFile, err)
@@ -160,10 +160,21 @@ func handlePostgresqlRecover(req dto.CommonRecover, parentTask *task.Task, isRol
 				}
 			}()
 		}
+		if len(req.Secret) != 0 {
+			err = files.OpensslDecrypt(req.File, req.Secret)
+			if err != nil {
+				return err
+			}
+			req.File = path.Join(path.Dir(req.File), "tmp_"+path.Base(req.File))
+			defer os.Remove(req.File)
+			t.LogWithStatus(i18n.GetMsgByKey("Decrypt"), err)
+		}
 		if err := cli.Recover(client.RecoverInfo{
+			Database:   req.Name,
 			Name:       req.DetailName,
 			SourceFile: req.File,
 			Username:   dbInfo.Username,
+			Task:       t,
 			Timeout:    300,
 		}); err != nil {
 			global.LOG.Errorf("recover postgresql db %s from %s failed, err: %v", req.DetailName, req.File, err)
@@ -176,25 +187,42 @@ func handlePostgresqlRecover(req dto.CommonRecover, parentTask *task.Task, isRol
 		return recoverDatabase(parentTask)
 	}
 
-	itemTask.AddSubTaskWithOps(i18n.GetMsgByKey("TaskRecover"), recoverDatabase, nil, 3, time.Hour)
+	var timeout time.Duration
+	switch req.Timeout {
+	case -1:
+		timeout = 0
+	case 0:
+		timeout = 3 * time.Hour
+	default:
+		timeout = time.Duration(req.Timeout) * time.Second
+	}
+	itemTask.AddSubTaskWithOps(i18n.GetMsgByKey("TaskRecover"), recoverDatabase, nil, 0, timeout)
 	go func() {
 		_ = itemTask.Execute()
 	}()
 	return nil
 }
 
-func doPostgresqlgBackup(db DatabaseHelper, targetDir, fileName string) error {
+func doPostgresqlBackup(db DatabaseHelper, targetDir, fileName, secret string, task *task.Task) error {
 	cli, err := LoadPostgresqlClientByFrom(db.Database)
 	if err != nil {
 		return err
 	}
 	defer cli.Close()
-	backupInfo := pgclient.BackupInfo{
+	backupInfo := client.BackupInfo{
+		Database:  db.Database,
 		Name:      db.Name,
 		TargetDir: targetDir,
 		FileName:  fileName,
 
+		Task:    task,
 		Timeout: 300,
 	}
-	return cli.Backup(backupInfo)
+	if err := cli.Backup(backupInfo); err != nil {
+		return err
+	}
+	if len(secret) != 0 {
+		return files.OpensslEncrypt(path.Join(targetDir, fileName), secret)
+	}
+	return nil
 }

agent/app/service/backup_redis.go

@@ -19,7 +19,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
-	"github.com/pkg/errors"
 )
 
 func (u *BackupService) RedisBackup(req dto.CommonBackup) error {
@@ -98,9 +97,8 @@ func handleRedisBackup(redisInfo *repo.RootInfo, parentTask *task.Task, recordID
 			}
 		}
 
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("docker exec %s redis-cli -a %s --no-auth-warning save", redisInfo.ContainerName, redisInfo.Password)
-		if err != nil {
-			return errors.New(string(stdout))
+		if err := cmd.RunDefaultBashCf("docker exec %s redis-cli -a %s --no-auth-warning save", redisInfo.ContainerName, redisInfo.Password); err != nil {
+			return err
 		}
 
 		if strings.HasSuffix(fileName, ".tar.gz") {
@@ -111,16 +109,14 @@ func handleRedisBackup(redisInfo *repo.RootInfo, parentTask *task.Task, recordID
 			return nil
 		}
 		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(stdout1)
+			if err := cmd.RunDefaultBashCf("docker cp %s:/data/appendonly.aof %s/%s", redisInfo.ContainerName, backupDir, fileName); err != nil {
+				return err
 			}
 			return nil
 		}
 
-		stdout1, err1 := cmd.RunDefaultWithStdoutBashCf("docker cp %s:/data/dump.rdb %s/%s", redisInfo.ContainerName, backupDir, fileName)
-		if err1 != nil {
-			return errors.New(stdout1)
+		if err := cmd.RunDefaultBashCf("docker cp %s:/data/dump.rdb %s/%s", redisInfo.ContainerName, backupDir, fileName); err != nil {
+			return err
 		}
 		return nil
 	}

agent/app/service/backup_website.go

@@ -16,7 +16,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/i18n"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
-	"github.com/pkg/errors"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
@@ -132,7 +131,7 @@ func handleWebsiteRecover(website *model.Website, parentTask *task.Task, recover
 		if err != nil {
 			return err
 		}
-		if err = fileOp.CopyFile(fmt.Sprintf("%s/%s.conf", tmpPath, website.Alias), GetOpenrestyDir(SiteConfDir)); err != nil {
+		if err = fileOp.CopyFile(fmt.Sprintf("%s/%s.conf", tmpPath, website.Alias), GetConfDir(*website)); err != nil {
 			return err
 		}
 
@@ -179,9 +178,8 @@ func handleWebsiteRecover(website *model.Website, parentTask *task.Task, recover
 		if err = fileOp.TarGzExtractPro(fmt.Sprintf("%s/%s.web.tar.gz", tmpPath, website.Alias), GetOpenrestyDir(SitesRootDir), ""); err != nil {
 			return err
 		}
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("docker exec -i %s nginx -s reload", nginxInfo.ContainerName)
-		if err != nil {
-			return errors.New(stdout)
+		if err := cmd.RunDefaultBashCf("docker exec -i %s nginx -s reload", nginxInfo.ContainerName); err != nil {
+			return err
 		}
 		oldWebsite.ID = website.ID
 		if err := websiteRepo.SaveWithoutCtx(&oldWebsite); err != nil {
@@ -261,7 +259,7 @@ func doWebsiteBackup(website *model.Website, parentTask *task.Task, backupDir, f
 	if err := fileOp.SaveFile(tmpDir+"/website.json", string(remarkInfo), fs.ModePerm); err != nil {
 		return err
 	}
-	nginxConfFile := GetSitePath(*website, SiteConf)
+	nginxConfFile := GetWebsiteConfigPath(*website)
 	if err := fileOp.CopyFile(nginxConfFile, tmpDir); err != nil {
 		return err
 	}
@@ -365,7 +363,7 @@ func recoverWebsiteDatabase(t *task.Task, dbID uint, dbType, tmpPath, websiteKey
 			Name:       db.MysqlName,
 			DetailName: db.Name,
 			File:       fmt.Sprintf("%s/%s.sql.gz", tmpPath, websiteKey),
-		}, t, true, ""); err != nil {
+		}, t, true); err != nil {
 			t.LogFailedWithErr(taskName, err)
 			return err
 		}

agent/app/service/clam.go

@@ -21,14 +21,15 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/clam"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
-	"github.com/1Panel-dev/1Panel/agent/utils/systemctl"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
 	"github.com/jinzhu/copier"
 	"github.com/robfig/cron/v3"
 )
 
 type ClamService struct {
-	serviceName string
+	serviceName      string
+	freshClamService string
 }
 
 type IClamService interface {
@@ -56,23 +57,31 @@ func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
 	var baseInfo dto.ClamBaseInfo
 	baseInfo.Version = "-"
 	baseInfo.FreshVersion = "-"
-	exist1, _ := systemctl.IsExist(constant.ClamServiceNameCentOs)
-	if exist1 {
-		c.serviceName = constant.ClamServiceNameCentOs
-		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(constant.ClamServiceNameCentOs)
+
+	clamSvc, err := controller.LoadServiceName("clam")
+	if err != nil {
+		baseInfo.IsExist = false
+		return baseInfo, nil
 	}
-	exist2, _ := systemctl.IsExist(constant.ClamServiceNameUbuntu)
-	if exist2 {
-		c.serviceName = constant.ClamServiceNameUbuntu
+	c.serviceName = clamSvc
+	exist, _ := controller.CheckExist(clamSvc)
+	if exist {
 		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(constant.ClamServiceNameUbuntu)
+		baseInfo.IsActive, _ = controller.CheckActive(clamSvc)
 	}
-	freshExist, _ := systemctl.IsExist(constant.FreshClamService)
+
+	freshSvc, err := controller.LoadServiceName("freshclam")
+	if err != nil {
+		baseInfo.FreshIsExist = false
+		return baseInfo, nil
+	}
+	c.freshClamService = freshSvc
+	freshExist, _ := controller.CheckExist(freshSvc)
 	if freshExist {
 		baseInfo.FreshIsExist = true
-		baseInfo.FreshIsActive, _ = systemctl.IsActive(constant.FreshClamService)
+		baseInfo.FreshIsActive, _ = controller.CheckActive(freshSvc)
 	}
+
 	if !cmd.Which("clamdscan") {
 		baseInfo.IsActive = false
 	}
@@ -87,7 +96,7 @@ func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
 			}
 		}
 	} else {
-		_ = clam.CheckClamIsActive(false, clamRepo)
+		_ = clam.StopAllClamJob(false, clamRepo)
 	}
 	if baseInfo.FreshIsActive {
 		version, err := cmd.RunDefaultWithStdoutBashC("freshclam --version")
@@ -105,15 +114,13 @@ func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
 func (c *ClamService) Operate(operate string) error {
 	switch operate {
 	case "start", "restart", "stop":
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s %s", operate, c.serviceName)
-		if err != nil {
-			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, stdout)
+		if err := controller.Handle(operate, c.serviceName); err != nil {
+			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, err)
 		}
 		return nil
 	case "fresh-start", "fresh-restart", "fresh-stop":
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s %s", strings.TrimPrefix(operate, "fresh-"), constant.FreshClamService)
-		if err != nil {
-			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, stdout)
+		if err := controller.Handle(strings.TrimPrefix(operate, "fresh-"), c.freshClamService); err != nil {
+			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, err)
 		}
 		return nil
 	default:
@@ -306,7 +313,7 @@ func (c *ClamService) Delete(req dto.ClamDelete) error {
 }
 
 func (c *ClamService) HandleOnce(id uint) error {
-	if active := clam.CheckClamIsActive(true, clamRepo); !active {
+	if active := clam.StopAllClamJob(true, clamRepo); !active {
 		return buserr.New("ErrClamdscanNotFound")
 	}
 	clamItem, _ := clamRepo.Get(repo.WithByID(id))
@@ -379,37 +386,13 @@ func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
 	filePath := ""
 	switch req.Name {
 	case "clamd":
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			filePath = "/etc/clamav/clamd.conf"
-		} else {
-			filePath = "/etc/clamd.d/scan.conf"
-		}
+		filePath = c.loadConfigPath("clamd")
 	case "clamd-log":
 		filePath = c.loadLogPath("clamd-log")
-		if len(filePath) != 0 {
-			break
-		}
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			filePath = "/var/log/clamav/clamav.log"
-		} else {
-			filePath = "/var/log/clamd.scan"
-		}
 	case "freshclam":
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			filePath = "/etc/clamav/freshclam.conf"
-		} else {
-			filePath = "/etc/freshclam.conf"
-		}
+		filePath = c.loadConfigPath("freshclam")
 	case "freshclam-log":
 		filePath = c.loadLogPath("freshclam-log")
-		if len(filePath) != 0 {
-			break
-		}
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			filePath = "/var/log/clamav/freshclam.log"
-		} else {
-			filePath = "/var/log/freshclam.log"
-		}
 	default:
 		return "", fmt.Errorf("not support such type")
 	}
@@ -432,23 +415,11 @@ func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
 
 func (c *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
 	filePath := ""
-	service := ""
 	switch req.Name {
 	case "clamd":
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			service = constant.ClamServiceNameUbuntu
-			filePath = "/etc/clamav/clamd.conf"
-		} else {
-			service = constant.ClamServiceNameCentOs
-			filePath = "/etc/clamd.d/scan.conf"
-		}
+		filePath = c.loadConfigPath("clamd")
 	case "freshclam":
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			filePath = "/etc/clamav/freshclam.conf"
-		} else {
-			filePath = "/etc/freshclam.conf"
-		}
-		service = "clamav-freshclam.service"
+		filePath = c.loadConfigPath("freshclam")
 	default:
 		return fmt.Errorf("not support such type")
 	}
@@ -461,50 +432,65 @@ func (c *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
 	_, _ = write.WriteString(req.File)
 	write.Flush()
 
-	_ = systemctl.Restart(service)
+	_ = controller.HandleRestart(c.serviceName)
 	return nil
 }
 
 func (c *ClamService) loadLogPath(name string) string {
-	confPath := ""
-	if name == "clamd-log" {
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			confPath = "/etc/clamav/clamd.conf"
-		} else {
-			confPath = "/etc/clamd.d/scan.conf"
-		}
-	} else {
-		if c.serviceName == constant.ClamServiceNameUbuntu {
-			confPath = "/etc/clamav/freshclam.conf"
-		} else {
-			confPath = "/etc/freshclam.conf"
-		}
-	}
-	if _, err := os.Stat(confPath); err != nil {
-		return ""
+	configKey := "clamd"
+	searchPrefix := "LogFile "
+	if name != "clamd-log" {
+		configKey = "freshclam"
+		searchPrefix = "UpdateLogFile "
 	}
+	confPath := c.loadConfigPath(configKey)
 	content, err := os.ReadFile(confPath)
 	if err != nil {
+		global.LOG.Debugf("read config of %s failed, err: %v", configKey, err)
 		return ""
 	}
 	lines := strings.Split(string(content), "\n")
-	if name == "clamd-log" {
-		for _, line := range lines {
-			if strings.HasPrefix(line, "LogFile ") {
-				return strings.Trim(strings.ReplaceAll(line, "LogFile ", ""), " ")
-			}
-		}
-	} else {
-		for _, line := range lines {
-			if strings.HasPrefix(line, "UpdateLogFile ") {
-				return strings.Trim(strings.ReplaceAll(line, "UpdateLogFile ", ""), " ")
-			}
+	for _, line := range lines {
+		if strings.HasPrefix(line, searchPrefix) {
+			return strings.Trim(strings.ReplaceAll(line, searchPrefix, ""), " ")
+		}
+	}
+	if configKey == "clamd" {
+		if _, err := os.Stat("/var/log/clamav/clamav.log"); err == nil {
+			return "/var/log/clamav/clamav.log"
+		}
+		if _, err := os.Stat("/var/log/clamd.scan"); err == nil {
+			return "/var/log/clamd.scan"
+		}
+	}
+	if configKey == "freshclam" {
+		if _, err := os.Stat("/var/log/clamav/freshclam.log"); err == nil {
+			return "/var/log/clamav/freshclam.log"
+		}
+		if _, err := os.Stat("/var/log/freshclam.log"); err == nil {
+			return "/var/log/freshclam.log"
 		}
 	}
-
 	return ""
 }
 
+func (c *ClamService) loadConfigPath(confType string) string {
+	switch confType {
+	case "clamd":
+		if _, err := os.Stat("/etc/clamav/clamd.conf"); err == nil {
+			return "/etc/clamav/clamd.conf"
+		}
+		return "/etc/clamd.d/scan.conf"
+	case "freshclam":
+		if _, err := os.Stat("/etc/clamav/freshclam.conf"); err == nil {
+			return "/etc/clamav/freshclam.conf"
+		}
+		return "/etc/freshclam.conf"
+	default:
+		return ""
+	}
+}
+
 func handleAlert(infectedFiles, clamName string, clamId uint) {
 	itemInfected, _ := strconv.Atoi(strings.TrimSpace(infectedFiles))
 	if itemInfected < 0 {

agent/app/service/compose_template.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"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/jinzhu/copier"
@@ -12,8 +13,9 @@ type ComposeTemplateService struct{}
 type IComposeTemplateService interface {
 	List() ([]dto.ComposeTemplateInfo, error)
 	SearchWithPage(search dto.SearchWithPage) (int64, interface{}, error)
-	Create(composeDto dto.ComposeTemplateCreate) error
+	Create(req dto.ComposeTemplateCreate) error
 	Update(id uint, upMap map[string]interface{}) error
+	Batch(req dto.ComposeTemplateBatch) error
 	Delete(ids []uint) error
 }
 
@@ -64,6 +66,22 @@ func (u *ComposeTemplateService) Create(composeDto dto.ComposeTemplateCreate) er
 	return nil
 }
 
+func (u *ComposeTemplateService) Batch(req dto.ComposeTemplateBatch) error {
+	for _, item := range req.Templates {
+		template, _ := composeRepo.Get(repo.WithByName(item.Name))
+		if template.ID == 0 {
+			if err := composeRepo.Create(&model.ComposeTemplate{Name: item.Name, Content: item.Content, Description: item.Description}); err != nil {
+				return err
+			}
+		} else {
+			if err := composeRepo.Update(template.ID, map[string]interface{}{"content": item.Content, "description": item.Description}); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 func (u *ComposeTemplateService) Delete(ids []uint) error {
 	if len(ids) == 1 {
 		compose, _ := composeRepo.Get(repo.WithByID(ids[0]))

agent/app/service/container.go

@@ -12,7 +12,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -20,12 +19,8 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-	"github.com/gin-gonic/gin"
-
-	"github.com/pkg/errors"
-
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"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"
@@ -34,6 +29,8 @@ 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/1Panel-dev/1Panel/agent/utils/re"
+	"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"
@@ -44,7 +41,9 @@ import (
 	"github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/client"
 	"github.com/docker/go-connections/nat"
+	"github.com/gin-gonic/gin"
 	v1 "github.com/opencontainers/image-spec/specs-go/v1"
+	"github.com/pkg/errors"
 	"github.com/shirou/gopsutil/v4/cpu"
 	"github.com/shirou/gopsutil/v4/mem"
 )
@@ -69,6 +68,7 @@ type IContainerService interface {
 	ContainerUpgrade(req dto.ContainerUpgrade) error
 	ContainerInfo(req dto.OperationWithName) (*dto.ContainerOperate, error)
 	ContainerListStats() ([]dto.ContainerListStats, error)
+	ContainerItemStats(req dto.OperationWithName) (dto.ContainerItemStats, error)
 	LoadResourceLimit() (*dto.ResourceLimit, error)
 	ContainerRename(req dto.ContainerRename) error
 	ContainerCommit(req dto.ContainerCommit) error
@@ -83,6 +83,7 @@ type IContainerService interface {
 	CreateVolume(req dto.VolumeCreate) error
 	TestCompose(req dto.ComposeCreate) (bool, error)
 	ComposeUpdate(req dto.ComposeUpdate) error
+	ComposeLogClean(req dto.ComposeLogClean) error
 	Prune(req dto.ContainerPrune) error
 
 	LoadUsers(req dto.OperationWithName) []string
@@ -95,18 +96,12 @@ func NewIContainerService() IContainerService {
 }
 
 func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, error) {
-	var (
-		records []container.Summary
-		list    []container.Summary
-	)
 	client, err := docker.NewDockerClient()
 	if err != nil {
 		return 0, nil, err
 	}
 	defer client.Close()
-	options := container.ListOptions{
-		All: true,
-	}
+	options := container.ListOptions{All: true}
 	if len(req.Filters) != 0 {
 		options.Filters = filters.NewArgs()
 		options.Filters.Add("label", req.Filters)
@@ -115,112 +110,32 @@ func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, erro
 	if err != nil {
 		return 0, nil, err
 	}
-	if req.ExcludeAppStore {
-		for _, item := range containers {
-			if created, ok := item.Labels[composeCreatedBy]; ok && created == "Apps" {
-				continue
-			}
-			list = append(list, item)
-		}
-	} else {
-		list = containers
-	}
+	records := searchWithFilter(req, containers)
 
-	if len(req.Name) != 0 {
-		length, count := len(list), 0
-		for count < length {
-			if !strings.Contains(list[count].Names[0][1:], req.Name) && !strings.Contains(list[count].Image, req.Name) {
-				list = append(list[:count], list[(count+1):]...)
-				length--
-			} else {
-				count++
-			}
-		}
-	}
-	if req.State != "all" {
-		length, count := len(list), 0
-		for count < length {
-			if list[count].State != req.State {
-				list = append(list[:count], list[(count+1):]...)
-				length--
-			} else {
-				count++
-			}
-		}
-	}
-	switch req.OrderBy {
-	case "name":
-		sort.Slice(list, func(i, j int) bool {
-			if req.Order == constant.OrderAsc {
-				return list[i].Names[0][1:] < list[j].Names[0][1:]
-			}
-			return list[i].Names[0][1:] > list[j].Names[0][1:]
-		})
-	default:
-		sort.Slice(list, func(i, j int) bool {
-			if req.Order == constant.OrderAsc {
-				return list[i].Created < list[j].Created
-			}
-			return list[i].Created > list[j].Created
-		})
-	}
-
-	total, start, end := len(list), (req.Page-1)*req.PageSize, req.Page*req.PageSize
+	var backData []dto.ContainerInfo
+	total, start, end := len(records), (req.Page-1)*req.PageSize, req.Page*req.PageSize
 	if start > total {
-		records = make([]container.Summary, 0)
+		backData = make([]dto.ContainerInfo, 0)
 	} else {
 		if end >= total {
 			end = total
 		}
-		records = list[start:end]
+		backData = records[start:end]
 	}
 
-	backDatas := make([]dto.ContainerInfo, len(records))
-	for i := 0; i < len(records); i++ {
-		item := records[i]
-		IsFromCompose := false
-		if _, ok := item.Labels[composeProjectLabel]; ok {
-			IsFromCompose = true
-		}
-		IsFromApp := false
-		if created, ok := item.Labels[composeCreatedBy]; ok && created == "Apps" {
-			IsFromApp = true
-		}
-
-		exposePorts := transPortToStr(records[i].Ports)
-		info := dto.ContainerInfo{
-			ContainerID:   item.ID,
-			CreateTime:    time.Unix(item.Created, 0).Format(constant.DateTimeLayout),
-			Name:          item.Names[0][1:],
-			ImageId:       strings.Split(item.ImageID, ":")[1],
-			ImageName:     item.Image,
-			State:         item.State,
-			RunTime:       item.Status,
-			Ports:         exposePorts,
-			IsFromApp:     IsFromApp,
-			IsFromCompose: IsFromCompose,
-		}
-		install, _ := appInstallRepo.GetFirst(appInstallRepo.WithContainerName(info.Name))
+	for i := 0; i < len(backData); i++ {
+		install, _ := appInstallRepo.GetFirst(appInstallRepo.WithContainerName(backData[i].Name))
 		if install.ID > 0 {
-			info.AppInstallName = install.Name
-			info.AppName = install.App.Name
+			backData[i].AppInstallName = install.Name
+			backData[i].AppName = install.App.Name
 			websites, _ := websiteRepo.GetBy(websiteRepo.WithAppInstallId(install.ID))
 			for _, website := range websites {
-				info.Websites = append(info.Websites, website.PrimaryDomain)
+				backData[i].Websites = append(backData[i].Websites, website.PrimaryDomain)
 			}
 		}
-		backDatas[i] = info
-		if item.NetworkSettings != nil && len(item.NetworkSettings.Networks) > 0 {
-			networks := make([]string, 0, len(item.NetworkSettings.Networks))
-			for key := range item.NetworkSettings.Networks {
-				networks = append(networks, item.NetworkSettings.Networks[key].IPAddress)
-			}
-			sort.Strings(networks)
-			backDatas[i].Network = networks
-		}
 	}
 
-	return int64(total), backDatas, nil
+	return int64(total), backData, nil
 }
 
 func (u *ContainerService) List() []dto.ContainerOptions {
@@ -282,10 +197,8 @@ func (u *ContainerService) LoadStatus() (dto.ContainerStatus, error) {
 	}
 	defer client.Close()
 	c := context.Background()
-	images, _ := client.ImageList(c, image.ListOptions{})
-	for _, image := range images {
-		data.ImageSize += uint64(image.Size)
-	}
+
+	images, _ := client.ImageList(c, image.ListOptions{All: true})
 	data.ImageCount = len(images)
 	repo, _ := imageRepoRepo.List()
 	data.RepoCount = len(repo)
@@ -296,11 +209,8 @@ func (u *ContainerService) LoadStatus() (dto.ContainerStatus, error) {
 	volumes, _ := client.VolumeList(c, volume.ListOptions{})
 	data.VolumeCount = len(volumes.Volumes)
 	data.ComposeCount = loadComposeCount(client)
-	containers, err := client.ContainerList(c, container.ListOptions{All: true})
-	if err != nil {
-		return data, err
-	}
-	data.All = uint(len(containers))
+	containers, _ := client.ContainerList(c, container.ListOptions{All: true})
+	data.ContainerCount = len(containers)
 	for _, item := range containers {
 		switch item.State {
 		case "created":
@@ -319,7 +229,50 @@ func (u *ContainerService) LoadStatus() (dto.ContainerStatus, error) {
 			data.Removing++
 		}
 	}
-	data.ContainerCount = int(data.All)
+	return data, nil
+}
+func (u *ContainerService) ContainerItemStats(req dto.OperationWithName) (dto.ContainerItemStats, error) {
+	var data dto.ContainerItemStats
+	client, err := docker.NewDockerClient()
+	if err != nil {
+		return data, err
+	}
+	if req.Name != "system" {
+		defer client.Close()
+		containerInfo, _, err := client.ContainerInspectWithRaw(context.Background(), req.Name, true)
+		if err != nil {
+			return data, err
+		}
+		data.SizeRw = *containerInfo.SizeRw
+		data.SizeRootFs = *containerInfo.SizeRootFs
+		return data, nil
+	}
+
+	usage, err := client.DiskUsage(context.Background(), types.DiskUsageOptions{})
+	if err != nil {
+		return data, err
+	}
+	for _, item := range usage.Images {
+		data.ImageUsage += item.Size
+		if item.Containers < 1 {
+			data.ImageReclaimable += item.Size
+		}
+	}
+	for _, item := range usage.Containers {
+		data.ContainerUsage += item.SizeRw
+		if item.State != "running" {
+			data.ContainerReclaimable += item.SizeRw
+		}
+	}
+	for _, item := range usage.Volumes {
+		data.VolumeUsage += item.UsageData.Size
+		if item.UsageData.RefCount == 0 {
+			data.VolumeReclaimable += item.UsageData.Size
+		}
+	}
+	for _, item := range usage.BuildCache {
+		data.BuildCacheUsage += item.Size
+	}
 	return data, nil
 }
 func (u *ContainerService) ContainerListStats() ([]dto.ContainerListStats, error) {
@@ -407,6 +360,9 @@ func (u *ContainerService) Inspect(req dto.InspectReq) (string, error) {
 		}
 		for _, container := range containers {
 			config := container.Labels[composeConfigLabel]
+			if len(req.Detail) != 0 && strings.Contains(config, req.Detail) {
+				config = req.Detail
+			}
 			workdir := container.Labels[composeWorkdirLabel]
 			if len(config) != 0 && len(workdir) != 0 && strings.Contains(config, workdir) {
 				filePath = config
@@ -478,6 +434,7 @@ func (u *ContainerService) Prune(req dto.ContainerPrune) error {
 				pruneFilters.Add("until", "24h")
 			}
 		}
+		taskItem.Log(i18n.GetMsgByKey("PruneStart"))
 		DeletedNumber := 0
 		SpaceReclaimed := 0
 		switch req.PruneType {
@@ -643,27 +600,27 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 	data.Name = strings.ReplaceAll(oldContainer.Name, "/", "")
 	data.Image = oldContainer.Config.Image
 	if oldContainer.NetworkSettings != nil {
-		for network := range oldContainer.NetworkSettings.Networks {
-			data.Network = network
-			break
+		for net, val := range oldContainer.NetworkSettings.Networks {
+			netItem := dto.ContainerNetwork{
+				Network: net,
+				MacAddr: val.MacAddress,
+			}
+			if val.IPAMConfig != nil {
+				if netItem.Network != "bridge" {
+					netItem.Ipv4 = val.IPAMConfig.IPv4Address
+					netItem.Ipv6 = val.IPAMConfig.IPv6Address
+				}
+			} else {
+				if netItem.Network != "bridge" {
+					netItem.Ipv4 = val.IPAddress
+				}
+			}
+			data.Networks = append(data.Networks, netItem)
 		}
 	}
 
 	exposePorts, _ := loadPortByInspect(oldContainer.ID, client)
 	data.ExposedPorts = loadContainerPortForInfo(exposePorts)
-	networkSettings := oldContainer.NetworkSettings
-	bridgeNetworkSettings := networkSettings.Networks[data.Network]
-	if bridgeNetworkSettings.IPAMConfig != nil {
-		data.MacAddr = bridgeNetworkSettings.MacAddress
-		if data.Network != "bridge" {
-			data.Ipv4 = bridgeNetworkSettings.IPAMConfig.IPv4Address
-			data.Ipv6 = bridgeNetworkSettings.IPAMConfig.IPv6Address
-		}
-	} else {
-		if data.Network != "bridge" {
-			data.Ipv4 = bridgeNetworkSettings.IPAddress
-		}
-	}
 	data.Hostname = oldContainer.Config.Hostname
 	data.DNS = oldContainer.HostConfig.DNS
 	data.DomainName = oldContainer.Config.Domainname
@@ -895,25 +852,36 @@ func (u *ContainerService) ContainerOperation(req dto.ContainerOperation) error
 		return err
 	}
 	defer client.Close()
-	for _, item := range req.Names {
-		global.LOG.Infof("start container %s operation %s", item, req.Operation)
-		switch req.Operation {
-		case constant.ContainerOpStart:
-			err = client.ContainerStart(ctx, item, container.StartOptions{})
-		case constant.ContainerOpStop:
-			err = client.ContainerStop(ctx, item, container.StopOptions{})
-		case constant.ContainerOpRestart:
-			err = client.ContainerRestart(ctx, item, container.StopOptions{})
-		case constant.ContainerOpKill:
-			err = client.ContainerKill(ctx, item, "SIGKILL")
-		case constant.ContainerOpPause:
-			err = client.ContainerPause(ctx, item)
-		case constant.ContainerOpUnpause:
-			err = client.ContainerUnpause(ctx, item)
-		case constant.ContainerOpRemove:
-			err = client.ContainerRemove(ctx, item, container.RemoveOptions{RemoveVolumes: true, Force: true})
-		}
+	taskItem, err := task.NewTaskWithOps(strings.Join(req.Names, " "), req.Operation, task.TaskScopeContainer, req.TaskID, 1)
+	if err != nil {
+		return fmt.Errorf("new task for container commit failed, err: %v", err)
 	}
+
+	for _, item := range req.Names {
+		taskItem.AddSubTask(item, func(t *task.Task) error {
+			switch req.Operation {
+			case constant.ContainerOpStart:
+				err = client.ContainerStart(ctx, item, container.StartOptions{})
+			case constant.ContainerOpStop:
+				err = client.ContainerStop(ctx, item, container.StopOptions{})
+			case constant.ContainerOpRestart:
+				err = client.ContainerRestart(ctx, item, container.StopOptions{})
+			case constant.ContainerOpKill:
+				err = client.ContainerKill(ctx, item, "SIGKILL")
+			case constant.ContainerOpPause:
+				err = client.ContainerPause(ctx, item)
+			case constant.ContainerOpUnpause:
+				err = client.ContainerUnpause(ctx, item)
+			case constant.ContainerOpRemove:
+				err = client.ContainerRemove(ctx, item, container.RemoveOptions{RemoveVolumes: true, Force: true})
+			}
+			return err
+		}, nil)
+	}
+
+	go func() {
+		_ = taskItem.Execute()
+	}()
 	return err
 }
 
@@ -1002,12 +970,18 @@ func collectLogs(done <-chan struct{}, params dto.StreamLog, messageChan chan<-
 
 	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...)
+		dockerComposeCmd := common.GetDockerComposeCommand()
+		var yamlFiles []string
+		for _, item := range strings.Split(params.Compose, ",") {
+			if len(item) != 0 {
+				yamlFiles = append(yamlFiles, "-f", item)
+			}
+		}
+		if dockerComposeCmd == "docker-compose" {
+			newCmdArgs := append(yamlFiles, cmdArgs...)
+			dockerCmd = exec.Command(dockerComposeCmd, newCmdArgs...)
 		} else {
-			newCmdArgs := append([]string{"compose", "-f", params.Compose}, cmdArgs...)
+			newCmdArgs := append(append([]string{"compose"}, yamlFiles...), cmdArgs...)
 			dockerCmd = exec.Command("docker", newCmdArgs...)
 		}
 	} else {
@@ -1087,10 +1061,16 @@ func (u *ContainerService) DownloadContainerLogs(containerType, container, since
 	commandArg := []string{"logs", container}
 	dockerCommand := global.CONF.DockerConfig.Command
 	if containerType == "compose" {
+		var yamlFiles []string
+		for _, item := range strings.Split(container, ",") {
+			if len(item) != 0 {
+				yamlFiles = append(yamlFiles, "-f", item)
+			}
+		}
 		if dockerCommand == "docker-compose" {
-			commandArg = []string{"-f", container, "logs"}
+			commandArg = append(yamlFiles, "logs")
 		} else {
-			commandArg = []string{"compose", "-f", container, "logs"}
+			commandArg = append(append([]string{"compose"}, yamlFiles...), "logs")
 		}
 	}
 
@@ -1132,7 +1112,7 @@ 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>`)
+		var ansiRegex = re.GetRegex(re.AnsiEscapePattern)
 		for scanner.Scan() {
 			line := scanner.Text()
 			cleanLine := ansiRegex.ReplaceAllString(line, "")
@@ -1177,10 +1157,8 @@ func (u *ContainerService) ContainerStats(id string) (*dto.ContainerStats, error
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		res.Body.Close()
 		return nil, err
 	}
-	res.Body.Close()
 	var stats *container.StatsResponse
 	if err := json.Unmarshal(body, &stats); err != nil {
 		return nil, err
@@ -1222,6 +1200,16 @@ func stringsToMap(list []string) map[string]string {
 	}
 	return labelMap
 }
+func stringsToMap2(list []string) map[string]*string {
+	var labelMap = make(map[string]*string)
+	for _, label := range list {
+		if strings.Contains(label, "=") {
+			sps := strings.SplitN(label, "=", 2)
+			labelMap[sps[0]] = &sps[1]
+		}
+	}
+	return labelMap
+}
 
 func calculateCPUPercentUnix(stats *container.StatsResponse) float64 {
 	cpuPercent := 0.0
@@ -1460,25 +1448,25 @@ func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *conta
 	config.User = req.User
 	config.WorkingDir = req.WorkingDir
 
-	if len(req.Network) != 0 {
-		switch req.Network {
-		case "host", "none", "bridge":
-			hostConf.NetworkMode = container.NetworkMode(req.Network)
-		}
-		if req.Ipv4 != "" || req.Ipv6 != "" {
-			networkConf.EndpointsConfig = map[string]*network.EndpointSettings{req.Network: {
-				IPAMConfig: &network.EndpointIPAMConfig{
-					IPv4Address: req.Ipv4,
-					IPv6Address: req.Ipv6,
-				}, MacAddress: req.MacAddr}}
-		} else {
-			networkConf.EndpointsConfig = map[string]*network.EndpointSettings{req.Network: {}}
+	if len(req.Networks) != 0 {
+		networkConf.EndpointsConfig = make(map[string]*network.EndpointSettings)
+		for _, item := range req.Networks {
+			switch item.Network {
+			case "host", "none", "bridge":
+				hostConf.NetworkMode = container.NetworkMode(item.Network)
+			}
+			if item.Ipv4 != "" || item.Ipv6 != "" {
+				networkConf.EndpointsConfig[item.Network] = &network.EndpointSettings{
+					IPAMConfig: &network.EndpointIPAMConfig{
+						IPv4Address: item.Ipv4,
+						IPv6Address: item.Ipv6,
+					}, MacAddress: item.MacAddr}
+			} else {
+				networkConf.EndpointsConfig[item.Network] = &network.EndpointSettings{}
+			}
 		}
 	} else {
-		if req.Ipv4 != "" || req.Ipv6 != "" {
-			return nil, nil, nil, fmt.Errorf("please set up the network")
-		}
-		networkConf = network.NetworkingConfig{}
+		return nil, nil, nil, fmt.Errorf("please set up the network")
 	}
 
 	hostConf.Privileged = req.Privileged
@@ -1726,3 +1714,105 @@ func loadContainerPortForInfo(itemPorts []container.Port) []dto.PortHelper {
 	}
 	return exposedPorts
 }
+
+func searchWithFilter(req dto.PageContainer, containers []container.Summary) []dto.ContainerInfo {
+	var (
+		records []dto.ContainerInfo
+		list    []container.Summary
+	)
+
+	if req.ExcludeAppStore {
+		for _, item := range containers {
+			if created, ok := item.Labels[composeCreatedBy]; ok && created == "Apps" {
+				continue
+			}
+			list = append(list, item)
+		}
+	} else {
+		list = containers
+	}
+
+	if len(req.Name) != 0 {
+		length, count := len(list), 0
+		for count < length {
+			if !strings.Contains(list[count].Names[0][1:], req.Name) && !strings.Contains(list[count].Image, req.Name) {
+				list = append(list[:count], list[(count+1):]...)
+				length--
+			} else {
+				count++
+			}
+		}
+	}
+	if req.State != "all" {
+		length, count := len(list), 0
+		for count < length {
+			if list[count].State != req.State {
+				list = append(list[:count], list[(count+1):]...)
+				length--
+			} else {
+				count++
+			}
+		}
+	}
+	switch req.OrderBy {
+	case "name":
+		sort.Slice(list, func(i, j int) bool {
+			if req.Order == constant.OrderAsc {
+				return list[i].Names[0][1:] < list[j].Names[0][1:]
+			}
+			return list[i].Names[0][1:] > list[j].Names[0][1:]
+		})
+	default:
+		sort.Slice(list, func(i, j int) bool {
+			if req.Order == constant.OrderAsc {
+				return list[i].Created < list[j].Created
+			}
+			return list[i].Created > list[j].Created
+		})
+	}
+	for _, item := range list {
+		IsFromCompose := false
+		if _, ok := item.Labels[composeProjectLabel]; ok {
+			IsFromCompose = true
+		}
+		IsFromApp := false
+		if created, ok := item.Labels[composeCreatedBy]; ok && created == "Apps" {
+			IsFromApp = true
+		}
+		exposePorts := transPortToStr(item.Ports)
+		info := dto.ContainerInfo{
+			ContainerID:   item.ID,
+			CreateTime:    time.Unix(item.Created, 0).Format(constant.DateTimeLayout),
+			Name:          item.Names[0][1:],
+			Ports:         exposePorts,
+			ImageId:       strings.Split(item.ImageID, ":")[1],
+			ImageName:     item.Image,
+			State:         item.State,
+			RunTime:       item.Status,
+			IsFromApp:     IsFromApp,
+			IsFromCompose: IsFromCompose,
+		}
+		if item.NetworkSettings != nil && len(item.NetworkSettings.Networks) > 0 {
+			networks := make([]string, 0, len(item.NetworkSettings.Networks))
+			for key := range item.NetworkSettings.Networks {
+				networks = append(networks, item.NetworkSettings.Networks[key].IPAddress)
+			}
+			sort.Strings(networks)
+			info.Network = networks
+		}
+		records = append(records, info)
+	}
+	descriptions, _ := settingRepo.GetDescriptionList(repo.WithByType("container"))
+	for i := 0; i < len(records); i++ {
+		for _, desc := range descriptions {
+			if desc.ID == records[i].ContainerID {
+				records[i].Description = desc.Description
+				records[i].IsPinned = desc.IsPinned
+			}
+		}
+	}
+	sort.Slice(records, func(i, j int) bool {
+		return records[i].IsPinned && !records[j].IsPinned
+	})
+	return records
+}

agent/app/service/container_compose.go

@@ -2,10 +2,12 @@ package service
 
 import (
 	"bufio"
+	"context"
 	"errors"
 	"fmt"
 	"os"
 	"path"
+	"path/filepath"
 	"sort"
 	"strings"
 	"time"
@@ -23,7 +25,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
-	"golang.org/x/net/context"
 )
 
 const composeProjectLabel = "com.docker.compose.project"
@@ -73,6 +74,7 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 				Name:        container.Names[0][1:],
 				State:       container.State,
 				CreateTime:  time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
+				Ports:       transPortToStr(container.Ports),
 			}
 			if compose, has := composeMap[name]; has {
 				compose.ContainerCount++
@@ -179,7 +181,7 @@ func (u *ContainerService) TestCompose(req dto.ComposeCreate) (bool, error) {
 	cmd := getComposeCmd(req.Path, "config")
 	stdout, err := cmd.CombinedOutput()
 	if err != nil {
-		return false, errors.New(string(stdout))
+		return false, fmt.Errorf("docker-compose config failed, std: %s, err: %v", string(stdout), err)
 	}
 	return true, nil
 }
@@ -203,14 +205,13 @@ func (u *ContainerService) CreateCompose(req dto.ComposeCreate) error {
 	}
 	go func() {
 		taskItem.AddSubTask(i18n.GetMsgByKey("ComposeCreate"), func(t *task.Task) error {
-			cmd := getComposeCmd(req.Path, "up")
-			out, err := cmd.CombinedOutput()
-			taskItem.Log(i18n.GetWithName("ComposeCreateRes", string(out)))
+			err := compose.UpWithTask(req.Path, t)
+			t.LogWithStatus(i18n.GetMsgByKey("ComposeCreate"), err)
 			if err != nil {
 				_, _ = compose.Down(req.Path)
 				return err
 			}
-			_ = composeRepo.CreateRecord(&model.Compose{Name: req.Name, Path: req.Path})
+			_ = composeRepo.CreateRecord(&model.Compose{Name: strings.ToLower(req.Name), Path: req.Path})
 			return nil
 		}, nil)
 		_ = taskItem.Execute()
@@ -232,24 +233,24 @@ func (u *ContainerService) ComposeOperation(req dto.ComposeOperation) error {
 			return err
 		}
 		if req.WithFile {
-			_ = os.RemoveAll(path.Dir(req.Path))
+			for _, item := range strings.Split(req.Path, ",") {
+				if len(item) != 0 {
+					_ = os.RemoveAll(path.Dir(item))
+				}
+			}
 		}
 		_ = composeRepo.DeleteRecord(repo.WithByName(req.Name))
 		return nil
 	}
-	if _, err := os.Stat(req.Path); err != nil {
-		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
-	}
 	if req.Operation == "up" {
 		if stdout, err := compose.Up(req.Path); err != nil {
-			return errors.New(string(stdout))
+			return fmt.Errorf("docker-compose up failed, std: %s, err: %v", stdout, err)
 		}
 	} else {
 		if stdout, err := compose.Operate(req.Path, req.Operation); err != nil {
-			return errors.New(string(stdout))
+			return fmt.Errorf("docker-compose %s failed, std: %s, err: %v", req.Operation, stdout, err)
 		}
 	}
-	global.LOG.Infof("docker-compose %s %s successful", req.Operation, req.Name)
 	return nil
 }
 
@@ -257,11 +258,11 @@ func (u *ContainerService) ComposeUpdate(req dto.ComposeUpdate) error {
 	if cmd.CheckIllegal(req.Name, req.Path) {
 		return buserr.New("ErrCmdIllegal")
 	}
-	oldFile, err := os.ReadFile(req.Path)
+	oldFile, err := os.ReadFile(req.DetailPath)
 	if err != nil {
-		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
+		return fmt.Errorf("load file with path %s failed, %v", req.DetailPath, err)
 	}
-	file, err := os.OpenFile(req.Path, os.O_WRONLY|os.O_TRUNC, 0640)
+	file, err := os.OpenFile(req.DetailPath, os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
 		return err
 	}
@@ -270,21 +271,73 @@ func (u *ContainerService) ComposeUpdate(req dto.ComposeUpdate) error {
 	_, _ = write.WriteString(req.Content)
 	write.Flush()
 
-	global.LOG.Infof("docker-compose.yml %s has been replaced, now start to docker-compose restart", req.Path)
-	if err := newComposeEnv(req.Path, req.Env); err != nil {
+	global.LOG.Infof("docker-compose.yml %s has been replaced, now start to docker-compose restart", req.DetailPath)
+	if err := newComposeEnv(req.DetailPath, req.Env); err != nil {
 		return err
 	}
 
 	if stdout, err := compose.Up(req.Path); err != nil {
+		global.LOG.Errorf("update failed when handle compose up, std: %s, err: %s, now try to recreate the old compose file", stdout, err)
 		if err := recreateCompose(string(oldFile), req.Path); err != nil {
-			return fmt.Errorf("update failed when handle compose up, err: %s, recreate failed: %v", string(stdout), err)
+			return fmt.Errorf("update failed and recreate old compose file also failed, err: %v", err)
 		}
-		return fmt.Errorf("update failed when handle compose up, err: %s", string(stdout))
+		return fmt.Errorf("update failed when handle compose up, std: %v, err: %s", stdout, err)
 	}
 
 	return nil
 }
 
+func (u *ContainerService) ComposeLogClean(req dto.ComposeLogClean) error {
+	client, err := docker.NewDockerClient()
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	options := container.ListOptions{All: true}
+	options.Filters = filters.NewArgs()
+	options.Filters.Add("label", composeProjectLabel)
+
+	list, err := client.ContainerList(context.Background(), options)
+	if err != nil {
+		return err
+	}
+	ctx := context.Background()
+	for _, item := range list {
+		if name, ok := item.Labels[composeProjectLabel]; ok {
+			if name != req.Name {
+				continue
+			}
+			containerItem, err := client.ContainerInspect(ctx, item.ID)
+			if err != nil {
+				return err
+			}
+			if err := client.ContainerStop(ctx, containerItem.ID, container.StopOptions{}); err != nil {
+				return err
+			}
+			file, err := os.OpenFile(containerItem.LogPath, os.O_RDWR|os.O_CREATE, constant.FilePerm)
+			if err != nil {
+				return err
+			}
+			defer file.Close()
+			if err = file.Truncate(0); err != nil {
+				return err
+			}
+			_, _ = file.Seek(0, 0)
+
+			files, _ := filepath.Glob(fmt.Sprintf("%s.*", containerItem.LogPath))
+			for _, file := range files {
+				_ = os.Remove(file)
+			}
+		}
+	}
+	return u.ComposeOperation(dto.ComposeOperation{
+		Name:      req.Name,
+		Path:      req.Path,
+		Operation: "restart",
+	})
+}
+
 func (u *ContainerService) loadPath(req *dto.ComposeCreate) error {
 	if req.From == "template" || req.From == "edit" {
 		dir := fmt.Sprintf("%s/docker/compose/%s", global.Dir.DataDir, req.Name)
@@ -309,11 +362,8 @@ func (u *ContainerService) loadPath(req *dto.ComposeCreate) error {
 }
 
 func removeContainerForCompose(composeName, composePath string) error {
-	if _, err := os.Stat(composePath); err == nil {
-		if stdout, err := compose.Operate(composePath, "down"); err != nil {
-			return errors.New(stdout)
-		}
-		return nil
+	if stdout, err := compose.Operate(composePath, "down"); err != nil {
+		return errors.New(stdout)
 	}
 	var options container.ListOptions
 	options.All = true
@@ -353,40 +403,31 @@ func recreateCompose(content, path string) error {
 
 func loadEnv(list []dto.ComposeInfo) []dto.ComposeInfo {
 	for i := 0; i < len(list); i++ {
-		envFilePath := path.Join(path.Dir(list[i].Path), "1panel.env")
+		tmpPath := list[i].Path
+		if strings.Contains(list[i].Path, ",") {
+			tmpPath = strings.Split(list[i].Path, ",")[0]
+		}
+		envFilePath := path.Join(path.Dir(tmpPath), ".env")
 		file, err := os.ReadFile(envFilePath)
 		if err != nil {
 			continue
 		}
-		lines := strings.Split(string(file), "\n")
-		for _, line := range lines {
-			lineItem := strings.TrimSpace(line)
-			if len(lineItem) != 0 && !strings.HasPrefix(lineItem, "#") {
-				list[i].Env = append(list[i].Env, lineItem)
-			}
-		}
+		list[i].Env = string(file)
 	}
 	return list
 }
 
-func newComposeEnv(pathItem string, env []string) error {
-	if len(env) == 0 {
-		return nil
-	}
-	envFilePath := path.Join(path.Dir(pathItem), "1panel.env")
+func newComposeEnv(pathItem string, env string) error {
+	envFilePath := path.Join(path.Dir(pathItem), ".env")
 	file, err := os.OpenFile(envFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, constant.FilePerm)
 	if err != nil {
 		global.LOG.Errorf("failed to create env file: %v", err)
 		return err
 	}
 	defer file.Close()
-	for _, env := range env {
-		envItem := strings.TrimSpace(env)
-		if _, err := file.WriteString(fmt.Sprintf("%s\n", envItem)); err != nil {
-			global.LOG.Errorf("failed to write env to file: %v", err)
-			return err
-		}
+	if _, err := file.WriteString(env); err != nil {
+		global.LOG.Errorf("failed to write env to file: %v", err)
+		return err
 	}
-	global.LOG.Infof("1panel.env file successfully created or updated with env variables in %s", envFilePath)
 	return nil
 }

agent/app/service/container_network.go

@@ -117,10 +117,8 @@ func (u *ContainerService) CreateNetwork(req dto.NetworkCreate) error {
 		return err
 	}
 	defer client.Close()
-	var (
-		ipams    []network.IPAMConfig
-		enableV6 bool
-	)
+	var ipams []network.IPAMConfig
+
 	if req.Ipv4 {
 		var itemIpam network.IPAMConfig
 		if len(req.AuxAddress) != 0 {
@@ -141,7 +139,6 @@ func (u *ContainerService) CreateNetwork(req dto.NetworkCreate) error {
 		ipams = append(ipams, itemIpam)
 	}
 	if req.Ipv6 {
-		enableV6 = true
 		var itemIpam network.IPAMConfig
 		if len(req.AuxAddress) != 0 {
 			itemIpam.AuxAddress = make(map[string]string)
@@ -162,7 +159,7 @@ func (u *ContainerService) CreateNetwork(req dto.NetworkCreate) error {
 	}
 
 	options := network.CreateOptions{
-		EnableIPv6: &enableV6,
+		EnableIPv6: &req.Ipv6,
 		Driver:     req.Driver,
 		Options:    stringsToMap(req.Options),
 		Labels:     stringsToMap(req.Labels),

agent/app/service/container_volume.go

@@ -5,7 +5,6 @@ import (
 	"sort"
 	"strings"
 	"time"
-	"unicode"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/buserr"
@@ -20,6 +19,7 @@ func (u *ContainerService) PageVolume(req dto.SearchWithPage) (int64, interface{
 	if err != nil {
 		return 0, nil, err
 	}
+	defer client.Close()
 	list, err := client.VolumeList(context.TODO(), volume.ListOptions{})
 	if err != nil {
 		return 0, nil, err
@@ -57,7 +57,7 @@ func (u *ContainerService) PageVolume(req dto.SearchWithPage) (int64, interface{
 		var volume dto.Volume
 		volume.Driver = item.Driver
 		volume.Mountpoint = item.Mountpoint
-		volume.Name = simplifyVolumeName(item.Name)
+		volume.Name = item.Name
 		for key, val := range item.Labels {
 			volume.Labels = append(volume.Labels, dto.VolumeOption{Key: key, Value: val})
 		}
@@ -143,16 +143,3 @@ func (u *ContainerService) CreateVolume(req dto.VolumeCreate) error {
 	}
 	return nil
 }
-
-func simplifyVolumeName(name string) string {
-	if len(name) != 64 {
-		return name
-	}
-
-	for _, char := range name {
-		if !unicode.Is(unicode.ASCII_Hex_Digit, char) {
-			return name
-		}
-	}
-	return name[:12]
-}

agent/app/service/cronjob.go

@@ -108,6 +108,9 @@ func (u *CronjobService) LoadInfo(req dto.OperateByID) (*dto.CronjobOperate, err
 	if cronjob.Type == "snapshot" && len(cronjob.SnapshotRule) != 0 {
 		_ = json.Unmarshal([]byte(cronjob.SnapshotRule), &item.SnapshotRule)
 	}
+	if cronjob.Type == "cleanLog" {
+		_ = json.Unmarshal([]byte(cronjob.Config), &item.CleanLogConfig)
+	}
 	return &item, err
 }
 
@@ -444,7 +447,7 @@ func (u *CronjobService) SearchRecords(search dto.SearchRecord) (int64, interfac
 func (u *CronjobService) LoadNextHandle(specStr string) ([]string, error) {
 	spec := cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)
 	now := time.Now()
-	var nexts [5]string
+	var next [5]string
 	if strings.HasPrefix(specStr, "@every ") {
 		duration := time.Minute
 		if strings.HasSuffix(specStr, "s") {
@@ -459,10 +462,10 @@ func (u *CronjobService) LoadNextHandle(specStr string) ([]string, error) {
 		}
 		for i := 0; i < 5; i++ {
 			nextTime := now.Add(time.Duration(durationItem) * duration)
-			nexts[i] = nextTime.Format(constant.DateTimeLayout)
+			next[i] = nextTime.Format(constant.DateTimeLayout)
 			now = nextTime
 		}
-		return nexts[:], nil
+		return next[:], nil
 	}
 	sched, err := spec.Parse(specStr)
 	if err != nil {
@@ -470,10 +473,10 @@ func (u *CronjobService) LoadNextHandle(specStr string) ([]string, error) {
 	}
 	for i := 0; i < 5; i++ {
 		nextTime := sched.Next(now)
-		nexts[i] = nextTime.Format(constant.DateTimeLayout)
+		next[i] = nextTime.Format(constant.DateTimeLayout)
 		now = nextTime
 	}
-	return nexts[:], nil
+	return next[:], nil
 }
 
 func (u *CronjobService) LoadRecordLog(req dto.OperateByID) string {
@@ -577,6 +580,10 @@ func (u *CronjobService) Create(req dto.CronjobOperate) error {
 	}
 	cronjob.Spec = spec
 	cronjob.EntryIDs = entryIDs
+	if req.Type == "cleanLog" {
+		config, _ := json.Marshal(req.CleanLogConfig)
+		cronjob.Config = string(config)
+	}
 	if err := cronjobRepo.Create(&cronjob); err != nil {
 		return err
 	}
@@ -626,8 +633,8 @@ func (u *CronjobService) HandleStop(id uint) error {
 	if len(record.TaskID) == 0 {
 		return nil
 	}
-	if cancle, ok := global.TaskCtxMap[record.TaskID]; ok {
-		cancle()
+	if cancel, ok := global.TaskCtxMap[record.TaskID]; ok {
+		cancel()
 	}
 	return nil
 }

agent/app/service/cronjob_backup.go

@@ -13,6 +13,7 @@ import (
 
 	"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/i18n"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
@@ -21,7 +22,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
-	"github.com/pkg/errors"
 )
 
 func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
@@ -32,7 +32,7 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, t
 	}
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, app := range apps {
 		retry := 0
@@ -90,7 +90,7 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 	}
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, web := range webs {
 		retry := 0
@@ -149,7 +149,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 	}
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, dbInfo := range dbs {
 		retry := 0
@@ -167,7 +167,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
 			record.FileName = simplifiedFileName(fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)))
 			if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" || cronjob.DBType == "mysql-cluster" {
-				if err := doMysqlBackup(dbInfo, backupDir, record.FileName); err != nil {
+				if err := doMysqlBackup(dbInfo, backupDir, record.FileName, cronjob.Secret); err != nil {
 					if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 						retry++
 						return err
@@ -178,7 +178,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 					}
 				}
 			} else {
-				if err := doPostgresqlgBackup(dbInfo, backupDir, record.FileName); err != nil {
+				if err := doPostgresqlBackup(dbInfo, backupDir, record.FileName, cronjob.Secret, taskItem); err != nil {
 					if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 						retry++
 						return err
@@ -217,7 +217,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	taskItem.AddSubTaskWithOps(task.GetTaskName(cronjob.SourceDir, task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 		fileName := fmt.Sprintf("%s.tar.gz", startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(2))
@@ -267,7 +267,7 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	taskItem.AddSubTaskWithOps(task.GetTaskName(i18n.GetMsgByKey("SystemLog"), task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 		nameItem := startTime.Format(constant.DateTimeSlimLayout) + common.RandStrAndNum(5)
@@ -303,7 +303,7 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.JobRecords, taskItem *task.Task) error {
 	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	var record model.BackupRecord
 	record.Status = constant.StatusSuccess
@@ -440,10 +440,10 @@ func loadDbsForJob(cronjob model.Cronjob) []DatabaseHelper {
 }
 
 func loadWebsForJob(cronjob model.Cronjob) []model.Website {
-	var weblist []model.Website
+	var list []model.Website
 	if cronjob.Website == "all" {
-		weblist, _ = websiteRepo.List()
-		return weblist
+		list, _ = websiteRepo.List()
+		return list
 	}
 	websites := strings.Split(cronjob.Website, ",")
 	var idItems []uint
@@ -451,8 +451,8 @@ func loadWebsForJob(cronjob model.Cronjob) []model.Website {
 		itemID, _ := strconv.Atoi(websites[i])
 		idItems = append(idItems, uint(itemID))
 	}
-	weblist, _ = websiteRepo.GetBy(repo.WithByIDs(idItems))
-	return weblist
+	list, _ = websiteRepo.GetBy(repo.WithByIDs(idItems))
+	return list
 }
 
 func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret string) error {

agent/app/service/cronjob_helper.go

@@ -1,16 +1,20 @@
 package service
 
 import (
+	"bufio"
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
+	"net/http"
 	"os"
-	"path"
 	pathUtils "path"
+	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
-	"github.com/pkg/errors"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
@@ -60,7 +64,7 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 		return
 	}
 	if err = u.loadTask(cronjob, &record, taskItem); err != nil {
-		global.LOG.Debugf("preper to handle cron job [%s] %s failed, err: %v", cronjob.Type, cronjob.Name, err)
+		global.LOG.Debugf("prepare to handle cron job [%s] %s failed, err: %v", cronjob.Type, cronjob.Name, err)
 		item, _ := taskRepo.GetFirst(taskRepo.WithByID(record.TaskID))
 		if len(item.ID) == 0 {
 			record.TaskID = ""
@@ -127,6 +131,10 @@ func (u *CronjobService) loadTask(cronjob *model.Cronjob, record *model.JobRecor
 		err = u.handleDirectory(*cronjob, record.StartTime, taskItem)
 	case "log":
 		err = u.handleSystemLog(*cronjob, record.StartTime, taskItem)
+	case "syncIpGroup":
+		u.handleSyncIpGroup(*cronjob, taskItem)
+	case "cleanLog":
+		u.handleCleanLog(*cronjob, taskItem)
 	}
 	return err
 }
@@ -138,7 +146,7 @@ func (u *CronjobService) handleShell(cronjob model.Cronjob, taskItem *task.Task)
 		if len(cronjob.ContainerName) != 0 {
 			scriptItem := cronjob.Script
 			if cronjob.ScriptMode == "select" {
-				scriptItem = path.Join("/tmp", path.Base(cronjob.Script))
+				scriptItem = pathUtils.Join("/tmp", pathUtils.Base(cronjob.Script))
 				if err := cmdMgr.Run("docker", "cp", cronjob.Script, cronjob.ContainerName+":"+scriptItem); err != nil {
 					return err
 				}
@@ -186,10 +194,17 @@ func (u *CronjobService) handleShell(cronjob model.Cronjob, taskItem *task.Task)
 }
 
 func (u *CronjobService) handleCurl(cronjob model.Cronjob, taskItem *task.Task) {
-	taskItem.AddSubTaskWithOps(i18n.GetWithName("HandleShell", cronjob.Name), func(t *task.Task) error {
-		cmdMgr := cmd.NewCommandMgr(cmd.WithTask(*taskItem))
-		return cmdMgr.Run("curl", cronjob.URL)
-	}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
+	urls := strings.Split(cronjob.URL, ",")
+	for _, url := range urls {
+		if len(strings.TrimSpace(url)) == 0 {
+			continue
+		}
+		taskItem.AddSubTaskWithOps(i18n.GetWithName("HandleCurl", url), func(t *task.Task) error {
+			taskItem.LogStart(i18n.GetWithName("HandleCurl", url))
+			cmdMgr := cmd.NewCommandMgr(cmd.WithTask(*taskItem))
+			return cmdMgr.Run("curl", url)
+		}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
+	}
 }
 
 func (u *CronjobService) handleNtpSync(cronjob model.Cronjob, taskItem *task.Task) {
@@ -210,10 +225,124 @@ func (u *CronjobService) handleNtpSync(cronjob model.Cronjob, taskItem *task.Tas
 	}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 }
 
+func (u *CronjobService) handleCleanLog(cronjob model.Cronjob, taskItem *task.Task) {
+	taskItem.AddSubTaskWithOps(i18n.GetWithName("CleanLog", cronjob.Name), func(t *task.Task) error {
+		config := GetCleanLogConfig(cronjob)
+		for _, scope := range config.Scopes {
+			switch scope {
+			case "website":
+				websites, _ := websiteRepo.List()
+				for _, website := range websites {
+					curStr := i18n.GetWithName("CleanLogByName", website.PrimaryDomain)
+					t.LogStart(curStr)
+					accessLogPath := GetSitePath(website, SiteAccessLog)
+					if err := os.Truncate(accessLogPath, 0); err != nil {
+						t.LogFailedWithErr(curStr, err)
+						continue
+					}
+					errLogPath := GetSitePath(website, SiteErrorLog)
+					if err := os.Truncate(errLogPath, 0); err != nil {
+						t.LogFailedWithErr(curStr, err)
+						continue
+					}
+					t.LogSuccess(curStr)
+				}
+				appInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+				if appInstall.ID > 0 {
+					curStr := i18n.GetWithName("CleanLogByName", "OpenResty")
+					t.LogStart(curStr)
+					accessLogPath := pathUtils.Join(appInstall.GetPath(), "log", "access.log")
+					if err := os.Truncate(accessLogPath, 0); err != nil {
+						t.LogFailedWithErr(curStr, err)
+					}
+					errLogPath := pathUtils.Join(appInstall.GetPath(), "log", "error.log")
+					if err := os.Truncate(errLogPath, 0); err != nil {
+						t.LogFailedWithErr(curStr, err)
+					}
+					t.LogSuccess(curStr)
+				}
+			}
+		}
+		return nil
+	}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
+}
+
+func (u *CronjobService) handleSyncIpGroup(cronjob model.Cronjob, taskItem *task.Task) {
+	taskItem.AddSubTaskWithOps(i18n.GetWithName("SyncIpGroup", cronjob.Name), func(t *task.Task) error {
+		appInstall, err := getAppInstallByKey(constant.AppOpenresty)
+		if err != nil {
+			return err
+		}
+		ipGroupDir := pathUtils.Join(appInstall.GetPath(), "1pwaf", "data", "rules", "ip_group")
+		urlDir := pathUtils.Join(ipGroupDir, "ip_group_url")
+		_, err = os.Stat(urlDir)
+		if err != nil && os.IsNotExist(err) {
+			return buserr.New("WafIpGroupNotFound")
+		}
+
+		urlsFiles, err := os.ReadDir(urlDir)
+		if err != nil {
+			return err
+		}
+		for _, file := range urlsFiles {
+			if file.IsDir() || !strings.HasSuffix(file.Name(), "_url") {
+				continue
+			}
+			urlFilePath := filepath.Join(urlDir, file.Name())
+
+			urlContent, err := os.ReadFile(urlFilePath)
+			if err != nil {
+				continue
+			}
+			remoteURL := strings.TrimSpace(string(urlContent))
+			if remoteURL == "" {
+				continue
+			}
+			resp, err := http.Get(remoteURL)
+			if err != nil {
+				continue
+			}
+
+			ipGroupFile := strings.TrimSuffix(file.Name(), "_url")
+			ipGroupPath := filepath.Join(ipGroupDir, ipGroupFile)
+
+			if resp.StatusCode != http.StatusOK {
+				resp.Body.Close()
+				taskItem.Logf("get remote ip group %s failed %s status code %d", ipGroupFile, remoteURL, resp.StatusCode)
+				continue
+			}
+
+			outFile, err := os.OpenFile(ipGroupPath, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
+			if err != nil {
+				resp.Body.Close()
+				taskItem.Logf("sync %s failed %v", ipGroupFile, err)
+				continue
+			}
+
+			writer := bufio.NewWriter(outFile)
+			_, err = io.Copy(writer, resp.Body)
+			if err != nil {
+				outFile.Close()
+				resp.Body.Close()
+				taskItem.Logf("sync %s failed , write file failed %v", ipGroupFile, err)
+				continue
+			}
+			writer.Flush()
+			outFile.Close()
+			resp.Body.Close()
+			taskItem.LogSuccess(i18n.Get("TaskSync") + " " + ipGroupFile)
+		}
+		if err := opNginx(appInstall.ContainerName, constant.NginxReload); err != nil {
+			return err
+		}
+		return nil
+	}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
+}
+
 func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	clientMap := NewBackupClientMap([]string{fmt.Sprintf("%v", cronjob.DownloadAccountID)})
 	if !clientMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
-		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", clientMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+		return buserr.New(i18n.GetMsgWithDetail("LoadBackupFailed", clientMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	taskItem.AddSubTaskWithOps(i18n.GetWithName("CutWebsiteLog", cronjob.Name), func(t *task.Task) error {
 		websites := loadWebsForJob(*cronjob)
@@ -343,9 +472,9 @@ func (u *CronjobService) removeExpiredLog(cronjob model.Cronjob) {
 				_ = os.Remove(file)
 			}
 		}
-		_ = cronjobRepo.DeleteRecord(repo.WithByID(uint(records[i].ID)))
+		_ = cronjobRepo.DeleteRecord(repo.WithByID(records[i].ID))
 		_ = taskRepo.Delete(taskRepo.WithByID(records[i].TaskID))
-		_ = os.Remove(path.Join(global.CONF.Base.InstallDir, "1panel/log/task/Cronjob", records[i].TaskID+".log"))
+		_ = os.Remove(pathUtils.Join(global.CONF.Base.InstallDir, "1panel/log/task/Cronjob", records[i].TaskID+".log"))
 	}
 }
 
@@ -362,3 +491,9 @@ func handleCronJobAlert(cronjob *model.Cronjob) {
 	}
 	_ = alert_push.PushAlert(pushAlert)
 }
+
+func GetCleanLogConfig(cronJob model.Cronjob) dto.CleanLogConfig {
+	config := &dto.CleanLogConfig{}
+	_ = json.Unmarshal([]byte(cronJob.Config), config)
+	return *config
+}

agent/app/service/dashboard.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"cmp"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -21,11 +22,11 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/ai_tools/xpu"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
+	"github.com/1Panel-dev/1Panel/agent/utils/controller"
 	"github.com/1Panel-dev/1Panel/agent/utils/copier"
+	"github.com/1Panel-dev/1Panel/agent/utils/psutil"
 	"github.com/gin-gonic/gin"
-	"github.com/shirou/gopsutil/v4/cpu"
 	"github.com/shirou/gopsutil/v4/disk"
-	"github.com/shirou/gopsutil/v4/host"
 	"github.com/shirou/gopsutil/v4/load"
 	"github.com/shirou/gopsutil/v4/mem"
 	"github.com/shirou/gopsutil/v4/net"
@@ -38,6 +39,8 @@ type IDashboardService interface {
 	LoadBaseInfo(ioOption string, netOption string) (*dto.DashboardBase, error)
 	LoadCurrentInfoForNode() *dto.NodeCurrent
 	LoadCurrentInfo(ioOption string, netOption string) *dto.DashboardCurrent
+	LoadTopCPU() []dto.Process
+	LoadTopMem() []dto.Process
 
 	LoadQuickOptions() []dto.QuickJump
 	ChangeQuick(req dto.ChangeQuicks) error
@@ -53,28 +56,30 @@ func NewIDashboardService() IDashboardService {
 }
 
 func (u *DashboardService) Restart(operation string) error {
-	if operation != "1panel" && operation != "system" && operation != "1panel-agent" {
+	switch operation {
+	case "system":
+		{
+			go func() {
+				if err := cmd.RunDefaultBashCf("%s reboot", cmd.SudoHandleCmd()); err != nil {
+					global.LOG.Errorf("handle reboot failed, %v", err)
+				}
+			}()
+			return nil
+		}
+	case "1panel-agent":
+		controller.RestartPanel(false, true, false)
+		return nil
+	case "1panel":
+		controller.RestartPanel(true, true, false)
+		return nil
+	default:
 		return fmt.Errorf("handle restart operation %s failed, err: nonsupport such operation", operation)
 	}
-	itemCmd := fmt.Sprintf("%s systemctl restart 1panel-agent.service && %s systemctl restart 1panel-core.service", cmd.SudoHandleCmd(), cmd.SudoHandleCmd())
-	if operation == "system" {
-		itemCmd = fmt.Sprintf("%s reboot", cmd.SudoHandleCmd())
-	}
-	if operation == "1panel-agent" {
-		itemCmd = fmt.Sprintf("%s systemctl restart 1panel-agent.service", cmd.SudoHandleCmd())
-	}
-	go func() {
-		stdout, err := cmd.RunDefaultWithStdoutBashC(itemCmd)
-		if err != nil {
-			global.LOG.Errorf("handle %s failed, err: %v", itemCmd, stdout)
-		}
-	}()
-	return nil
 }
 
 func (u *DashboardService) LoadOsInfo() (*dto.OsInfo, error) {
 	var baseInfo dto.OsInfo
-	hostInfo, err := host.Info()
+	hostInfo, err := psutil.HOST.GetHostInfo(false)
 	if err != nil {
 		return nil, err
 	}
@@ -83,8 +88,9 @@ func (u *DashboardService) LoadOsInfo() (*dto.OsInfo, error) {
 	baseInfo.PlatformFamily = hostInfo.PlatformFamily
 	baseInfo.KernelArch = hostInfo.KernelArch
 	baseInfo.KernelVersion = hostInfo.KernelVersion
+	baseInfo.PrettyDistro = psutil.HOST.GetDistro()
 
-	diskInfo, err := disk.Usage(global.Dir.BaseDir)
+	diskInfo, err := psutil.DISK.GetUsage(global.Dir.BaseDir, false)
 	if err == nil {
 		baseInfo.DiskSize = int64(diskInfo.Free)
 	}
@@ -101,12 +107,17 @@ func (u *DashboardService) LoadOsInfo() (*dto.OsInfo, error) {
 func (u *DashboardService) LoadCurrentInfoForNode() *dto.NodeCurrent {
 	var currentInfo dto.NodeCurrent
 
-	currentInfo.CPUTotal, _ = cpu.Counts(true)
-	totalPercent, _ := cpu.Percent(100*time.Millisecond, false)
-	if len(totalPercent) == 1 {
-		currentInfo.CPUUsedPercent = totalPercent[0]
-		currentInfo.CPUUsed = currentInfo.CPUUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	currentInfo.CPUTotal, _ = psutil.CPUInfo.GetLogicalCores(false)
+
+	cpuUsedPercent, perCore, cpuDetailedPercent := psutil.CPU.GetCPUUsage()
+	if len(perCore) == 0 {
+		currentInfo.CPUTotal = psutil.CPU.NumCPU()
+	} else {
+		currentInfo.CPUTotal = len(perCore)
 	}
+	currentInfo.CPUUsedPercent = cpuUsedPercent
+	currentInfo.CPUUsed = cpuUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	currentInfo.CPUDetailedPercent = cpuDetailedPercent
 
 	loadInfo, _ := load.Avg()
 	currentInfo.Load1 = loadInfo.Load1
@@ -117,7 +128,7 @@ func (u *DashboardService) LoadCurrentInfoForNode() *dto.NodeCurrent {
 	memoryInfo, _ := mem.VirtualMemory()
 	currentInfo.MemoryTotal = memoryInfo.Total
 	currentInfo.MemoryAvailable = memoryInfo.Available
-	currentInfo.MemoryUsed = memoryInfo.Used + memoryInfo.Shared
+	currentInfo.MemoryUsed = memoryInfo.Used
 	currentInfo.MemoryUsedPercent = memoryInfo.UsedPercent
 
 	swapInfo, _ := mem.SwapMemory()
@@ -131,38 +142,39 @@ func (u *DashboardService) LoadCurrentInfoForNode() *dto.NodeCurrent {
 
 func (u *DashboardService) LoadBaseInfo(ioOption string, netOption string) (*dto.DashboardBase, error) {
 	var baseInfo dto.DashboardBase
-	hostInfo, err := host.Info()
+	hostInfo, err := psutil.HOST.GetHostInfo(false)
 	if err != nil {
 		return nil, err
 	}
-	baseInfo.Hostname = hostInfo.Hostname
-	baseInfo.OS = hostInfo.OS
-	baseInfo.Platform = hostInfo.Platform
-	baseInfo.PlatformFamily = hostInfo.PlatformFamily
-	baseInfo.PlatformVersion = hostInfo.PlatformVersion
-	baseInfo.KernelArch = hostInfo.KernelArch
-	baseInfo.KernelVersion = hostInfo.KernelVersion
 	ss, _ := json.Marshal(hostInfo)
-	baseInfo.VirtualizationSystem = string(ss)
-	baseInfo.IpV4Addr = loadOutboundIP()
-	httpProxy := os.Getenv("http_proxy")
-	if httpProxy == "" {
-		httpProxy = os.Getenv("HTTP_PROXY")
+	baseInfo = dto.DashboardBase{
+		Hostname:             hostInfo.Hostname,
+		OS:                   hostInfo.OS,
+		Platform:             hostInfo.Platform,
+		PlatformFamily:       hostInfo.PlatformFamily,
+		PlatformVersion:      hostInfo.PlatformVersion,
+		PrettyDistro:         psutil.HOST.GetDistro(),
+		KernelArch:           hostInfo.KernelArch,
+		KernelVersion:        hostInfo.KernelVersion,
+		VirtualizationSystem: string(ss),
+		IpV4Addr:             loadOutboundIP(),
+		SystemProxy:          "noProxy",
 	}
-	if httpProxy != "" {
-		baseInfo.SystemProxy = httpProxy
+
+	if proxy := cmp.Or(os.Getenv("http_proxy"), os.Getenv("HTTP_PROXY")); proxy != "" {
+		baseInfo.SystemProxy = proxy
 	}
-	baseInfo.SystemProxy = "noProxy"
 
 	loadQuickJump(&baseInfo)
 
-	cpuInfo, err := cpu.Info()
-	if err == nil {
+	cpuInfo, err := psutil.CPUInfo.GetCPUInfo(false)
+	if err == nil && len(cpuInfo) > 0 {
 		baseInfo.CPUModelName = cpuInfo[0].ModelName
 	}
 
-	baseInfo.CPUCores, _ = cpu.Counts(false)
-	baseInfo.CPULogicalCores, _ = cpu.Counts(true)
+	baseInfo.CPUCores, _ = psutil.CPUInfo.GetPhysicalCores(false)
+	baseInfo.CPULogicalCores, _ = psutil.CPUInfo.GetLogicalCores(false)
+	baseInfo.CPUMhz = cpuInfo[0].Mhz
 
 	baseInfo.CurrentInfo = *u.LoadCurrentInfo(ioOption, netOption)
 	return &baseInfo, nil
@@ -170,18 +182,22 @@ func (u *DashboardService) LoadBaseInfo(ioOption string, netOption string) (*dto
 
 func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *dto.DashboardCurrent {
 	var currentInfo dto.DashboardCurrent
-	hostInfo, _ := host.Info()
+	hostInfo, _ := psutil.HOST.GetHostInfo(false)
 	currentInfo.Uptime = hostInfo.Uptime
-	currentInfo.TimeSinceUptime = time.Now().Add(-time.Duration(hostInfo.Uptime) * time.Second).Format(constant.DateTimeLayout)
+	currentInfo.TimeSinceUptime = time.Unix(int64(hostInfo.BootTime), 0).Format(constant.DateTimeLayout)
 	currentInfo.Procs = hostInfo.Procs
+	currentInfo.CPUTotal, _ = psutil.CPUInfo.GetLogicalCores(false)
 
-	currentInfo.CPUTotal, _ = cpu.Counts(true)
-	totalPercent, _ := cpu.Percent(100*time.Millisecond, false)
-	if len(totalPercent) == 1 {
-		currentInfo.CPUUsedPercent = totalPercent[0]
-		currentInfo.CPUUsed = currentInfo.CPUUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	cpuUsedPercent, perCore, cpuDetailedPercent := psutil.CPU.GetCPUUsage()
+	if len(perCore) == 0 {
+		currentInfo.CPUTotal = psutil.CPU.NumCPU()
+	} else {
+		currentInfo.CPUTotal = len(perCore)
 	}
-	currentInfo.CPUPercent, _ = cpu.Percent(100*time.Millisecond, true)
+	currentInfo.CPUPercent = perCore
+	currentInfo.CPUUsedPercent = cpuUsedPercent
+	currentInfo.CPUUsed = cpuUsedPercent * 0.01 * float64(currentInfo.CPUTotal)
+	currentInfo.CPUDetailedPercent = cpuDetailedPercent
 
 	loadInfo, _ := load.Avg()
 	currentInfo.Load1 = loadInfo.Load1
@@ -191,7 +207,7 @@ func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *d
 
 	memoryInfo, _ := mem.VirtualMemory()
 	currentInfo.MemoryTotal = memoryInfo.Total
-	currentInfo.MemoryUsed = memoryInfo.Used + memoryInfo.Shared
+	currentInfo.MemoryUsed = memoryInfo.Used
 	currentInfo.MemoryFree = memoryInfo.Free
 	currentInfo.MemoryCache = memoryInfo.Cached + memoryInfo.Buffers
 	currentInfo.MemoryShard = memoryInfo.Shared
@@ -240,6 +256,7 @@ func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *d
 			if state.Name == netOption {
 				currentInfo.NetBytesSent = state.BytesSent
 				currentInfo.NetBytesRecv = state.BytesRecv
+				break
 			}
 		}
 	}
@@ -248,6 +265,14 @@ func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *d
 	return &currentInfo
 }
 
+func (u *DashboardService) LoadTopCPU() []dto.Process {
+	return loadTopCPU()
+}
+
+func (u *DashboardService) LoadTopMem() []dto.Process {
+	return loadTopMem()
+}
+
 func (u *DashboardService) LoadAppLauncher(ctx *gin.Context) ([]dto.AppLauncher, error) {
 	var data []dto.AppLauncher
 	appInstalls, err := appInstallRepo.ListBy(context.Background())
@@ -260,7 +285,7 @@ func (u *DashboardService) LoadAppLauncher(ctx *gin.Context) ([]dto.AppLauncher,
 	}
 
 	showList, err := launcherRepo.ListName()
-	defaultList, err := appRepo.GetTopRecomment()
+	defaultList, err := appRepo.GetTopRecommend()
 	if err != nil {
 		return data, nil
 	}
@@ -401,10 +426,11 @@ type diskInfo struct {
 func loadDiskInfo() []dto.DiskInfo {
 	var datas []dto.DiskInfo
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(2 * time.Second))
-	stdout, err := cmdMgr.RunWithStdoutBashC("timeout 2 df -hT -P | awk 'NR>1 && !/tmpfs|snap\\/core|udev/ {print}'")
+	format := `awk 'NR>1 && !/tmpfs|snap\/core|udev/ {printf "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", $1, $2, $3, $4, $5, $6, $7}'`
+	stdout, err := cmdMgr.RunWithStdout("bash", "-c", `timeout 2 df -hT -P | `+format)
 	if err != nil {
 		cmdMgr2 := cmd.NewCommandMgr(cmd.WithTimeout(1 * time.Second))
-		stdout, err = cmdMgr2.RunWithStdoutBashC("timeout 1 df -lhT -P | awk 'NR>1 && !/tmpfs|snap\\/core|udev/ {print}'")
+		stdout, err = cmdMgr2.RunWithStdout("bash", "-c", `timeout 1 df -lhT -P | `+format)
 		if err != nil {
 			return datas
 		}
@@ -414,7 +440,7 @@ func loadDiskInfo() []dto.DiskInfo {
 	var mounts []diskInfo
 	var excludes = []string{"/mnt/cdrom", "/boot", "/boot/efi", "/dev", "/dev/shm", "/run/lock", "/run", "/run/shm", "/run/user"}
 	for _, line := range lines {
-		fields := strings.Fields(line)
+		fields := strings.Split(line, "\t")
 		if len(fields) < 7 {
 			continue
 		}
@@ -448,41 +474,52 @@ func loadDiskInfo() []dto.DiskInfo {
 	)
 	wg.Add(len(mounts))
 	for i := 0; i < len(mounts); i++ {
-		go func(timeoutCh <-chan time.Time, mount diskInfo) {
+		go func(mount diskInfo) {
 			defer wg.Done()
 
 			var itemData dto.DiskInfo
 			itemData.Path = mount.Mount
 			itemData.Type = mount.Type
 			itemData.Device = mount.Device
+
+			type diskResult struct {
+				state *disk.UsageStat
+				err   error
+			}
+			resultCh := make(chan diskResult, 1)
+
+			go func() {
+				state, err := psutil.DISK.GetUsage(mount.Mount, false)
+				resultCh <- diskResult{state: state, err: err}
+			}()
+
 			select {
-			case <-timeoutCh:
+			case <-time.After(5 * time.Second):
 				mu.Lock()
 				datas = append(datas, 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 {
+			case result := <-resultCh:
+				if result.err != nil {
 					mu.Lock()
 					datas = append(datas, itemData)
 					mu.Unlock()
-					global.LOG.Errorf("load disk info from %s failed, err: %v", mount.Mount, err)
+					global.LOG.Errorf("load disk info from %s failed, err: %v", mount.Mount, result.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
+				itemData.Total = result.state.Total
+				itemData.Free = result.state.Free
+				itemData.Used = result.state.Used
+				itemData.UsedPercent = result.state.UsedPercent
+				itemData.InodesTotal = result.state.InodesTotal
+				itemData.InodesUsed = result.state.InodesUsed
+				itemData.InodesFree = result.state.InodesFree
+				itemData.InodesUsedPercent = result.state.InodesUsedPercent
 				mu.Lock()
 				datas = append(datas, itemData)
 				mu.Unlock()
 			}
-		}(time.After(5*time.Second), mounts[i])
+		}(mounts[i])
 	}
 	wg.Wait()
 

agent/app/service/database.go

@@ -119,27 +119,27 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
 	if req.Timeout == 0 {
 		req.Timeout = 30
 	}
+	var err error
 	switch req.Type {
 	case constant.AppPostgresql:
-		_, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
-			From:     "remote",
-			Address:  req.Address,
-			Port:     req.Port,
-			Username: req.Username,
-			Password: req.Password,
-			Timeout:  req.Timeout,
+		_, err = postgresql.NewPostgresqlClient(pgclient.DBInfo{
+			From:      "remote",
+			Address:   req.Address,
+			Port:      req.Port,
+			InitialDB: req.InitialDB,
+			Username:  req.Username,
+			Password:  req.Password,
+			Timeout:   req.Timeout,
 		})
-		return err == nil
 	case constant.AppRedis:
-		_, err := redisclient.NewRedisClient(redisclient.DBInfo{
+		_, err = redisclient.NewRedisClient(redisclient.DBInfo{
 			Address:  req.Address,
 			Port:     req.Port,
 			Password: req.Password,
 			Timeout:  req.Timeout,
 		})
-		return err == nil
 	case "mysql", "mariadb":
-		_, err := mysql.NewMysqlClient(client.DBInfo{
+		_, err = mysql.NewMysqlClient(client.DBInfo{
 			From:     "remote",
 			Address:  req.Address,
 			Port:     req.Port,
@@ -153,10 +153,13 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
 			SkipVerify: req.SkipVerify,
 			Timeout:    req.Timeout,
 		})
-		return err == nil
+	}
+	if err != nil {
+		global.LOG.Errorf("check database connection failed, err: %v", err)
+		return false
 	}
 
-	return false
+	return true
 }
 
 func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
@@ -173,12 +176,13 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
 	switch req.Type {
 	case constant.AppPostgresql:
 		if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
-			From:     "remote",
-			Address:  req.Address,
-			Port:     req.Port,
-			Username: req.Username,
-			Password: req.Password,
-			Timeout:  req.Timeout,
+			From:      "remote",
+			Address:   req.Address,
+			Port:      req.Port,
+			InitialDB: req.InitialDB,
+			Username:  req.Username,
+			Password:  req.Password,
+			Timeout:   req.Timeout,
 		}); err != nil {
 			return err
 		}
@@ -274,12 +278,13 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
 	switch req.Type {
 	case constant.AppPostgresql:
 		if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
-			From:     "remote",
-			Address:  req.Address,
-			Port:     req.Port,
-			Username: req.Username,
-			Password: req.Password,
-			Timeout:  req.Timeout,
+			From:      "remote",
+			Address:   req.Address,
+			Port:      req.Port,
+			InitialDB: req.InitialDB,
+			Username:  req.Username,
+			Password:  req.Password,
+			Timeout:   req.Timeout,
 		}); err != nil {
 			return err
 		}
@@ -325,6 +330,7 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
 	upMap["port"] = req.Port
 	upMap["username"] = req.Username
 	upMap["password"] = pass
+	upMap["initial_db"] = req.InitialDB
 	upMap["timeout"] = req.Timeout
 	upMap["description"] = req.Description
 	upMap["ssl"] = req.SSL

agent/app/service/database_common.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"strings"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"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"
@@ -51,7 +53,14 @@ func (u *DBCommonService) LoadDatabaseFile(req dto.OperationWithNameAndType) (st
 	case "mariadb-conf":
 		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/mariadb/%s/conf/my.cnf", req.Name))
 	case "postgresql-conf":
+		database, err := databaseRepo.Get(repo.WithByName(req.Name))
+		if err != nil {
+			return "", err
+		}
 		filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/postgresql/%s/data/postgresql.conf", req.Name))
+		if strings.HasPrefix(database.Version, "18.") {
+			filePath = path.Join(global.Dir.DataDir, fmt.Sprintf("apps/postgresql/%s/data/18/docker/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":
@@ -76,8 +85,13 @@ func (u *DBCommonService) UpdateConfByFile(req dto.DBConfUpdateByFile) error {
 	switch req.Type {
 	case constant.AppMariaDB, constant.AppMysql, constant.AppMysqlCluster:
 		path = fmt.Sprintf("%s/%s/%s/conf/my.cnf", global.Dir.AppInstallDir, req.Type, app.Name)
-	case constant.AppPostgresql, constant.AppPostgresqlCluster:
+	case constant.AppPostgresqlCluster:
 		path = fmt.Sprintf("%s/%s/%s/data/postgresql.conf", global.Dir.AppInstallDir, req.Type, app.Name)
+	case constant.AppPostgresql:
+		path = fmt.Sprintf("%s/%s/%s/data/postgresql.conf", global.Dir.AppInstallDir, req.Type, app.Name)
+		if strings.HasPrefix(app.Version, "18.") {
+			path = fmt.Sprintf("%s/%s/%s/data/18/docker/postgresql.conf", global.Dir.AppInstallDir, req.Type, app.Name)
+		}
 	case constant.AppRedis, constant.AppRedisCluster:
 		path = fmt.Sprintf("%s/%s/%s/conf/redis.conf", global.Dir.AppInstallDir, req.Type, app.Name)
 	}

agent/app/service/database_mysql.go

@@ -7,7 +7,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -25,6 +24,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
 	"github.com/1Panel-dev/1Panel/agent/utils/mysql"
 	"github.com/1Panel-dev/1Panel/agent/utils/mysql/client"
+	"github.com/1Panel-dev/1Panel/agent/utils/re"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/jinzhu/copier"
 	"github.com/pkg/errors"
@@ -45,6 +45,7 @@ type IMysqlService interface {
 	DeleteCheck(req dto.MysqlDBDeleteCheck) ([]dto.DBResource, error)
 	Delete(ctx context.Context, req dto.MysqlDBDelete) error
 
+	LoadFormatOption(req dto.OperationWithName) []dto.MysqlFormatCollationOption
 	LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlStatus, error)
 	LoadVariables(req dto.OperationWithNameAndType) (*dto.MysqlVariables, error)
 	LoadRemoteAccess(req dto.OperationWithNameAndType) (bool, error)
@@ -99,7 +100,7 @@ func (u *MysqlService) ListDBOption() ([]dto.MysqlOption, error) {
 }
 
 func (u *MysqlService) Create(ctx context.Context, req dto.MysqlDBCreate) (*model.DatabaseMysql, error) {
-	if cmd.CheckIllegal(req.Name, req.Username, req.Password, req.Format, req.Permission) {
+	if cmd.CheckIllegal(req.Name, req.Username, req.Password, req.Format, req.Collation, req.Permission) {
 		return nil, buserr.New("ErrCmdIllegal")
 	}
 
@@ -114,7 +115,7 @@ func (u *MysqlService) Create(ctx context.Context, req dto.MysqlDBCreate) (*mode
 	}
 
 	if req.From == "local" && req.Username == "root" {
-		return nil, errors.New("Cannot set root as user name")
+		return nil, errors.New("cannot set root as user name")
 	}
 
 	cli, version, err := LoadMysqlClientByFrom(req.Database)
@@ -126,6 +127,7 @@ func (u *MysqlService) Create(ctx context.Context, req dto.MysqlDBCreate) (*mode
 	if err := cli.Create(client.CreateInfo{
 		Name:       req.Name,
 		Format:     req.Format,
+		Collation:  req.Collation,
 		Username:   req.Username,
 		Password:   req.Password,
 		Permission: req.Permission,
@@ -584,6 +586,19 @@ func (u *MysqlService) LoadStatus(req dto.OperationWithNameAndType) (*dto.MysqlS
 	return &info, nil
 }
 
+func (u *MysqlService) LoadFormatOption(req dto.OperationWithName) []dto.MysqlFormatCollationOption {
+	defaultList := []dto.MysqlFormatCollationOption{{Format: "utf8mb4"}, {Format: "utf8mb3"}, {Format: "gbk"}, {Format: "big5"}}
+	client, _, err := LoadMysqlClientByFrom(req.Name)
+	if err != nil {
+		return defaultList
+	}
+	options, err := client.LoadFormatCollation(3)
+	if err != nil {
+		return defaultList
+	}
+	return options
+}
+
 func executeSqlForMaps(containerName, dbType, password, command string) (map[string]string, error) {
 	if dbType == "mysql-cluster" {
 		dbType = "mysql"
@@ -623,7 +638,7 @@ func updateMyCnf(oldFiles []string, group string, param string, value interface{
 	isOn := false
 	hasGroup := false
 	hasKey := false
-	regItem, _ := regexp.Compile(`\[*\]`)
+	regItem := re.GetRegex(re.MysqlGroupPattern)
 	var newFiles []string
 	i := 0
 	for _, line := range oldFiles {