Update CONTRIBUTING.md

Refs https://github.com/1Panel-dev/1Panel/issues/4171

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: 问题与讨论 / Questions & Discussions
+    url: https://github.com/1Panel-dev/1Panel/discussions
+    about: 提出针对本项目安装部署、使用及其他方面的相关问题 / Raise questions about the installation, deployment, use and other aspects of the project.
   - name: 对 1Panel 项目有其他问题
-    url: https://1panel.cn
-    about: 如果想要进一步了解 1Panel 项目，欢迎发送邮件到 support@fit2cloud.com 进行提问。
-  - name: 反馈安全问题 (Report Security Bug)
-    url: mailto://support@fit2cloud.com
-    about: 请通过邮箱 support@fit2cloud.com 反馈安全问题 (Please report security vulnerabilities to support@fit2cloud.com)
+    url: https://bbs.fit2cloud.com/c/1p/7
+    about: 如果你对 1Panel 有其他想要提问的，我们欢迎到我们的官方社区进行提问。

.github/ISSUE_TEMPLATE/question.yml

@@ -1,12 +0,0 @@
-name: 问题咨询
-description: 提出针对本项目安装部署、使用及其他方面的相关问题
-title: "[QUESTION]"
-labels: question
-assignees: wanghe-fit2cloud
-body:
-  - type: textarea
-    id: description
-    attributes:
-      label: "请描述您的问题"
-    validations:
-      required: true

.github/workflows/release-drafter.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v3
         with:
-          node-version: '18.14'
+          node-version: '20.2'
       - name: Build Web
         run: |
           cd frontend && npm install && npm run build:pro
@@ -24,7 +24,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v4
         with:
-          go-version: '1.20.x'
+          go-version: '1.21.x'
       - name: Build Release
         uses: goreleaser/goreleaser-action@v4
         with:

.gitignore

@@ -39,6 +39,13 @@ frontend/auto-imports.d.ts
 frontend/components.d.ts
 frontend/src/xpack
 backend/xpack
+backend/router/entry_xpack.go
+backend/server/init_xpack.go
+plugins/openresty/waf/db
+plugins/openresty/waf/data
+plugins/openresty/waf/sites
+plugins/openresty/waf/conf/websites.json
+
 
 .history/
 dist/

CONTRIBUTING.md

@@ -5,7 +5,7 @@ PR are always welcome, even if they only contain small fixes like typos or a few
 
 Please submit a PR broken down into small changes bit by bit. A PR consisting of a lot features and code changes may be hard to review. It is recommended to submit PRs in an incremental fashion.
 
-This [development guideline](https://kubeoperator.io/docs/dev/dev_manual/) contains information about repository structure, how to setup development environment, how to run it, and more.
+This [development guideline](https://1panel.cn/docs/dev_manual/dev_manual/) contains information about repository structure, how to setup development environment, how to run it, and more.
 
 Note: If you split your pull request to small changes, please make sure any of the changes goes to master will not break anything. Otherwise, it can not be merged until this feature complete.
 
@@ -22,4 +22,4 @@ When reporting issues, always include:
 * Snapshots or log files if needed
 
 Because the issues are open to the public, when submitting files, be sure to remove any sensitive information, e.g. user name, password, IP address, and company name. You can
-replace those parts with "REDACTED" or other strings like "****".
+replace those parts with "REDACTED" or other strings like "****".

README.md

@@ -11,13 +11,13 @@
 
 ------------------------------
 
-1Panel 是一个现代化、开源的 Linux 服务器运维管理面板。1Panel 的功能和优势包括：
+1Panel 是新一代的 Linux 服务器运维管理面板。
 
-- **快速建站**：深度集成 Wordpress 和 [Halo](https://github.com/halo-dev/halo/)，域名绑定、SSL 证书配置等一键搞定；
-- **高效管理**：通过 Web 端轻松管理 Linux 服务器，包括主机监控、文件管理、数据库管理、容器管理等；
-- **安全可靠**：基于容器来管理和部署应用，最小漏洞暴露面，提供防火墙和日志审计等功能；
-- **一键备份**：支持一键备份和恢复，备份数据到各类云端存储，永不丢失；
-- **应用商店**：精选各类高质量开源工具和应用软件，助力您轻松安装和升级。
+- **高效管理**：用户可以通过 Web 图形界面轻松管理 Linux 服务器，实现主机监控、文件管理、数据库管理、容器管理等功能；
+- **快速建站**：深度集成开源建站软件 WordPress 和 [Halo](https://github.com/halo-dev/halo/)，域名绑定、SSL 证书配置等操作一键搞定；
+- **应用商店**：精选上架各类高质量的开源工具和应用软件，协助用户轻松安装并升级；
+- **安全可靠**：基于容器管理并部署应用，实现最小的漏洞暴露面，同时提供防火墙和日志审计等功能；
+- **一键备份**：支持一键备份和恢复，用户可以将数据备份到各类云端存储介质，永不丢失。
 
 ## UI 展示
 
@@ -50,8 +50,7 @@ curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_
 
 如果您在使用过程中发现任何安全问题，请通过以下方式直接联系我们：
 
-- 邮箱：support@fit2cloud.com
-- 电话：400-052-0755
+- 邮箱：wanghe@fit2cloud.com
 
 ## Star History
 

backend/app/api/v1/backup.go

@@ -49,6 +49,17 @@ func (b *BaseApi) CreateBackup(c *gin.Context) {
 	helper.SuccessWithData(c, nil)
 }
 
+// @Tags Backup Account
+// @Summary Refresh OneDrive token
+// @Description 刷新 OneDrive token
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /settings/backup/refresh/onedrive [post]
+func (b *BaseApi) RefreshOneDriveToken(c *gin.Context) {
+	backupService.Run()
+	helper.SuccessWithData(c, nil)
+}
+
 // @Tags Backup Account
 // @Summary List buckets
 // @Description 获取 bucket 列表
@@ -91,16 +102,16 @@ func (b *BaseApi) ListBuckets(c *gin.Context) {
 // @Summary Load OneDrive info
 // @Description 获取 OneDrive 信息
 // @Accept json
-// @Success 200 string clientID
+// @Success 200 {object} dto.OneDriveInfo
 // @Security ApiKeyAuth
 // @Router /settings/backup/onedrive [get]
 func (b *BaseApi) LoadOneDriveInfo(c *gin.Context) {
-	clientID, err := backupService.LoadOneDriveInfo()
+	data, err := backupService.LoadOneDriveInfo()
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	helper.SuccessWithData(c, clientID)
+	helper.SuccessWithData(c, data)
 }
 
 // @Tags Backup Account
@@ -151,6 +162,32 @@ func (b *BaseApi) SearchBackupRecords(c *gin.Context) {
 	})
 }
 
+// @Tags Backup Account
+// @Summary Page backup records by cronjob
+// @Description 通过计划任务获取备份记录列表分页
+// @Accept json
+// @Param request body dto.RecordSearchByCronjob true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /settings/backup/record/search/bycronjob [post]
+func (b *BaseApi) SearchBackupRecordsByCronjob(c *gin.Context) {
+	var req dto.RecordSearchByCronjob
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	total, list, err := backupService.SearchRecordsByCronjobWithPage(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Items: list,
+		Total: total,
+	})
+}
+
 // @Tags Backup Account
 // @Summary Download backup record
 // @Description 下载备份记录
@@ -265,12 +302,7 @@ func (b *BaseApi) LoadFilesFromBackup(c *gin.Context) {
 		return
 	}
 
-	data, err := backupService.ListFiles(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
+	data := backupService.ListFiles(req)
 	helper.SuccessWithData(c, data)
 }
 
@@ -281,7 +313,7 @@ func (b *BaseApi) LoadFilesFromBackup(c *gin.Context) {
 // @Param request body dto.CommonBackup true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /settings/backup/ [post]
+// @Router /settings/backup/backup [post]
 // @x-panel-log {"bodyKeys":["type","name","detailName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"备份 [type] 数据 [name][detailName]","formatEN":"backup [type] data [name][detailName]"}
 func (b *BaseApi) Backup(c *gin.Context) {
 	var req dto.CommonBackup
@@ -334,14 +366,12 @@ func (b *BaseApi) Recover(c *gin.Context) {
 		return
 	}
 
-	if req.Source != "LOCAL" {
-		downloadPath, err := backupService.DownloadRecord(dto.DownloadRecord{Source: req.Source, FileDir: path.Dir(req.File), FileName: path.Base(req.File)})
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, fmt.Errorf("download file failed, err: %v", err))
-			return
-		}
-		req.File = downloadPath
+	downloadPath, err := backupService.DownloadRecord(dto.DownloadRecord{Source: req.Source, FileDir: path.Dir(req.File), FileName: path.Base(req.File)})
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, fmt.Errorf("download file failed, err: %v", err))
+		return
 	}
+	req.File = downloadPath
 	switch req.Type {
 	case "mysql", "mariadb":
 		if err := backupService.MysqlRecover(req); err != nil {

backend/app/api/v1/cronjob.go

@@ -95,17 +95,13 @@ func (b *BaseApi) SearchJobRecords(c *gin.Context) {
 // @Param request body dto.OperateByID true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /cronjob/record/log [post]
+// @Router /cronjobs/records/log [post]
 func (b *BaseApi) LoadRecordLog(c *gin.Context) {
 	var req dto.OperateByID
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-	content, err := cronjobService.LoadRecordLog(req)
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
+	content := cronjobService.LoadRecordLog(req)
 	helper.SuccessWithData(c, content)
 }
 

backend/app/api/v1/dashboard.go

@@ -8,6 +8,22 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+// @Tags Dashboard
+// @Summary Load os info
+// @Description 获取服务器基础数据
+// @Accept json
+// @Success 200 {object} dto.OsInfo
+// @Security ApiKeyAuth
+// @Router /dashboard/base/os [get]
+func (b *BaseApi) LoadDashboardOsInfo(c *gin.Context) {
+	data, err := dashboardService.LoadOsInfo()
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, data)
+}
+
 // @Tags Dashboard
 // @Summary Load dashboard base info
 // @Description 获取首页基础数据

backend/app/api/v1/database_postgresql.go

@@ -164,24 +164,6 @@ func (b *BaseApi) SearchPostgresql(c *gin.Context) {
 	})
 }
 
-// @Tags Database Postgresql
-// @Summary List postgresql database names
-// @Description 获取 postgresql 数据库列表
-// @Accept json
-// @Param request body dto.PageInfo true "request"
-// @Success 200 {array} dto.PostgresqlOption
-// @Security ApiKeyAuth
-// @Router /databases/pg/options [get]
-func (b *BaseApi) ListPostgresqlDBName(c *gin.Context) {
-	list, err := postgresqlService.ListDBOption()
-	if err != nil {
-		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
-		return
-	}
-
-	helper.SuccessWithData(c, list)
-}
-
 // @Tags Database Postgresql
 // @Summary Load postgresql database from remote
 // @Description 从服务器获取

backend/app/api/v1/file.go

@@ -422,11 +422,9 @@ func (b *BaseApi) MoveFile(c *gin.Context) {
 // @Summary Download file
 // @Description 下载文件
 // @Accept json
-// @Param request body request.FileDownload true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /files/download [post]
-// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"下载文件 [name]","formatEN":"Download file [name]"}
+// @Router /files/download [get]
 func (b *BaseApi) Download(c *gin.Context) {
 	filePath := c.Query("path")
 	file, err := os.Open(filePath)
@@ -689,7 +687,7 @@ func (b *BaseApi) Keys(c *gin.Context) {
 // @Param request body request.FileReadByLineReq true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /files/log/read [post]
+// @Router /files/read [post]
 func (b *BaseApi) ReadFileByLine(c *gin.Context) {
 	var req request.FileReadByLineReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

backend/app/api/v1/nginx.go

@@ -12,7 +12,7 @@ import (
 // @Description 获取 OpenResty 配置信息
 // @Success 200 {object} response.FileInfo
 // @Security ApiKeyAuth
-// @Router /openResty [get]
+// @Router /openresty [get]
 func (b *BaseApi) GetNginx(c *gin.Context) {
 	fileInfo, err := nginxService.GetNginxConfig()
 	if err != nil {
@@ -29,7 +29,7 @@ func (b *BaseApi) GetNginx(c *gin.Context) {
 // @Param request body request.NginxScopeReq true "request"
 // @Success 200 {array} response.NginxParam
 // @Security ApiKeyAuth
-// @Router /openResty/scope [post]
+// @Router /openresty/scope [post]
 func (b *BaseApi) GetNginxConfigByScope(c *gin.Context) {
 	var req request.NginxScopeReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -51,7 +51,7 @@ func (b *BaseApi) GetNginxConfigByScope(c *gin.Context) {
 // @Param request body request.NginxConfigUpdate true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /openResty/update [post]
+// @Router /openresty/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":"更新 nginx 配置 [domain]","formatEN":"Update nginx conf [domain]"}
 func (b *BaseApi) UpdateNginxConfigByScope(c *gin.Context) {
 	var req request.NginxConfigUpdate
@@ -70,7 +70,7 @@ func (b *BaseApi) UpdateNginxConfigByScope(c *gin.Context) {
 // @Description 获取 OpenResty 状态信息
 // @Success 200 {object} response.NginxStatus
 // @Security ApiKeyAuth
-// @Router /openResty/status [get]
+// @Router /openresty/status [get]
 func (b *BaseApi) GetNginxStatus(c *gin.Context) {
 	res, err := nginxService.GetStatus()
 	if err != nil {
@@ -87,7 +87,7 @@ func (b *BaseApi) GetNginxStatus(c *gin.Context) {
 // @Param request body request.NginxConfigFileUpdate true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /openResty/file [post]
+// @Router /openresty/file [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 nginx 配置","formatEN":"Update nginx conf"}
 func (b *BaseApi) UpdateNginxFile(c *gin.Context) {
 	var req request.NginxConfigFileUpdate
@@ -107,7 +107,7 @@ func (b *BaseApi) UpdateNginxFile(c *gin.Context) {
 // @Description 清理 OpenResty 代理缓存
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /openResty/clear [post]
+// @Router /openresty/clear [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"清理 Openresty 代理缓存","formatEN":"Clear nginx proxy cache"}
 func (b *BaseApi) ClearNginxProxyCache(c *gin.Context) {
 	if err := nginxService.ClearProxyCache(); err != nil {

backend/app/api/v1/runtime.go

@@ -203,3 +203,19 @@ func (b *BaseApi) OperateNodeModules(c *gin.Context) {
 	}
 	helper.SuccessWithOutData(c)
 }
+
+// @Tags Runtime
+// @Summary Sync runtime status
+// @Description 同步运行环境状态
+// @Accept json
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes/sync [post]
+func (b *BaseApi) SyncStatus(c *gin.Context) {
+	err := runtimeService.SyncRuntimeStatus()
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}

backend/app/api/v1/terminal.go

@@ -55,7 +55,6 @@ func (b *BaseApi) WsSsh(c *gin.Context) {
 		return
 	}
 	defer client.Close()
-	
 	sws, err := terminal.NewLogicSshWsSession(cols, rows, true, connInfo.Client, wsConn)
 	if wshandleError(wsConn, err) {
 		return
@@ -106,7 +105,7 @@ func (b *BaseApi) RedisWsSsh(c *gin.Context) {
 	defer killBash(redisConf.ContainerName, commands, pidMap)
 	defer slave.Close()
 
-	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave)
+	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, false)
 	if wshandleError(wsConn, err) {
 		return
 	}
@@ -174,7 +173,7 @@ func (b *BaseApi) ContainerWsSsh(c *gin.Context) {
 	defer killBash(containerID, command, pidMap)
 	defer slave.Close()
 
-	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave)
+	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, true)
 	if wshandleError(wsConn, err) {
 		return
 	}

backend/app/dto/backup.go

@@ -21,6 +21,12 @@ type BackupInfo struct {
 	Vars       string    `json:"vars"`
 }
 
+type OneDriveInfo struct {
+	ClientID     string `json:"client_id"`
+	ClientSecret string `json:"client_secret"`
+	RedirectUri  string `json:"redirect_uri"`
+}
+
 type BackupSearchFile struct {
 	Type string `json:"type" validate:"required"`
 }
@@ -45,6 +51,11 @@ type RecordSearch struct {
 	DetailName string `json:"detailName"`
 }
 
+type RecordSearchByCronjob struct {
+	PageInfo
+	CronjobID uint `json:"cronjobID" validate:"required"`
+}
+
 type BackupRecords struct {
 	ID         uint      `json:"id"`
 	CreatedAt  time.Time `json:"createdAt"`

backend/app/dto/command.go

@@ -2,6 +2,8 @@ package dto
 
 type SearchCommandWithPage struct {
 	SearchWithPage
+	OrderBy string `json:"orderBy"`
+	Order   string `json:"order"`
 	GroupID uint   `json:"groupID"`
 	Info    string `json:"info"`
 }

backend/app/dto/container.go

@@ -38,8 +38,8 @@ type ContainerInfo struct {
 }
 
 type ResourceLimit struct {
-	CPU    int `json:"cpu"`
-	Memory int `json:"memory"`
+	CPU    int    `json:"cpu"`
+	Memory uint64 `json:"memory"`
 }
 
 type ContainerOperate struct {

backend/app/dto/cronjob.go

@@ -3,14 +3,9 @@ package dto
 import "time"
 
 type CronjobCreate struct {
-	Name     string `json:"name" validate:"required"`
-	Type     string `json:"type" validate:"required"`
-	SpecType string `json:"specType" validate:"required"`
-	Week     int    `json:"week" validate:"number,max=6,min=0"`
-	Day      int    `json:"day" validate:"number"`
-	Hour     int    `json:"hour" validate:"number"`
-	Minute   int    `json:"minute" validate:"number"`
-	Second   int    `json:"second" validate:"number"`
+	Name string `json:"name" validate:"required"`
+	Type string `json:"type" validate:"required"`
+	Spec string `json:"spec" validate:"required"`
 
 	Script         string `json:"script"`
 	ContainerName  string `json:"containerName"`
@@ -21,20 +16,16 @@ type CronjobCreate struct {
 	DBName         string `json:"dbName"`
 	URL            string `json:"url"`
 	SourceDir      string `json:"sourceDir"`
-	KeepLocal      bool   `json:"keepLocal"`
-	TargetDirID    int    `json:"targetDirID"`
-	RetainCopies   int    `json:"retainCopies" validate:"number,min=1"`
+
+	BackupAccounts  string `json:"backupAccounts"`
+	DefaultDownload string `json:"defaultDownload"`
+	RetainCopies    int    `json:"retainCopies" validate:"number,min=1"`
 }
 
 type CronjobUpdate struct {
-	ID       uint   `json:"id" validate:"required"`
-	Name     string `json:"name" validate:"required"`
-	SpecType string `json:"specType" validate:"required"`
-	Week     int    `json:"week" validate:"number,max=6,min=0"`
-	Day      int    `json:"day" validate:"number"`
-	Hour     int    `json:"hour" validate:"number"`
-	Minute   int    `json:"minute" validate:"number"`
-	Second   int    `json:"second" validate:"number"`
+	ID   uint   `json:"id" validate:"required"`
+	Name string `json:"name" validate:"required"`
+	Spec string `json:"spec" validate:"required"`
 
 	Script         string `json:"script"`
 	ContainerName  string `json:"containerName"`
@@ -45,9 +36,10 @@ type CronjobUpdate struct {
 	DBName         string `json:"dbName"`
 	URL            string `json:"url"`
 	SourceDir      string `json:"sourceDir"`
-	KeepLocal      bool   `json:"keepLocal"`
-	TargetDirID    int    `json:"targetDirID"`
-	RetainCopies   int    `json:"retainCopies" validate:"number,min=1"`
+
+	BackupAccounts  string `json:"backupAccounts"`
+	DefaultDownload string `json:"defaultDownload"`
+	RetainCopies    int    `json:"retainCopies" validate:"number,min=1"`
 }
 
 type CronjobUpdateStatus struct {
@@ -61,6 +53,7 @@ type CronjobDownload struct {
 }
 
 type CronjobClean struct {
+	IsDelete  bool `json:"isDelete"`
 	CleanData bool `json:"cleanData"`
 	CronjobID uint `json:"cronjobID" validate:"required"`
 }
@@ -71,29 +64,23 @@ type CronjobBatchDelete struct {
 }
 
 type CronjobInfo struct {
-	ID       uint   `json:"id"`
-	Name     string `json:"name"`
-	Type     string `json:"type"`
-	SpecType string `json:"specType"`
-	Week     int    `json:"week"`
-	Day      int    `json:"day"`
-	Hour     int    `json:"hour"`
-	Minute   int    `json:"minute"`
-	Second   int    `json:"second"`
+	ID   uint   `json:"id"`
+	Name string `json:"name"`
+	Type string `json:"type"`
+	Spec string `json:"spec"`
 
-	Script         string `json:"script"`
-	ContainerName  string `json:"containerName"`
-	AppID          string `json:"appID"`
-	Website        string `json:"website"`
-	ExclusionRules string `json:"exclusionRules"`
-	DBType         string `json:"dbType"`
-	DBName         string `json:"dbName"`
-	URL            string `json:"url"`
-	SourceDir      string `json:"sourceDir"`
-	KeepLocal      bool   `json:"keepLocal"`
-	TargetDir      string `json:"targetDir"`
-	TargetDirID    int    `json:"targetDirID"`
-	RetainCopies   int    `json:"retainCopies"`
+	Script          string `json:"script"`
+	ContainerName   string `json:"containerName"`
+	AppID           string `json:"appID"`
+	Website         string `json:"website"`
+	ExclusionRules  string `json:"exclusionRules"`
+	DBType          string `json:"dbType"`
+	DBName          string `json:"dbName"`
+	URL             string `json:"url"`
+	SourceDir       string `json:"sourceDir"`
+	BackupAccounts  string `json:"backupAccounts"`
+	DefaultDownload string `json:"defaultDownload"`
+	RetainCopies    int    `json:"retainCopies"`
 
 	LastRecordTime string `json:"lastRecordTime"`
 	Status         string `json:"status"`

backend/app/dto/dashboard.go

@@ -24,6 +24,14 @@ type DashboardBase struct {
 	CurrentInfo DashboardCurrent `json:"currentInfo"`
 }
 
+type OsInfo struct {
+	OS             string `json:"os"`
+	Platform       string `json:"platform"`
+	PlatformFamily string `json:"platformFamily"`
+	KernelArch     string `json:"kernelArch"`
+	KernelVersion  string `json:"kernelVersion"`
+}
+
 type DashboardCurrent struct {
 	Uptime          uint64 `json:"uptime"`
 	TimeSinceUptime string `json:"timeSinceUptime"`

backend/app/dto/database.go

@@ -41,7 +41,7 @@ type MysqlDBInfo struct {
 	Username    string    `json:"username"`
 	Password    string    `json:"password"`
 	Permission  string    `json:"permission"`
-	BackupCount int       `json:"backupCount"`
+	IsDelete    bool      `json:"isDelete"`
 	Description string    `json:"description"`
 }
 

backend/app/dto/database_postgresql.go

@@ -20,7 +20,7 @@ type PostgresqlDBInfo struct {
 	Username       string    `json:"username"`
 	Password       string    `json:"password"`
 	SuperUser      bool      `json:"superUser"`
-	BackupCount    int       `json:"backupCount"`
+	IsDelete       bool      `json:"isDelete"`
 	Description    string    `json:"description"`
 }
 

backend/app/dto/request/app.go

@@ -32,6 +32,7 @@ type AppContainerConfig struct {
 	EditCompose   bool    `json:"editCompose"`
 	DockerCompose string  `json:"dockerCompose"`
 	HostMode      bool    `json:"hostMode"`
+	PullImage     bool    `json:"pullImage"`
 }
 
 type AppInstalledSearch struct {
@@ -67,6 +68,7 @@ type AppInstalledOperate struct {
 	DeleteBackup bool                `json:"deleteBackup"`
 	DeleteDB     bool                `json:"deleteDB"`
 	Backup       bool                `json:"backup"`
+	PullImage    bool                `json:"pullImage"`
 }
 
 type AppInstalledUpdate struct {

backend/app/dto/request/file.go

@@ -64,7 +64,7 @@ type FileDeCompress struct {
 
 type FileEdit struct {
 	Path    string `json:"path"  validate:"required"`
-	Content string `json:"content"  validate:"required"`
+	Content string `json:"content"`
 }
 
 type FileRename struct {

backend/app/dto/response/app.go

@@ -1,9 +1,10 @@
 package response
 
 import (
+	"time"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
-	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 )
@@ -72,10 +73,11 @@ type AppInstalledDTO struct {
 }
 
 type DatabaseConn struct {
-	Username    string `json:"username"`
-	Password    string `json:"password"`
-	ServiceName string `json:"serviceName"`
-	Port        int64  `json:"port"`
+	Username      string `json:"username"`
+	Password      string `json:"password"`
+	ContainerName string `json:"containerName"`
+	ServiceName   string `json:"serviceName"`
+	Port          int64  `json:"port"`
 }
 
 type AppService struct {

backend/app/dto/setting.go

@@ -52,6 +52,8 @@ type SettingInfo struct {
 	AppStoreSyncStatus   string `json:"appStoreSyncStatus"`
 
 	FileRecycleBin string `json:"fileRecycleBin"`
+
+	SnapshotIgnore string `json:"snapshotIgnore"`
 }
 
 type SettingUpdate struct {
@@ -99,9 +101,10 @@ type SnapshotStatus struct {
 }
 
 type SnapshotCreate struct {
-	ID          uint   `json:"id"`
-	From        string `json:"from" validate:"required,oneof=OSS S3 SFTP MINIO COS KODO OneDrive WebDAV"`
-	Description string `json:"description" validate:"max=256"`
+	ID              uint   `json:"id"`
+	From            string `json:"from" validate:"required"`
+	DefaultDownload string `json:"defaultDownload" validate:"required"`
+	Description     string `json:"description" validate:"max=256"`
 }
 type SnapshotRecover struct {
 	IsNew      bool `json:"isNew"`
@@ -114,14 +117,15 @@ type SnapshotImport struct {
 	Description string   `json:"description" validate:"max=256"`
 }
 type SnapshotInfo struct {
-	ID          uint      `json:"id"`
-	Name        string    `json:"name"`
-	Description string    `json:"description" validate:"max=256"`
-	From        string    `json:"from"`
-	Status      string    `json:"status"`
-	Message     string    `json:"message"`
-	CreatedAt   time.Time `json:"createdAt"`
-	Version     string    `json:"version"`
+	ID              uint      `json:"id"`
+	Name            string    `json:"name"`
+	Description     string    `json:"description" validate:"max=256"`
+	From            string    `json:"from"`
+	DefaultDownload string    `json:"defaultDownload"`
+	Status          string    `json:"status"`
+	Message         string    `json:"message"`
+	CreatedAt       time.Time `json:"createdAt"`
+	Version         string    `json:"version"`
 
 	InterruptStep    string `json:"interruptStep"`
 	RecoverStatus    string `json:"recoverStatus"`

backend/app/model/backup.go

@@ -12,6 +12,8 @@ type BackupAccount struct {
 
 type BackupRecord struct {
 	BaseModel
+	From       string `gorm:"type:varchar(64)" json:"from"`
+	CronjobID  uint   `gorm:"type:decimal" json:"cronjobID"`
 	Type       string `gorm:"type:varchar(64);not null" json:"type"`
 	Name       string `gorm:"type:varchar(64);not null" json:"name"`
 	DetailName string `gorm:"type:varchar(256)" json:"detailName"`

backend/app/model/cronjob.go

@@ -5,15 +5,9 @@ import "time"
 type Cronjob struct {
 	BaseModel
 
-	Name     string `gorm:"type:varchar(64);not null;unique" json:"name"`
-	Type     string `gorm:"type:varchar(64);not null" json:"type"`
-	SpecType string `gorm:"type:varchar(64);not null" json:"specType"`
-	Spec     string `gorm:"type:varchar(64);not null" json:"spec"`
-	Week     uint64 `gorm:"type:decimal" json:"week"`
-	Day      uint64 `gorm:"type:decimal" json:"day"`
-	Hour     uint64 `gorm:"type:decimal" json:"hour"`
-	Minute   uint64 `gorm:"type:decimal" json:"minute"`
-	Second   uint64 `gorm:"type:decimal" json:"second"`
+	Name string `gorm:"type:varchar(64);not null" json:"name"`
+	Type string `gorm:"type:varchar(64);not null" json:"type"`
+	Spec string `gorm:"type:varchar(64);not null" json:"spec"`
 
 	ContainerName  string `gorm:"type:varchar(64)" json:"containerName"`
 	Script         string `gorm:"longtext" json:"script"`
@@ -25,13 +19,17 @@ type Cronjob struct {
 	SourceDir      string `gorm:"type:varchar(256)" json:"sourceDir"`
 	ExclusionRules string `gorm:"longtext" json:"exclusionRules"`
 
-	KeepLocal    bool   `gorm:"type:varchar(64)" json:"keepLocal"`
-	TargetDirID  uint64 `gorm:"type:decimal" json:"targetDirID"`
-	RetainCopies uint64 `gorm:"type:decimal" json:"retainCopies"`
+	// 已废弃
+	KeepLocal   bool   `gorm:"type:varchar(64)" json:"keepLocal"`
+	TargetDirID uint64 `gorm:"type:decimal" json:"targetDirID"`
 
-	Status  string       `gorm:"type:varchar(64)" json:"status"`
-	EntryID uint64       `gorm:"type:decimal" json:"entryID"`
-	Records []JobRecords `json:"records"`
+	BackupAccounts  string `gorm:"type:varchar(64)" json:"backupAccounts"`
+	DefaultDownload string `gorm:"type:varchar(64)" json:"defaultDownload"`
+	RetainCopies    uint64 `gorm:"type:decimal" json:"retainCopies"`
+
+	Status   string       `gorm:"type:varchar(64)" json:"status"`
+	EntryIDs string       `gorm:"type:varchar(64)" json:"entryIDs"`
+	Records  []JobRecords `json:"records"`
 }
 
 type JobRecords struct {

backend/app/model/database_mysql.go

@@ -9,5 +9,6 @@ type DatabaseMysql struct {
 	Username    string `json:"username" gorm:"type:varchar(256);not null"`
 	Password    string `json:"password" gorm:"type:varchar(256);not null"`
 	Permission  string `json:"permission" gorm:"type:varchar(256);not null"`
+	IsDelete    bool   `json:"isDelete" gorm:"type:varchar(64)"`
 	Description string `json:"description" gorm:"type:varchar(256);"`
 }

backend/app/model/database_postgresql.go

@@ -8,6 +8,7 @@ type DatabasePostgresql struct {
 	Format         string `json:"format" gorm:"type:varchar(64);not null"`
 	Username       string `json:"username" gorm:"type:varchar(256);not null"`
 	Password       string `json:"password" gorm:"type:varchar(256);not null"`
-	SuperUser      bool   `json:"superUser" gorm:"type:varchar(64)" `
+	SuperUser      bool   `json:"superUser" gorm:"type:varchar(64)"`
+	IsDelete       bool   `json:"isDelete" gorm:"type:varchar(64)"`
 	Description    string `json:"description" gorm:"type:varchar(256);"`
 }

backend/app/model/snapshot.go

@@ -2,12 +2,13 @@ package model
 
 type Snapshot struct {
 	BaseModel
-	Name        string `json:"name" gorm:"type:varchar(64);not null;unique"`
-	Description string `json:"description" gorm:"type:varchar(256)"`
-	From        string `json:"from"`
-	Status      string `json:"status" gorm:"type:varchar(64)"`
-	Message     string `json:"message" gorm:"type:varchar(256)"`
-	Version     string `json:"version" gorm:"type:varchar(256)"`
+	Name            string `json:"name" gorm:"type:varchar(64);not null;unique"`
+	Description     string `json:"description" gorm:"type:varchar(256)"`
+	From            string `json:"from"`
+	DefaultDownload string `json:"defaultDownload" gorm:"type:varchar(64)"`
+	Status          string `json:"status" gorm:"type:varchar(64)"`
+	Message         string `json:"message" gorm:"type:varchar(256)"`
+	Version         string `json:"version" gorm:"type:varchar(256)"`
 
 	InterruptStep    string `json:"interruptStep" gorm:"type:varchar(64)"`
 	RecoverStatus    string `json:"recoverStatus" gorm:"type:varchar(64)"`

backend/app/repo/backup.go

@@ -2,6 +2,7 @@ package repo
 
 import (
 	"context"
+
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"gorm.io/gorm"
@@ -23,6 +24,7 @@ type IBackupRepo interface {
 	WithByDetailName(detailName string) DBOption
 	WithByFileName(fileName string) DBOption
 	WithByType(backupType string) DBOption
+	WithByCronID(cronjobID uint) DBOption
 }
 
 func NewIBackupRepo() IBackupRepo {
@@ -125,3 +127,9 @@ func (u *BackupRepo) Delete(opts ...DBOption) error {
 func (u *BackupRepo) DeleteRecord(ctx context.Context, opts ...DBOption) error {
 	return getTx(ctx, opts...).Delete(&model.BackupRecord{}).Error
 }
+
+func (u *BackupRepo) WithByCronID(cronjobID uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("cronjob_id = ?", cronjobID)
+	}
+}

backend/app/repo/cronjob.go

@@ -20,7 +20,8 @@ type ICronjobRepo interface {
 	Page(limit, offset int, opts ...DBOption) (int64, []model.Cronjob, error)
 	Create(cronjob *model.Cronjob) error
 	WithByJobID(id int) DBOption
-	WithByBackupID(id uint) DBOption
+	WithByDbName(name string) DBOption
+	WithByDefaultDownload(account string) DBOption
 	WithByRecordDropID(id int) DBOption
 	WithByRecordFile(file string) DBOption
 	Save(id uint, cronjob model.Cronjob) error
@@ -28,6 +29,7 @@ type ICronjobRepo interface {
 	Delete(opts ...DBOption) error
 	DeleteRecord(opts ...DBOption) error
 	StartRecords(cronjobID uint, fromLocal bool, targetPath string) model.JobRecords
+	UpdateRecords(id uint, vars map[string]interface{}) error
 	EndRecords(record model.JobRecords, status, message, records string)
 	PageRecords(page, size int, opts ...DBOption) (int64, []model.JobRecords, error)
 }
@@ -116,9 +118,15 @@ func (c *CronjobRepo) WithByJobID(id int) DBOption {
 	}
 }
 
-func (c *CronjobRepo) WithByBackupID(id uint) DBOption {
+func (c *CronjobRepo) WithByDbName(name string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
-		return g.Where("target_dir_id = ?", id)
+		return g.Where("db_name = ?", name)
+	}
+}
+
+func (c *CronjobRepo) WithByDefaultDownload(account string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("default_download = ?", account)
 	}
 }
 
@@ -164,6 +172,10 @@ func (u *CronjobRepo) Update(id uint, vars map[string]interface{}) error {
 	return global.DB.Model(&model.Cronjob{}).Where("id = ?", id).Updates(vars).Error
 }
 
+func (u *CronjobRepo) UpdateRecords(id uint, vars map[string]interface{}) error {
+	return global.DB.Model(&model.JobRecords{}).Where("id = ?", id).Updates(vars).Error
+}
+
 func (u *CronjobRepo) Delete(opts ...DBOption) error {
 	db := global.DB
 	for _, opt := range opts {

backend/app/repo/website.go

@@ -18,6 +18,7 @@ type IWebsiteRepo interface {
 	WithDefaultServer() DBOption
 	WithDomainLike(domain string) DBOption
 	WithRuntimeID(runtimeID uint) DBOption
+	WithIDs(ids []uint) DBOption
 	Page(page, size int, opts ...DBOption) (int64, []model.Website, error)
 	List(opts ...DBOption) ([]model.Website, error)
 	GetFirst(opts ...DBOption) (model.Website, error)
@@ -36,9 +37,15 @@ func NewIWebsiteRepo() IWebsiteRepo {
 type WebsiteRepo struct {
 }
 
-func (w *WebsiteRepo) WithAppInstallId(appInstallId uint) DBOption {
+func (w *WebsiteRepo) WithAppInstallId(appInstallID uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
-		return db.Where("app_install_id = ?", appInstallId)
+		return db.Where("app_install_id = ?", appInstallID)
+	}
+}
+
+func (w *WebsiteRepo) WithIDs(ids []uint) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("id in (?)", ids)
 	}
 }
 

backend/app/repo/website_domain.go

@@ -14,6 +14,7 @@ type IWebsiteDomainRepo interface {
 	WithWebsiteId(websiteId uint) DBOption
 	WithPort(port int) DBOption
 	WithDomain(domain string) DBOption
+	WithDomainLike(domain string) DBOption
 	Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDomain, error)
 	GetFirst(opts ...DBOption) (model.WebsiteDomain, error)
 	GetBy(opts ...DBOption) ([]model.WebsiteDomain, error)
@@ -44,6 +45,11 @@ func (w WebsiteDomainRepo) WithDomain(domain string) DBOption {
 		return db.Where("domain = ?", domain)
 	}
 }
+func (w WebsiteDomainRepo) WithDomainLike(domain string) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("domain like ?", "%"+domain+"%")
+	}
+}
 func (w WebsiteDomainRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDomain, error) {
 	var domains []model.WebsiteDomain
 	db := getDb(opts...).Model(&model.WebsiteDomain{})

backend/app/service/app.go

@@ -397,7 +397,7 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 		}
 		index++
 	}
-	if app.Limit == 0 && appInstall.Name != serviceName {
+	if app.Limit == 0 && appInstall.Name != serviceName && len(servicesMap) == 1 {
 		servicesMap[appInstall.Name] = servicesMap[serviceName]
 		delete(servicesMap, serviceName)
 		serviceName = appInstall.Name
@@ -459,7 +459,7 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 		if err = runScript(appInstall, "init"); err != nil {
 			return
 		}
-		upApp(appInstall)
+		upApp(appInstall, req.PullImage)
 	}()
 	go updateToolApp(appInstall)
 	return

backend/app/service/app_install.go

@@ -12,8 +12,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/1Panel-dev/1Panel/backend/i18n"
-
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"gopkg.in/yaml.v3"
 
@@ -152,7 +150,7 @@ func (a *AppInstallService) CheckExist(req request.AppInstalledInfo) (*response.
 	if reflect.DeepEqual(appInstall, model.AppInstall{}) {
 		return res, nil
 	}
-	if err = syncByID(appInstall.ID); err != nil {
+	if err = syncAppInstallStatus(&appInstall); err != nil {
 		return nil, err
 	}
 
@@ -188,6 +186,7 @@ func (a *AppInstallService) LoadConnInfo(req dto.OperationWithNameAndType) (resp
 	data.Password = app.Password
 	data.ServiceName = app.ServiceName
 	data.Port = app.Port
+	data.ContainerName = app.ContainerName
 	return data, nil
 }
 
@@ -241,28 +240,28 @@ func (a *AppInstallService) Operate(req request.AppInstalledOperate) error {
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncByID(install.ID)
+		return syncAppInstallStatus(&install)
 	case constant.Stop:
 		out, err := compose.Stop(dockerComposePath)
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncByID(install.ID)
+		return syncAppInstallStatus(&install)
 	case constant.Restart:
 		out, err := compose.Restart(dockerComposePath)
 		if err != nil {
 			return handleErr(install, err, out)
 		}
-		return syncByID(install.ID)
+		return syncAppInstallStatus(&install)
 	case constant.Delete:
 		if err := deleteAppInstall(install, req.DeleteBackup, req.ForceDelete, req.DeleteDB); err != nil && !req.ForceDelete {
 			return err
 		}
 		return nil
 	case constant.Sync:
-		return syncByID(install.ID)
+		return syncAppInstallStatus(&install)
 	case constant.Upgrade:
-		return upgradeInstall(install.ID, req.DetailId, req.Backup)
+		return upgradeInstall(install.ID, req.DetailId, req.Backup, req.PullImage)
 	case constant.Reload:
 		return opNginx(install.ContainerName, constant.NginxReload)
 	default:
@@ -412,7 +411,7 @@ func (a *AppInstallService) SyncAll(systemInit bool) error {
 		return err
 	}
 	for _, i := range allList {
-		if i.Status == constant.Installing || i.Status == constant.Upgrading {
+		if i.Status == constant.Installing || i.Status == constant.Upgrading || i.Status == constant.Rebuilding {
 			if systemInit {
 				i.Status = constant.Error
 				i.Message = "1Panel restart causes the task to terminate"
@@ -421,7 +420,7 @@ func (a *AppInstallService) SyncAll(systemInit bool) error {
 			continue
 		}
 		if !systemInit {
-			if err := syncByID(i.ID); err != nil {
+			if err = syncAppInstallStatus(&i); err != nil {
 				global.LOG.Errorf("sync install app[%s] error,mgs: %s", i.Name, err.Error())
 			}
 		}
@@ -528,7 +527,7 @@ func (a *AppInstallService) ChangeAppPort(req request.PortUpdate) error {
 		return nil
 	}
 
-	if err := updateInstallInfoInDB(req.Key, req.Name, "port", true, strconv.FormatInt(req.Port, 10)); err != nil {
+	if err := updateInstallInfoInDB(req.Key, req.Name, "port", strconv.FormatInt(req.Port, 10)); err != nil {
 		return nil
 	}
 
@@ -640,10 +639,11 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	for _, form := range appForm.FormFields {
 		if v, ok := envs[form.EnvKey]; ok {
 			appParam := response.AppParam{
-				Edit: false,
-				Key:  form.EnvKey,
-				Rule: form.Rule,
-				Type: form.Type,
+				Edit:     false,
+				Key:      form.EnvKey,
+				Rule:     form.Rule,
+				Type:     form.Type,
+				Multiple: form.Multiple,
 			}
 			if form.Edit {
 				appParam.Edit = true
@@ -655,10 +655,20 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 				appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithServiceName(v.(string)))
 				appParam.ShowValue = appInstall.Name
 			} else if form.Type == "select" {
-				for _, fv := range form.Values {
-					if fv.Value == v {
-						appParam.ShowValue = fv.Label
-						break
+				if form.Multiple {
+					if v == "" {
+						appParam.Value = []string{}
+					} else {
+						if str, ok := v.(string); ok {
+							appParam.Value = strings.Split(str, ",")
+						}
+					}
+				} else {
+					for _, fv := range form.Values {
+						if fv.Value == v {
+							appParam.ShowValue = fv.Label
+							break
+						}
 					}
 				}
 				appParam.Values = form.Values
@@ -666,14 +676,15 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 			params = append(params, appParam)
 		} else {
 			params = append(params, response.AppParam{
-				Edit:    form.Edit,
-				Key:     form.EnvKey,
-				Rule:    form.Rule,
-				Type:    form.Type,
-				LabelZh: form.LabelZh,
-				LabelEn: form.LabelEn,
-				Value:   form.Default,
-				Values:  form.Values,
+				Edit:     form.Edit,
+				Key:      form.EnvKey,
+				Rule:     form.Rule,
+				Type:     form.Type,
+				LabelZh:  form.LabelZh,
+				LabelEn:  form.LabelEn,
+				Value:    form.Default,
+				Values:   form.Values,
+				Multiple: form.Multiple,
 			})
 		}
 	}
@@ -689,15 +700,11 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	return &res, nil
 }
 
-func syncByID(installID uint) error {
-	appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(installID))
-	if err != nil {
-		return err
-	}
-	if appInstall.Status == constant.Installing {
+func syncAppInstallStatus(appInstall *model.AppInstall) error {
+	if appInstall.Status == constant.Installing || appInstall.Status == constant.Rebuilding || appInstall.Status == constant.Upgrading {
 		return nil
 	}
-	containerNames, err := getContainerNames(appInstall)
+	containerNames, err := getContainerNames(*appInstall)
 	if err != nil {
 		return err
 	}
@@ -709,75 +716,69 @@ func syncByID(installID uint) error {
 	if err != nil {
 		return err
 	}
+
 	var (
-		errorContainers    []string
-		notFoundContainers []string
-		runningContainers  []string
-		exitedContainers   []string
+		runningCount         int
+		exitedCount          int
+		pausedCount          int
+		exitedContainerNames []string
+		total                = len(containerNames)
+		count                = len(containers)
 	)
 
-	for _, n := range containers {
-		switch n.State {
+	foundNames := make(map[string]bool)
+	for _, con := range containers {
+		foundNames[con.Names[0]] = true
+		switch con.State {
 		case "exited":
-			exitedContainers = append(exitedContainers, n.Names[0])
+			exitedContainerNames = append(exitedContainerNames, strings.TrimPrefix(con.Names[0], "/"))
+			exitedCount++
 		case "running":
-			runningContainers = append(runningContainers, n.Names[0])
-		default:
-			errorContainers = append(errorContainers, n.Names[0])
+			runningCount++
+		case "paused":
+			pausedCount++
 		}
 	}
+
+	var notFoundNames []string
 	for _, name := range containerNames {
-		exist := false
-		for _, container := range containers {
-			if common.ExistWithStrArray(name, container.Names) {
-				exist = true
-				break
-			}
-		}
-		if !exist {
-			notFoundContainers = append(notFoundContainers, name)
+		if !foundNames["/"+name] {
+			notFoundNames = append(notFoundNames, name)
 		}
 	}
 
-	containerCount := len(containers)
-	errCount := len(errorContainers)
-	notFoundCount := len(notFoundContainers)
-	existedCount := len(exitedContainers)
-	normalCount := len(containerNames)
-	runningCount := len(runningContainers)
-
-	if containerCount == 0 {
-		appInstall.Status = constant.Error
-		appInstall.Message = i18n.GetMsgWithMap("ErrContainerNotFound", map[string]interface{}{"name": strings.Join(containerNames, ",")})
-		return appInstallRepo.Save(context.Background(), &appInstall)
-	}
-	if errCount == 0 && existedCount == 0 && notFoundCount == 0 {
-		appInstall.Status = constant.Running
-		return appInstallRepo.Save(context.Background(), &appInstall)
-	}
-	if existedCount == normalCount {
+	switch {
+	case count == 0:
+		if appInstall.Status != constant.Error {
+			appInstall.Status = constant.SyncErr
+			appInstall.Message = buserr.WithName("ErrContainerNotFound", strings.Join(containerNames, ",")).Error()
+		}
+	case exitedCount == total:
 		appInstall.Status = constant.Stopped
-		return appInstallRepo.Save(context.Background(), &appInstall)
-	}
-	if errCount == normalCount {
-		appInstall.Status = constant.Error
-	}
-	if runningCount < normalCount {
+	case runningCount == total:
+		appInstall.Status = constant.Running
+	case pausedCount == total:
+		appInstall.Status = constant.Paused
+	default:
+		var msg string
+		if exitedCount > 0 {
+			msg = buserr.WithName("ErrContainerMsg", strings.Join(exitedContainerNames, ",")).Error()
+		}
+		if len(notFoundNames) > 0 {
+			msg += buserr.WithName("ErrContainerNotFound", strings.Join(notFoundNames, ",")).Error()
+		}
+		if msg == "" {
+			msg = buserr.New("ErrAppWarn").Error()
+		}
+		appInstall.Message = msg
 		appInstall.Status = constant.UnHealthy
 	}
+	_ = appInstallRepo.Save(context.Background(), appInstall)
 
-	var errMsg string
-	if errCount > 0 {
-		errMsg += i18n.GetMsgWithMap("ErrContainerMsg", map[string]interface{}{"name": strings.Join(errorContainers, ",")})
-	}
-	if notFoundCount > 0 {
-		errMsg += i18n.GetMsgWithMap("ErrContainerNotFound", map[string]interface{}{"name": strings.Join(notFoundContainers, ",")})
-	}
-	appInstall.Message = errMsg
-	return appInstallRepo.Save(context.Background(), &appInstall)
+	return nil
 }
 
-func updateInstallInfoInDB(appKey, appName, param string, isRestart bool, value interface{}) error {
+func updateInstallInfoInDB(appKey, appName, param string, value interface{}) error {
 	if param != "password" && param != "port" && param != "user-password" {
 		return nil
 	}

backend/app/service/app_utils.go

@@ -354,8 +354,8 @@ func deleteAppInstall(install model.AppInstall, deleteBackup bool, forceDelete b
 					websiteApp, _ := appRepo.GetFirst(commonRepo.WithByID(websiteAppInstall.AppId))
 					if websiteApp.Type == constant.RuntimePHP {
 						go func() {
-							_, _ = compose.Down(install.GetComposePath())
-							_ = op.DeleteDir(install.GetPath())
+							_, _ = compose.Down(websiteAppInstall.GetComposePath())
+							_ = op.DeleteDir(websiteAppInstall.GetPath())
 						}()
 						_ = appInstallRepo.Delete(ctx, websiteAppInstall)
 					}
@@ -433,12 +433,12 @@ func deleteLink(ctx context.Context, install *model.AppInstall, deleteDB bool, f
 	return appInstallResourceRepo.DeleteBy(ctx, appInstallResourceRepo.WithAppInstallId(install.ID))
 }
 
-func upgradeInstall(installId uint, detailId uint, backup bool) error {
-	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(installId))
+func upgradeInstall(installID uint, detailID uint, backup, pullImage bool) error {
+	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(installID))
 	if err != nil {
 		return err
 	}
-	detail, err := appDetailRepo.GetFirst(commonRepo.WithByID(detailId))
+	detail, err := appDetailRepo.GetFirst(commonRepo.WithByID(detailID))
 	if err != nil {
 		return err
 	}
@@ -492,23 +492,6 @@ func upgradeInstall(installId uint, detailId uint, backup bool) error {
 			detailDir = path.Join(constant.ResourceDir, "apps", "local", strings.TrimPrefix(install.App.Key, "local"), detail.Version)
 		}
 
-		images, err := composeV2.GetDockerComposeImages([]byte(detail.DockerCompose))
-		if err != nil {
-			upErr = err
-			return
-		}
-		dockerCli, err := composeV2.NewClient()
-		if err != nil {
-			upErr = err
-			return
-		}
-		for _, image := range images {
-			if err = dockerCli.PullImage(image, true); err != nil {
-				upErr = buserr.WithNameAndErr("ErrDockerPullImage", "", err)
-				return
-			}
-		}
-
 		command := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -rn %s/* %s || true", detailDir, install.GetPath()))
 		stdout, _ := command.CombinedOutput()
 		if stdout != nil {
@@ -573,7 +556,7 @@ func upgradeInstall(installId uint, detailId uint, backup bool) error {
 
 		install.DockerCompose = string(composeByte)
 		install.Version = detail.Version
-		install.AppDetailId = detailId
+		install.AppDetailId = detailID
 
 		if out, err := compose.Down(install.GetComposePath()); err != nil {
 			if out != "" {
@@ -592,6 +575,31 @@ func upgradeInstall(installId uint, detailId uint, backup bool) error {
 			return
 		}
 
+		content, err := fileOp.GetContent(install.GetEnvPath())
+		if err != nil {
+			upErr = err
+			return
+		}
+
+		if pullImage {
+			images, err := composeV2.GetDockerComposeImages(install.Name, content, []byte(detail.DockerCompose))
+			if err != nil {
+				upErr = err
+				return
+			}
+			dockerCli, err := composeV2.NewClient()
+			if err != nil {
+				upErr = err
+				return
+			}
+			for _, image := range images {
+				if err = dockerCli.PullImage(image, true); err != nil {
+					upErr = buserr.WithNameAndErr("ErrDockerPullImage", "", err)
+					return
+				}
+			}
+		}
+
 		if upErr = fileOp.WriteFile(install.GetComposePath(), strings.NewReader(install.DockerCompose), 0775); upErr != nil {
 			return
 		}
@@ -679,6 +687,12 @@ func handleMap(params map[string]interface{}, envParams map[string]string) {
 			envParams[k] = strconv.Itoa(int(t))
 		case int:
 			envParams[k] = strconv.Itoa(t)
+		case []interface{}:
+			strArray := make([]string, len(t))
+			for i := range t {
+				strArray[i] = strings.ToLower(fmt.Sprintf("%v", t[i]))
+			}
+			envParams[k] = strings.Join(strArray, ",")
 		default:
 			envParams[k] = t.(string)
 		}
@@ -833,39 +847,36 @@ func checkContainerNameIsExist(containerName, appDir string) (bool, error) {
 	return false, nil
 }
 
-func upApp(appInstall *model.AppInstall) {
+func upApp(appInstall *model.AppInstall, pullImages bool) {
 	upProject := func(appInstall *model.AppInstall) (err error) {
-		if err == nil {
-			var (
-				out    string
-				errMsg string
-			)
-			if appInstall.App.Type != "php" {
-				out, err = compose.Pull(appInstall.GetComposePath())
-				if err != nil {
-					if out != "" {
-						if strings.Contains(out, "no such host") {
-							errMsg = i18n.GetMsgByKey("ErrNoSuchHost") + ":"
-						}
-						if strings.Contains(out, "timeout") {
-							errMsg = i18n.GetMsgByKey("ErrImagePullTimeOut") + ":"
-						}
-						appInstall.Message = errMsg + out
-					}
-					return err
-				}
-			}
-			out, err = compose.Up(appInstall.GetComposePath())
+		var (
+			out    string
+			errMsg string
+		)
+		if pullImages && appInstall.App.Type != "php" {
+			out, err = compose.Pull(appInstall.GetComposePath())
 			if err != nil {
 				if out != "" {
+					if strings.Contains(out, "no such host") {
+						errMsg = i18n.GetMsgByKey("ErrNoSuchHost") + ":"
+					}
+					if strings.Contains(out, "timeout") {
+						errMsg = i18n.GetMsgByKey("ErrImagePullTimeOut") + ":"
+					}
 					appInstall.Message = errMsg + out
 				}
 				return err
 			}
-			return
-		} else {
-			return
 		}
+
+		out, err = compose.Up(appInstall.GetComposePath())
+		if err != nil {
+			if out != "" {
+				appInstall.Message = errMsg + out
+			}
+			return err
+		}
+		return
 	}
 	if err := upProject(appInstall); err != nil {
 		appInstall.Status = constant.Error
@@ -888,11 +899,12 @@ func rebuildApp(appInstall model.AppInstall) error {
 			_ = handleErr(appInstall, err, out)
 			return
 		}
-		out, err = compose.Up(dockerComposePath)
+		out, err = compose.Up(appInstall.GetComposePath())
 		if err != nil {
 			_ = handleErr(appInstall, err, out)
 			return
 		}
+
 		appInstall.Status = constant.Running
 		_ = appInstallRepo.Save(context.Background(), &appInstall)
 	}()
@@ -980,6 +992,43 @@ func handleLocalAppDetail(versionDir string, appDetail *model.AppDetail) error {
 	if err != nil {
 		return buserr.WithMap(constant.ErrFileParseApp, map[string]interface{}{"name": "data.yml", "err": err.Error()}, err)
 	}
+	var appParam dto.AppForm
+	if err = json.Unmarshal(dataJson, &appParam); err != nil {
+		return buserr.WithMap(constant.ErrFileParseApp, map[string]interface{}{"name": "data.yml", "err": err.Error()}, err)
+	}
+	for _, formField := range appParam.FormFields {
+		if strings.Contains(formField.EnvKey, " ") {
+			return buserr.WithName(constant.ErrAppParamKey, formField.EnvKey)
+		}
+	}
+
+	var dataMap map[string]interface{}
+	err = yaml.Unmarshal(paramByte, &dataMap)
+	if err != nil {
+		return buserr.WithMap(constant.ErrFileParseApp, map[string]interface{}{"name": "data.yml", "err": err.Error()}, err)
+	}
+
+	additionalProperties, ok := dataMap["additionalProperties"].(map[string]interface{})
+	if !ok {
+		return buserr.WithName(constant.ErrAppParamKey, "additionalProperties")
+	}
+
+	formFieldsInterface, ok := additionalProperties["formFields"]
+	if ok {
+		formFields, ok := formFieldsInterface.([]interface{})
+		if !ok {
+			return buserr.WithName(constant.ErrAppParamKey, "formFields")
+		}
+		for _, item := range formFields {
+			field := item.(map[string]interface{})
+			for key, value := range field {
+				if value == nil {
+					return buserr.WithName(constant.ErrAppParamKey, key)
+				}
+			}
+		}
+	}
+
 	appDetail.Params = string(dataJson)
 	return nil
 }
@@ -1031,8 +1080,8 @@ func handleErr(install model.AppInstall, err error, out string) error {
 	if out != "" {
 		install.Message = out
 		reErr = errors.New(out)
-		install.Status = constant.Error
 	}
+	install.Status = constant.Error
 	_ = appInstallRepo.Save(context.Background(), &install)
 	return reErr
 }
@@ -1043,6 +1092,10 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool) ([]respons
 		if updated && (installed.App.Type == "php" || installed.Status == constant.Installing || (installed.App.Key == constant.AppMysql && installed.Version == "5.6.51")) {
 			continue
 		}
+		if err := syncAppInstallStatus(&installed); err != nil {
+			global.LOG.Error("sync app install status error : ", err)
+		}
+
 		installDTO := response.AppInstalledDTO{
 			AppInstall: installed,
 			Path:       installed.GetPath(),
@@ -1057,7 +1110,7 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool) ([]respons
 		}
 		var versions []string
 		for _, detail := range details {
-			if detail.IgnoreUpgrade {
+			if detail.IgnoreUpgrade || installed.Version == "latest" {
 				continue
 			}
 			if common.IsCrossVersion(installed.Version, detail.Version) && !app.CrossVersionUpdate {

backend/app/service/auth.go

@@ -109,6 +109,10 @@ func (u *AuthService) generateSession(c *gin.Context, name, authMethod string) (
 	if err != nil {
 		return nil, err
 	}
+	httpsSetting, err := settingRepo.Get(settingRepo.WithByKey("SSL"))
+	if err != nil {
+		return nil, err
+	}
 	lifeTime, err := strconv.Atoi(setting.Value)
 	if err != nil {
 		return nil, err
@@ -129,7 +133,7 @@ func (u *AuthService) generateSession(c *gin.Context, name, authMethod string) (
 	sessionUser, err := global.SESSION.Get(sID)
 	if err != nil {
 		sID = uuid.New().String()
-		c.SetCookie(constant.SessionName, sID, 0, "", "", false, false)
+		c.SetCookie(constant.SessionName, sID, 0, "", "", httpsSetting.Value == "enable", true)
 		err := global.SESSION.Set(sID, sessionUser, lifeTime)
 		if err != nil {
 			return nil, err
@@ -144,9 +148,13 @@ func (u *AuthService) generateSession(c *gin.Context, name, authMethod string) (
 }
 
 func (u *AuthService) LogOut(c *gin.Context) error {
+	httpsSetting, err := settingRepo.Get(settingRepo.WithByKey("SSL"))
+	if err != nil {
+		return err
+	}
 	sID, _ := c.Cookie(constant.SessionName)
 	if sID != "" {
-		c.SetCookie(constant.SessionName, sID, -1, "", "", false, false)
+		c.SetCookie(constant.SessionName, sID, -1, "", "", httpsSetting.Value == "enable", true)
 		err := global.SESSION.Delete(sID)
 		if err != nil {
 			return err

backend/app/service/backup.go

@@ -6,12 +6,12 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"io"
-	"net/http"
-	"net/url"
 	"os"
 	"path"
+	"sort"
 	"strings"
+	"sync"
+	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
@@ -19,6 +19,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cloud_storage"
+	"github.com/1Panel-dev/1Panel/backend/utils/cloud_storage/client"
 	fileUtils "github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/jinzhu/copier"
 	"github.com/pkg/errors"
@@ -29,7 +30,8 @@ type BackupService struct{}
 type IBackupService interface {
 	List() ([]dto.BackupInfo, error)
 	SearchRecordsWithPage(search dto.RecordSearch) (int64, []dto.BackupRecords, error)
-	LoadOneDriveInfo() (string, error)
+	SearchRecordsByCronjobWithPage(search dto.RecordSearchByCronjob) (int64, []dto.BackupRecords, error)
+	LoadOneDriveInfo() (dto.OneDriveInfo, error)
 	DownloadRecord(info dto.DownloadRecord) (string, error)
 	Create(backupDto dto.BackupOperate) error
 	GetBuckets(backupDto dto.ForBuckets) ([]interface{}, error)
@@ -38,7 +40,7 @@ type IBackupService interface {
 	BatchDeleteRecord(ids []uint) error
 	NewClient(backup *model.BackupAccount) (cloud_storage.CloudStorageClient, error)
 
-	ListFiles(req dto.BackupSearchFile) ([]string, error)
+	ListFiles(req dto.BackupSearchFile) []string
 
 	MysqlBackup(db dto.CommonBackup) error
 	PostgresqlBackup(db dto.CommonBackup) error
@@ -55,6 +57,8 @@ type IBackupService interface {
 
 	AppBackup(db dto.CommonBackup) error
 	AppRecover(req dto.CommonRecover) error
+
+	Run()
 }
 
 func NewIBackupService() IBackupService {
@@ -84,65 +88,72 @@ func (u *BackupService) SearchRecordsWithPage(search dto.RecordSearch) (int64, [
 		commonRepo.WithByType(search.Type),
 		backupRepo.WithByDetailName(search.DetailName),
 	)
-
-	var datas []dto.BackupRecords
-	clientMap := make(map[string]loadSizeHelper)
-	for i := 0; i < len(records); i++ {
-		var item dto.BackupRecords
-		if err := copier.Copy(&item, &records[i]); err != nil {
-			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		itemPath := path.Join(records[i].FileDir, records[i].FileName)
-		if records[i].Source == "LOCAL" {
-			fileInfo, err := os.Stat(itemPath)
-			if err == nil {
-				item.Size = fileInfo.Size()
-			}
-			datas = append(datas, item)
-			continue
-		}
-		if _, ok := clientMap[records[i].Source]; !ok {
-			backup, err := backupRepo.Get(commonRepo.WithByType(records[i].Source))
-			if err != nil {
-				global.LOG.Errorf("load backup model %s from db failed, err: %v", records[i].Source, err)
-				return total, datas, err
-			}
-			client, err := u.NewClient(&backup)
-			if err != nil {
-				global.LOG.Errorf("load backup client %s from db failed, err: %v", records[i].Source, err)
-				return total, datas, err
-			}
-			item.Size, _ = client.Size(path.Join(strings.TrimLeft(backup.BackupPath, "/"), itemPath))
-			datas = append(datas, item)
-			clientMap[records[i].Source] = loadSizeHelper{backupPath: strings.TrimLeft(backup.BackupPath, "/"), client: client}
-			continue
-		}
-		item.Size, _ = clientMap[records[i].Source].client.Size(path.Join(clientMap[records[i].Source].backupPath, itemPath))
-		datas = append(datas, item)
+	if err != nil {
+		return 0, nil, err
 	}
+
+	datas, err := u.loadRecordSize(records)
+	sort.Slice(datas, func(i, j int) bool {
+		return datas[i].CreatedAt.After(datas[j].CreatedAt)
+	})
+	return total, datas, err
+}
+
+func (u *BackupService) SearchRecordsByCronjobWithPage(search dto.RecordSearchByCronjob) (int64, []dto.BackupRecords, error) {
+	total, records, err := backupRepo.PageRecord(
+		search.Page, search.PageSize,
+		commonRepo.WithOrderBy("created_at desc"),
+		backupRepo.WithByCronID(search.CronjobID),
+	)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	datas, err := u.loadRecordSize(records)
+	sort.Slice(datas, func(i, j int) bool {
+		return datas[i].CreatedAt.After(datas[j].CreatedAt)
+	})
 	return total, datas, err
 }
 
 type loadSizeHelper struct {
+	isOk       bool
 	backupPath string
 	client     cloud_storage.CloudStorageClient
 }
 
-func (u *BackupService) LoadOneDriveInfo() (string, error) {
-	OneDriveID, err := settingRepo.Get(settingRepo.WithByKey("OneDriveID"))
+func (u *BackupService) LoadOneDriveInfo() (dto.OneDriveInfo, error) {
+	var data dto.OneDriveInfo
+	data.RedirectUri = constant.OneDriveRedirectURI
+	clientID, err := settingRepo.Get(settingRepo.WithByKey("OneDriveID"))
 	if err != nil {
-		return "", err
+		return data, err
 	}
-	idItem, err := base64.StdEncoding.DecodeString(OneDriveID.Value)
+	idItem, err := base64.StdEncoding.DecodeString(clientID.Value)
 	if err != nil {
-		return "", err
+		return data, err
 	}
-	return string(idItem), err
+	data.ClientID = string(idItem)
+	clientSecret, err := settingRepo.Get(settingRepo.WithByKey("OneDriveSc"))
+	if err != nil {
+		return data, err
+	}
+	secretItem, err := base64.StdEncoding.DecodeString(clientSecret.Value)
+	if err != nil {
+		return data, err
+	}
+	data.ClientSecret = string(secretItem)
+
+	return data, err
 }
 
 func (u *BackupService) DownloadRecord(info dto.DownloadRecord) (string, error) {
 	if info.Source == "LOCAL" {
-		return info.FileDir + "/" + info.FileName, nil
+		localDir, err := loadLocalDir()
+		if err != nil {
+			return "", err
+		}
+		return path.Join(localDir, info.FileDir, info.FileName), nil
 	}
 	backup, _ := backupRepo.Get(commonRepo.WithByType(info.Source))
 	if backup.ID == 0 {
@@ -205,6 +216,9 @@ func (u *BackupService) Create(req dto.BackupOperate) error {
 			return buserr.WithMap("ErrBackupCheck", map[string]interface{}{"err": err.Error()}, err)
 		}
 	}
+	if backup.Type == constant.OneDrive {
+		StartRefreshOneDriveToken()
+	}
 	if err := backupRepo.Create(&backup); err != nil {
 		return err
 	}
@@ -232,7 +246,14 @@ func (u *BackupService) GetBuckets(backupDto dto.ForBuckets) ([]interface{}, err
 }
 
 func (u *BackupService) Delete(id uint) error {
-	cronjobs, _ := cronjobRepo.List(cronjobRepo.WithByBackupID(id))
+	backup, _ := backupRepo.Get(commonRepo.WithByID(id))
+	if backup.ID == 0 {
+		return constant.ErrRecordNotFound
+	}
+	if backup.Type == constant.OneDrive {
+		global.Cron.Remove(global.OneDriveCronID)
+	}
+	cronjobs, _ := cronjobRepo.List(cronjobRepo.WithByDefaultDownload(backup.Type))
 	if len(cronjobs) != 0 {
 		return buserr.New(constant.ErrBackupInUsed)
 	}
@@ -245,22 +266,18 @@ func (u *BackupService) BatchDeleteRecord(ids []uint) error {
 		return err
 	}
 	for _, record := range records {
-		if record.Source == "LOCAL" {
-			if err := os.Remove(record.FileDir + "/" + record.FileName); err != nil {
-				global.LOG.Errorf("remove file %s failed, err: %v", record.FileDir+record.FileName, err)
-			}
-		} else {
-			backupAccount, err := backupRepo.Get(commonRepo.WithByType(record.Source))
-			if err != nil {
-				return err
-			}
-			client, err := u.NewClient(&backupAccount)
-			if err != nil {
-				return err
-			}
-			if _, err = client.Delete(record.FileDir + record.FileName); err != nil {
-				global.LOG.Errorf("remove file %s from %s failed, err: %v", record.FileDir+record.FileName, record.Source, err)
-			}
+		backupAccount, err := backupRepo.Get(commonRepo.WithByType(record.Source))
+		if err != nil {
+			global.LOG.Errorf("load backup account %s info from db failed, err: %v", record.Source, err)
+			continue
+		}
+		client, err := u.NewClient(&backupAccount)
+		if err != nil {
+			global.LOG.Errorf("new client for backup account %s failed, err: %v", record.Source, err)
+			continue
+		}
+		if _, err = client.Delete(path.Join(record.FileDir, record.FileName)); err != nil {
+			global.LOG.Errorf("remove file %s from %s failed, err: %v", path.Join(record.FileDir, record.FileName), record.Source, err)
 		}
 	}
 	return backupRepo.DeleteRecord(context.Background(), commonRepo.WithIdsIn(ids))
@@ -313,27 +330,29 @@ func (u *BackupService) Update(req dto.BackupOperate) error {
 	if backup.Type == "LOCAL" {
 		if dir, ok := varMap["dir"]; ok {
 			if dirStr, isStr := dir.(string); isStr {
-				if strings.HasSuffix(dirStr, "/") {
+				if strings.HasSuffix(dirStr, "/") && dirStr != "/" {
 					dirStr = dirStr[:strings.LastIndex(dirStr, "/")]
 				}
 				if err := copyDir(oldDir, dirStr); err != nil {
 					_ = backupRepo.Update(req.ID, (map[string]interface{}{"vars": oldVars}))
 					return err
 				}
+				global.CONF.System.Backup = dirStr
 			}
 		}
 	}
 	return nil
 }
 
-func (u *BackupService) ListFiles(req dto.BackupSearchFile) ([]string, error) {
+func (u *BackupService) ListFiles(req dto.BackupSearchFile) []string {
+	var datas []string
 	backup, err := backupRepo.Get(backupRepo.WithByType(req.Type))
 	if err != nil {
-		return nil, err
+		return datas
 	}
 	client, err := u.NewClient(&backup)
 	if err != nil {
-		return nil, err
+		return datas
 	}
 	prefix := "system_snapshot"
 	if len(backup.BackupPath) != 0 {
@@ -341,15 +360,15 @@ func (u *BackupService) ListFiles(req dto.BackupSearchFile) ([]string, error) {
 	}
 	files, err := client.ListObjects(prefix)
 	if err != nil {
-		return nil, err
+		global.LOG.Debugf("load files from %s failed, err: %v", req.Type, err)
+		return datas
 	}
-	var datas []string
 	for _, file := range files {
 		if len(file) != 0 {
 			datas = append(datas, path.Base(file))
 		}
 	}
-	return datas, nil
+	return datas
 }
 
 func (u *BackupService) NewClient(backup *model.BackupAccount) (cloud_storage.CloudStorageClient, error) {
@@ -357,9 +376,6 @@ func (u *BackupService) NewClient(backup *model.BackupAccount) (cloud_storage.Cl
 	if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
 		return nil, err
 	}
-	if backup.Type == "LOCAL" {
-		return nil, errors.New("not support")
-	}
 	varMap["bucket"] = backup.Bucket
 	switch backup.Type {
 	case constant.Sftp, constant.WebDAV:
@@ -387,6 +403,15 @@ func (u *BackupService) loadByType(accountType string, accounts []model.BackupAc
 			if err := copier.Copy(&item, &account); err != nil {
 				global.LOG.Errorf("copy backup account to dto backup info failed, err: %v", err)
 			}
+			if account.Type == constant.OneDrive {
+				varMap := make(map[string]interface{})
+				if err := json.Unmarshal([]byte(item.Vars), &varMap); err != nil {
+					return dto.BackupInfo{Type: accountType}
+				}
+				delete(varMap, "refresh_token")
+				itemVars, _ := json.Marshal(varMap)
+				item.Vars = string(itemVars)
+			}
 			return item
 		}
 	}
@@ -398,48 +423,68 @@ func (u *BackupService) loadAccessToken(backup *model.BackupAccount) error {
 	if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
 		return fmt.Errorf("unmarshal backup vars failed, err: %v", err)
 	}
-
-	data := url.Values{}
-	data.Set("client_id", global.CONF.System.OneDriveID)
-	data.Set("client_secret", global.CONF.System.OneDriveSc)
-	data.Set("grant_type", "authorization_code")
-	data.Set("code", varMap["code"].(string))
-	data.Set("redirect_uri", constant.OneDriveRedirectURI)
-	client := &http.Client{}
-	req, err := http.NewRequest("POST", "https://login.microsoftonline.com/common/oauth2/v2.0/token", strings.NewReader(data.Encode()))
+	token, refreshToken, err := client.RefreshToken("authorization_code", varMap)
 	if err != nil {
-		return fmt.Errorf("new http post client for access token failed, err: %v", err)
-	}
-	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	resp, err := client.Do(req)
-	if err != nil {
-		return fmt.Errorf("request for access token failed, err: %v", err)
+		return err
 	}
 	delete(varMap, "code")
-	respBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("read data from response body failed, err: %v", err)
-	}
-	defer resp.Body.Close()
-
-	token := map[string]interface{}{}
-	if err := json.Unmarshal(respBody, &token); err != nil {
-		return fmt.Errorf("unmarshal data from response body failed, err: %v", err)
-	}
-	accessToken, ok := token["refresh_token"].(string)
-	if !ok {
-		return errors.New("no such access token in response")
-	}
-
+	backup.Credential = token
+	varMap["refresh_status"] = constant.StatusSuccess
+	varMap["refresh_time"] = time.Now().Format("2006-01-02 15:04:05")
+	varMap["refresh_token"] = refreshToken
 	itemVars, err := json.Marshal(varMap)
 	if err != nil {
 		return fmt.Errorf("json marshal var map failed, err: %v", err)
 	}
-	backup.Credential = accessToken
 	backup.Vars = string(itemVars)
 	return nil
 }
 
+func (u *BackupService) loadRecordSize(records []model.BackupRecord) ([]dto.BackupRecords, error) {
+	var datas []dto.BackupRecords
+	clientMap := make(map[string]loadSizeHelper)
+	var wg sync.WaitGroup
+	for i := 0; i < len(records); i++ {
+		var item dto.BackupRecords
+		if err := copier.Copy(&item, &records[i]); err != nil {
+			return nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
+		}
+		itemPath := path.Join(records[i].FileDir, records[i].FileName)
+		if _, ok := clientMap[records[i].Source]; !ok {
+			backup, err := backupRepo.Get(commonRepo.WithByType(records[i].Source))
+			if err != nil {
+				global.LOG.Errorf("load backup model %s from db failed, err: %v", records[i].Source, err)
+				clientMap[records[i].Source] = loadSizeHelper{}
+				datas = append(datas, item)
+				continue
+			}
+			client, err := u.NewClient(&backup)
+			if err != nil {
+				global.LOG.Errorf("load backup client %s from db failed, err: %v", records[i].Source, err)
+				clientMap[records[i].Source] = loadSizeHelper{}
+				datas = append(datas, item)
+				continue
+			}
+			item.Size, _ = client.Size(path.Join(strings.TrimLeft(backup.BackupPath, "/"), itemPath))
+			datas = append(datas, item)
+			clientMap[records[i].Source] = loadSizeHelper{backupPath: strings.TrimLeft(backup.BackupPath, "/"), client: client, isOk: true}
+			continue
+		}
+		if clientMap[records[i].Source].isOk {
+			wg.Add(1)
+			go func(index int) {
+				item.Size, _ = clientMap[records[index].Source].client.Size(path.Join(clientMap[records[index].Source].backupPath, itemPath))
+				datas = append(datas, item)
+				wg.Done()
+			}(i)
+		} else {
+			datas = append(datas, item)
+		}
+	}
+	wg.Wait()
+	return datas, nil
+}
+
 func loadLocalDir() (string, error) {
 	backup, err := backupRepo.Get(commonRepo.WithByType("LOCAL"))
 	if err != nil {
@@ -521,3 +566,50 @@ func (u *BackupService) checkBackupConn(backup *model.BackupAccount) (bool, erro
 	targetPath := strings.TrimPrefix(path.Join(backup.BackupPath, "test/1panel"), "/")
 	return client.Upload(fileItem, targetPath)
 }
+
+func StartRefreshOneDriveToken() {
+	service := NewIBackupService()
+	oneDriveCronID, err := global.Cron.AddJob("0 * * * *", service)
+	if err != nil {
+		global.LOG.Errorf("can not add OneDrive corn job: %s", err.Error())
+		return
+	}
+	global.OneDriveCronID = oneDriveCronID
+}
+
+func (u *BackupService) Run() {
+	var backupItem model.BackupAccount
+	_ = global.DB.Where("`type` = ?", "OneDrive").First(&backupItem)
+	if backupItem.ID == 0 {
+		return
+	}
+	if len(backupItem.Credential) == 0 {
+		global.LOG.Error("OneDrive configuration lacks token information, please rebind.")
+		return
+	}
+	global.LOG.Info("start to refresh token of OneDrive ...")
+	varMap := make(map[string]interface{})
+	if err := json.Unmarshal([]byte(backupItem.Vars), &varMap); err != nil {
+		global.LOG.Errorf("Failed to refresh OneDrive token, please retry, err: %v", err)
+		return
+	}
+	token, refreshToken, err := client.RefreshToken("refresh_token", varMap)
+	varMap["refresh_status"] = constant.StatusSuccess
+	varMap["refresh_time"] = time.Now().Format("2006-01-02 15:04:05")
+	if err != nil {
+		varMap["refresh_status"] = constant.StatusFailed
+		varMap["refresh_msg"] = err.Error()
+		global.LOG.Errorf("Failed to refresh OneDrive token, please retry, err: %v", err)
+		return
+	}
+	varMap["refresh_token"] = refreshToken
+
+	varsItem, _ := json.Marshal(varMap)
+	_ = global.DB.Model(&model.BackupAccount{}).
+		Where("id = ?", backupItem.ID).
+		Updates(map[string]interface{}{
+			"credential": token,
+			"vars":       varsItem,
+		}).Error
+	global.LOG.Info("Successfully refreshed OneDrive token.")
+}

backend/app/service/backup_app.go

@@ -16,6 +16,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/pkg/errors"
@@ -35,10 +36,10 @@ func (u *BackupService) AppBackup(req dto.CommonBackup) error {
 		return err
 	}
 	timeNow := time.Now().Format("20060102150405")
+	itemDir := fmt.Sprintf("app/%s/%s", req.Name, req.DetailName)
+	backupDir := path.Join(localDir, itemDir)
 
-	backupDir := path.Join(localDir, fmt.Sprintf("app/%s/%s", req.Name, req.DetailName))
-
-	fileName := fmt.Sprintf("%s_%s.tar.gz", req.DetailName, timeNow)
+	fileName := fmt.Sprintf("%s_%s.tar.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
 	if err := handleAppBackup(&install, backupDir, fileName); err != nil {
 		return err
 	}
@@ -49,7 +50,7 @@ func (u *BackupService) AppBackup(req dto.CommonBackup) error {
 		DetailName: req.DetailName,
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
-		FileDir:    backupDir,
+		FileDir:    itemDir,
 		FileName:   fileName,
 	}
 
@@ -114,7 +115,7 @@ func handleAppBackup(install *model.AppInstall, backupDir, fileName string) erro
 			if err != nil {
 				return err
 			}
-			if err := handleMysqlBackup(db.MysqlName, db.Name, tmpDir, fmt.Sprintf("%s.sql.gz", install.Name)); err != nil {
+			if err := handleMysqlBackup(db.MysqlName, resource.Key, db.Name, tmpDir, fmt.Sprintf("%s.sql.gz", install.Name)); err != nil {
 				return err
 			}
 		case constant.AppPostgresql:
@@ -303,6 +304,10 @@ func reCreateDB(dbID uint, database model.Database, oldEnv string) (*model.Datab
 		Password:   oldPassword,
 		Permission: "%",
 	})
+	cronjobs, _ := cronjobRepo.List(cronjobRepo.WithByDbName(fmt.Sprintf("%v", dbID)))
+	for _, job := range cronjobs {
+		_ = cronjobRepo.Update(job.ID, map[string]interface{}{"db_name": fmt.Sprintf("%v", createDB.ID)})
+	}
 	if err != nil {
 		return nil, envMap, err
 	}

backend/app/service/backup_mysql.go

@@ -2,16 +2,18 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/buserr"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/1Panel-dev/1Panel/backend/utils/mysql/client"
 )
@@ -23,10 +25,11 @@ func (u *BackupService) MysqlBackup(req dto.CommonBackup) error {
 	}
 
 	timeNow := time.Now().Format("20060102150405")
-	targetDir := path.Join(localDir, fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName))
-	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow)
+	itemDir := fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName)
+	targetDir := path.Join(localDir, itemDir)
+	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
 
-	if err := handleMysqlBackup(req.Name, req.DetailName, targetDir, fileName); err != nil {
+	if err := handleMysqlBackup(req.Name, req.Type, req.DetailName, targetDir, fileName); err != nil {
 		return err
 	}
 
@@ -36,7 +39,7 @@ func (u *BackupService) MysqlBackup(req dto.CommonBackup) error {
 		DetailName: req.DetailName,
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
-		FileDir:    targetDir,
+		FileDir:    itemDir,
 		FileName:   fileName,
 	}
 	if err := backupRepo.CreateRecord(record); err != nil {
@@ -97,18 +100,20 @@ func (u *BackupService) MysqlRecoverByUpload(req dto.CommonRecover) error {
 	return nil
 }
 
-func handleMysqlBackup(database, dbName, targetDir, fileName string) error {
+func handleMysqlBackup(database, dbType, dbName, targetDir, fileName string) error {
 	dbInfo, err := mysqlRepo.Get(commonRepo.WithByName(dbName), mysqlRepo.WithByMysqlName(database))
 	if err != nil {
 		return err
 	}
-	cli, _, err := LoadMysqlClientByFrom(database)
+	cli, version, err := LoadMysqlClientByFrom(database)
 	if err != nil {
 		return err
 	}
 
 	backupInfo := client.BackupInfo{
 		Name:      dbName,
+		Type:      dbType,
+		Version:   version,
 		Format:    dbInfo.Format,
 		TargetDir: targetDir,
 		FileName:  fileName,
@@ -131,7 +136,7 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 	if err != nil {
 		return err
 	}
-	cli, _, err := LoadMysqlClientByFrom(req.Name)
+	cli, version, err := LoadMysqlClientByFrom(req.Name)
 	if err != nil {
 		return err
 	}
@@ -140,6 +145,8 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 		rollbackFile := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s_%s.sql.gz", req.Type, req.DetailName, time.Now().Format("20060102150405")))
 		if err := cli.Backup(client.BackupInfo{
 			Name:      req.DetailName,
+			Type:      req.Type,
+			Version:   version,
 			Format:    dbInfo.Format,
 			TargetDir: path.Dir(rollbackFile),
 			FileName:  path.Base(rollbackFile),
@@ -153,6 +160,8 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 				global.LOG.Info("recover failed, start to rollback now")
 				if err := cli.Recover(client.RecoverInfo{
 					Name:       req.DetailName,
+					Type:       req.Type,
+					Version:    version,
 					Format:     dbInfo.Format,
 					SourceFile: rollbackFile,
 
@@ -169,6 +178,8 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 	}
 	if err := cli.Recover(client.RecoverInfo{
 		Name:       req.DetailName,
+		Type:       req.Type,
+		Version:    version,
 		Format:     dbInfo.Format,
 		SourceFile: req.File,
 

backend/app/service/backup_postgresql.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/buserr"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	pgclient "github.com/1Panel-dev/1Panel/backend/utils/postgresql/client"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -25,8 +26,9 @@ func (u *BackupService) PostgresqlBackup(req dto.CommonBackup) error {
 	}
 
 	timeNow := time.Now().Format("20060102150405")
-	targetDir := path.Join(localDir, fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName))
-	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow)
+	itemDir := fmt.Sprintf("database/%s/%s/%s", req.Type, req.Name, req.DetailName)
+	targetDir := path.Join(localDir, itemDir)
+	fileName := fmt.Sprintf("%s_%s.sql.gz", req.DetailName, timeNow+common.RandStrAndNum(5))
 
 	if err := handlePostgresqlBackup(req.Name, req.DetailName, targetDir, fileName); err != nil {
 		return err
@@ -38,7 +40,7 @@ func (u *BackupService) PostgresqlBackup(req dto.CommonBackup) error {
 		DetailName: req.DetailName,
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
-		FileDir:    targetDir,
+		FileDir:    itemDir,
 		FileName:   fileName,
 	}
 	if err := backupRepo.CreateRecord(record); err != nil {

backend/app/service/backup_redis.go

@@ -14,6 +14,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/pkg/errors"
@@ -34,7 +35,7 @@ func (u *BackupService) RedisBackup() error {
 	}
 	global.LOG.Infof("appendonly in redis conf is %s", appendonly)
 
-	timeNow := time.Now().Format("20060102150405")
+	timeNow := time.Now().Format("20060102150405") + common.RandStrAndNum(5)
 	fileName := fmt.Sprintf("%s.rdb", timeNow)
 	if appendonly == "yes" {
 		if strings.HasPrefix(redisInfo.Version, "6.") {
@@ -43,7 +44,8 @@ func (u *BackupService) RedisBackup() error {
 			fileName = fmt.Sprintf("%s.tar.gz", timeNow)
 		}
 	}
-	backupDir := path.Join(localDir, fmt.Sprintf("database/redis/%s", redisInfo.Name))
+	itemDir := fmt.Sprintf("database/redis/%s", redisInfo.Name)
+	backupDir := path.Join(localDir, itemDir)
 	if err := handleRedisBackup(redisInfo, backupDir, fileName); err != nil {
 		return err
 	}
@@ -51,7 +53,7 @@ func (u *BackupService) RedisBackup() error {
 		Type:       "redis",
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
-		FileDir:    backupDir,
+		FileDir:    itemDir,
 		FileName:   fileName,
 	}
 	if err := backupRepo.CreateRecord(record); err != nil {

backend/app/service/backup_website.go

@@ -15,6 +15,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/pkg/errors"
@@ -31,8 +32,9 @@ func (u *BackupService) WebsiteBackup(req dto.CommonBackup) error {
 	}
 
 	timeNow := time.Now().Format("20060102150405")
-	backupDir := path.Join(localDir, fmt.Sprintf("website/%s", req.Name))
-	fileName := fmt.Sprintf("%s_%s.tar.gz", website.PrimaryDomain, timeNow)
+	itemDir := fmt.Sprintf("website/%s", req.Name)
+	backupDir := path.Join(localDir, itemDir)
+	fileName := fmt.Sprintf("%s_%s.tar.gz", website.PrimaryDomain, timeNow+common.RandStrAndNum(5))
 	if err := handleWebsiteBackup(&website, backupDir, fileName); err != nil {
 		return err
 	}
@@ -43,7 +45,7 @@ func (u *BackupService) WebsiteBackup(req dto.CommonBackup) error {
 		DetailName: req.DetailName,
 		Source:     "LOCAL",
 		BackupType: "LOCAL",
-		FileDir:    backupDir,
+		FileDir:    itemDir,
 		FileName:   fileName,
 	}
 	if err := backupRepo.CreateRecord(record); err != nil {

backend/app/service/command.go

@@ -23,7 +23,7 @@ func NewICommandService() ICommandService {
 }
 
 func (u *CommandService) List() ([]dto.CommandInfo, error) {
-	commands, err := commandRepo.GetList()
+	commands, err := commandRepo.GetList(commonRepo.WithOrderBy("name"))
 	if err != nil {
 		return nil, constant.ErrRecordNotFound
 	}
@@ -39,7 +39,7 @@ func (u *CommandService) List() ([]dto.CommandInfo, error) {
 }
 
 func (u *CommandService) SearchForTree() ([]dto.CommandTree, error) {
-	cmdList, err := commandRepo.GetList()
+	cmdList, err := commandRepo.GetList(commonRepo.WithOrderBy("name"))
 	if err != nil {
 		return nil, err
 	}
@@ -65,11 +65,11 @@ func (u *CommandService) SearchForTree() ([]dto.CommandTree, error) {
 }
 
 func (u *CommandService) SearchWithPage(search dto.SearchCommandWithPage) (int64, interface{}, error) {
-	total, commands, err := commandRepo.Page(search.Page, search.PageSize, commonRepo.WithLikeName(search.Info), commonRepo.WithByGroupID(search.GroupID))
+	total, commands, err := commandRepo.Page(search.Page, search.PageSize, commonRepo.WithLikeName(search.Info), commonRepo.WithByGroupID(search.GroupID), commonRepo.WithOrderRuleBy(search.OrderBy, search.Order))
 	if err != nil {
 		return 0, nil, err
 	}
-	groups, _ := groupRepo.GetList(commonRepo.WithByType("command"))
+	groups, _ := groupRepo.GetList(commonRepo.WithByType("command"), commonRepo.WithOrderBy("name"))
 	var dtoCommands []dto.CommandInfo
 	for _, command := range commands {
 		var item dto.CommandInfo

backend/app/service/container.go

@@ -15,6 +15,9 @@ import (
 	"sync"
 	"syscall"
 	"time"
+	"unicode/utf8"
+
+	"github.com/pkg/errors"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
@@ -334,7 +337,7 @@ func (u *ContainerService) LoadResourceLimit() (*dto.ResourceLimit, error) {
 
 	data := dto.ResourceLimit{
 		CPU:    cpuCounts,
-		Memory: int(memoryInfo.Total),
+		Memory: memoryInfo.Total,
 	}
 	return &data, nil
 }
@@ -432,7 +435,7 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 	data.AutoRemove = oldContainer.HostConfig.AutoRemove
 	data.Privileged = oldContainer.HostConfig.Privileged
 	data.PublishAllPorts = oldContainer.HostConfig.PublishAllPorts
-	data.RestartPolicy = oldContainer.HostConfig.RestartPolicy.Name
+	data.RestartPolicy = string(oldContainer.HostConfig.RestartPolicy.Name)
 	if oldContainer.HostConfig.NanoCPUs != 0 {
 		data.NanoCPUs = float64(oldContainer.HostConfig.NanoCPUs) / 1000000000
 	}
@@ -637,6 +640,9 @@ func (u *ContainerService) ContainerLogs(wsConn *websocket.Conn, containerType,
 	cmd := exec.Command("bash", "-c", command)
 	if !follow {
 		stdout, _ := cmd.CombinedOutput()
+		if !utf8.Valid(stdout) {
+			return errors.New("invalid utf8")
+		}
 		if err := wsConn.WriteMessage(websocket.TextMessage, stdout); err != nil {
 			global.LOG.Errorf("send message with log to ws failed, err: %v", err)
 		}
@@ -678,6 +684,9 @@ func (u *ContainerService) ContainerLogs(wsConn *websocket.Conn, containerType,
 				global.LOG.Errorf("read bytes from log failed, err: %v", err)
 				continue
 			}
+			if !utf8.Valid(buffer[:n]) {
+				continue
+			}
 			if err = wsConn.WriteMessage(websocket.TextMessage, buffer[:n]); err != nil {
 				global.LOG.Errorf("send message with log to ws failed, err: %v", err)
 				return err
@@ -714,7 +723,6 @@ func (u *ContainerService) ContainerStats(id string) (*dto.ContainerStats, error
 	if cache, ok := stats.MemoryStats.Stats["cache"]; ok {
 		data.Cache = float64(cache) / 1024 / 1024
 	}
-	data.Memory = data.Memory - data.Cache
 	data.NetworkRX, data.NetworkTX = calculateNetwork(stats.Networks)
 	data.ShotTime = stats.Read
 	return &data, nil
@@ -782,7 +790,7 @@ func calculateCPUPercentUnix(stats *types.StatsJSON) float64 {
 }
 func calculateMemPercentUnix(memStats types.MemoryStats) float64 {
 	memPercent := 0.0
-	memUsage := float64(memStats.Usage - memStats.Stats["cache"])
+	memUsage := float64(memStats.Usage)
 	memLimit := float64(memStats.Limit)
 	if memUsage > 0.0 && memLimit > 0.0 {
 		memPercent = (memUsage / memLimit) * 100.0
@@ -886,6 +894,7 @@ func loadCpuAndMem(client *client.Client, container string) dto.ContainerListSta
 	data.MemoryCache = stats.MemoryStats.Stats["cache"]
 	data.MemoryUsage = stats.MemoryStats.Usage
 	data.MemoryLimit = stats.MemoryStats.Limit
+
 	data.MemoryPercent = calculateMemPercentUnix(stats.MemoryStats)
 	return data
 }
@@ -976,7 +985,7 @@ func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *types
 	hostConf.AutoRemove = req.AutoRemove
 	hostConf.CPUShares = req.CPUShares
 	hostConf.PublishAllPorts = req.PublishAllPorts
-	hostConf.RestartPolicy = container.RestartPolicy{Name: req.RestartPolicy}
+	hostConf.RestartPolicy = container.RestartPolicy{Name: container.RestartPolicyMode(req.RestartPolicy)}
 	if req.RestartPolicy == "on-failure" {
 		hostConf.RestartPolicy.MaximumRetryCount = 5
 	}

backend/app/service/cornjob.go

@@ -5,11 +5,12 @@ import (
 	"fmt"
 	"os"
 	"path"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/jinzhu/copier"
@@ -28,10 +29,10 @@ type ICronjobService interface {
 	UpdateStatus(id uint, status string) error
 	Delete(req dto.CronjobBatchDelete) error
 	Download(down dto.CronjobDownload) (string, error)
-	StartJob(cronjob *model.Cronjob) (int, error)
+	StartJob(cronjob *model.Cronjob) (string, error)
 	CleanRecord(req dto.CronjobClean) error
 
-	LoadRecordLog(req dto.OperateByID) (string, error)
+	LoadRecordLog(req dto.OperateByID) string
 }
 
 func NewICronjobService() ICronjobService {
@@ -46,14 +47,6 @@ func (u *CronjobService) SearchWithPage(search dto.SearchWithPage) (int64, inter
 		if err := copier.Copy(&item, &cronjob); err != nil {
 			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
 		}
-		if hasBackup(item.Type) {
-			backup, _ := backupRepo.Get(commonRepo.WithByID(uint(item.TargetDirID)))
-			if len(backup.Type) != 0 {
-				item.TargetDir = backup.Type
-			}
-		} else {
-			item.TargetDir = "-"
-		}
 		record, _ := cronjobRepo.RecordFirst(cronjob.ID)
 		if record.ID != 0 {
 			item.LastRecordTime = record.StartTime.Format("2006-01-02 15:04:05")
@@ -83,19 +76,19 @@ func (u *CronjobService) SearchRecords(search dto.SearchRecord) (int64, interfac
 	return total, dtoCronjobs, err
 }
 
-func (u *CronjobService) LoadRecordLog(req dto.OperateByID) (string, error) {
+func (u *CronjobService) LoadRecordLog(req dto.OperateByID) string {
 	record, err := cronjobRepo.GetRecord(commonRepo.WithByID(req.ID))
 	if err != nil {
-		return "", err
+		return ""
 	}
 	if _, err := os.Stat(record.Records); err != nil {
-		return "", buserr.New("ErrHttpReqNotFound")
+		return ""
 	}
 	content, err := os.ReadFile(record.Records)
 	if err != nil {
-		return "", err
+		return ""
 	}
-	return string(content), nil
+	return string(content)
 }
 
 func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
@@ -103,24 +96,23 @@ func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
 	if err != nil {
 		return err
 	}
-	if req.CleanData && hasBackup(cronjob.Type) {
-		cronjob.RetainCopies = 0
-		backup, err := backupRepo.Get(commonRepo.WithByID(uint(cronjob.TargetDirID)))
-		if err != nil {
-			return err
-		}
-		if backup.Type != "LOCAL" {
-			localDir, err := loadLocalDir()
+	if req.CleanData {
+		if hasBackup(cronjob.Type) {
+			accountMap, err := loadClientMap(cronjob.BackupAccounts)
 			if err != nil {
 				return err
 			}
-			client, err := NewIBackupService().NewClient(&backup)
-			if err != nil {
-				return err
-			}
-			u.HandleRmExpired(backup.Type, backup.BackupPath, localDir, &cronjob, client)
+			cronjob.RetainCopies = 0
+			u.removeExpiredBackup(cronjob, accountMap, model.BackupRecord{})
 		} else {
-			u.HandleRmExpired(backup.Type, backup.BackupPath, "", &cronjob, nil)
+			u.removeExpiredLog(cronjob)
+		}
+	}
+	if req.IsDelete {
+		records, _ := backupRepo.ListRecord(backupRepo.WithByCronID(cronjob.ID))
+		for _, records := range records {
+			records.CronjobID = 0
+			_ = backupRepo.UpdateRecord(&records)
 		}
 	}
 	delRecords, err := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(req.CronjobID)))
@@ -184,29 +176,40 @@ func (u *CronjobService) Create(cronjobDto dto.CronjobCreate) error {
 		return errors.WithMessage(constant.ErrStructTransform, err.Error())
 	}
 	cronjob.Status = constant.StatusEnable
-	cronjob.Spec = loadSpec(cronjob)
 
 	global.LOG.Infof("create cronjob %s successful, spec: %s", cronjob.Name, cronjob.Spec)
-	entryID, err := u.StartJob(&cronjob)
+	spec := cronjob.Spec
+	entryIDs, err := u.StartJob(&cronjob)
 	if err != nil {
 		return err
 	}
-	cronjob.EntryID = uint64(entryID)
+	cronjob.Spec = spec
+	cronjob.EntryIDs = entryIDs
 	if err := cronjobRepo.Create(&cronjob); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (u *CronjobService) StartJob(cronjob *model.Cronjob) (int, error) {
-	if cronjob.EntryID != 0 {
-		global.Cron.Remove(cron.EntryID(cronjob.EntryID))
+func (u *CronjobService) StartJob(cronjob *model.Cronjob) (string, error) {
+	if len(cronjob.EntryIDs) != 0 {
+		ids := strings.Split(cronjob.EntryIDs, ",")
+		for _, id := range ids {
+			idItem, _ := strconv.Atoi(id)
+			global.Cron.Remove(cron.EntryID(idItem))
+		}
 	}
-	entryID, err := u.AddCronJob(cronjob)
-	if err != nil {
-		return 0, err
+	specs := strings.Split(cronjob.Spec, ",")
+	var ids []string
+	for _, spec := range specs {
+		cronjob.Spec = spec
+		entryID, err := u.AddCronJob(cronjob)
+		if err != nil {
+			return "", err
+		}
+		ids = append(ids, fmt.Sprintf("%v", entryID))
 	}
-	return entryID, nil
+	return strings.Join(ids, ","), nil
 }
 
 func (u *CronjobService) Delete(req dto.CronjobBatchDelete) error {
@@ -215,9 +218,13 @@ func (u *CronjobService) Delete(req dto.CronjobBatchDelete) error {
 		if cronjob.ID == 0 {
 			return errors.New("find cronjob in db failed")
 		}
-		global.Cron.Remove(cron.EntryID(cronjob.EntryID))
-		global.LOG.Infof("stop cronjob entryID: %d", cronjob.EntryID)
-		if err := u.CleanRecord(dto.CronjobClean{CronjobID: id, CleanData: req.CleanData}); err != nil {
+		ids := strings.Split(cronjob.EntryIDs, ",")
+		for _, id := range ids {
+			idItem, _ := strconv.Atoi(id)
+			global.Cron.Remove(cron.EntryID(idItem))
+		}
+		global.LOG.Infof("stop cronjob entryID: %s", cronjob.EntryIDs)
+		if err := u.CleanRecord(dto.CronjobClean{CronjobID: id, CleanData: req.CleanData, IsDelete: true}); err != nil {
 			return err
 		}
 		if err := cronjobRepo.Delete(commonRepo.WithByID(id)); err != nil {
@@ -238,29 +245,27 @@ func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
 		return constant.ErrRecordNotFound
 	}
 	upMap := make(map[string]interface{})
-	cronjob.EntryID = cronModel.EntryID
+	cronjob.EntryIDs = cronModel.EntryIDs
 	cronjob.Type = cronModel.Type
-	cronjob.Spec = loadSpec(cronjob)
+	spec := cronjob.Spec
 	if cronModel.Status == constant.StatusEnable {
-		newEntryID, err := u.StartJob(&cronjob)
+		newEntryIDs, err := u.StartJob(&cronjob)
 		if err != nil {
 			return err
 		}
-		upMap["entry_id"] = newEntryID
+		upMap["entry_ids"] = newEntryIDs
 	} else {
-		global.Cron.Remove(cron.EntryID(cronjob.EntryID))
+		ids := strings.Split(cronjob.EntryIDs, ",")
+		for _, id := range ids {
+			idItem, _ := strconv.Atoi(id)
+			global.Cron.Remove(cron.EntryID(idItem))
+		}
 	}
 
 	upMap["name"] = req.Name
-	upMap["spec"] = cronjob.Spec
+	upMap["spec"] = spec
 	upMap["script"] = req.Script
 	upMap["container_name"] = req.ContainerName
-	upMap["spec_type"] = req.SpecType
-	upMap["week"] = req.Week
-	upMap["day"] = req.Day
-	upMap["hour"] = req.Hour
-	upMap["minute"] = req.Minute
-	upMap["second"] = req.Second
 	upMap["app_id"] = req.AppID
 	upMap["website"] = req.Website
 	upMap["exclusion_rules"] = req.ExclusionRules
@@ -268,8 +273,9 @@ func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
 	upMap["db_name"] = req.DBName
 	upMap["url"] = req.URL
 	upMap["source_dir"] = req.SourceDir
-	upMap["keep_local"] = req.KeepLocal
-	upMap["target_dir_id"] = req.TargetDirID
+
+	upMap["backup_accounts"] = req.BackupAccounts
+	upMap["default_download"] = req.DefaultDownload
 	upMap["retain_copies"] = req.RetainCopies
 	return cronjobRepo.Update(id, upMap)
 }
@@ -280,19 +286,23 @@ func (u *CronjobService) UpdateStatus(id uint, status string) error {
 		return errors.WithMessage(constant.ErrRecordNotFound, "record not found")
 	}
 	var (
-		entryID int
-		err     error
+		entryIDs string
+		err      error
 	)
 	if status == constant.StatusEnable {
-		entryID, err = u.StartJob(&cronjob)
+		entryIDs, err = u.StartJob(&cronjob)
 		if err != nil {
 			return err
 		}
 	} else {
-		global.Cron.Remove(cron.EntryID(cronjob.EntryID))
-		global.LOG.Infof("stop cronjob entryID: %d", cronjob.EntryID)
+		ids := strings.Split(cronjob.EntryIDs, ",")
+		for _, id := range ids {
+			idItem, _ := strconv.Atoi(id)
+			global.Cron.Remove(cron.EntryID(idItem))
+		}
+		global.LOG.Infof("stop cronjob entryID: %s", cronjob.EntryIDs)
 	}
-	return cronjobRepo.Update(cronjob.ID, map[string]interface{}{"status": status, "entry_id": entryID})
+	return cronjobRepo.Update(cronjob.ID, map[string]interface{}{"status": status, "entry_ids": entryIDs})
 }
 
 func (u *CronjobService) AddCronJob(cronjob *model.Cronjob) (int, error) {
@@ -328,26 +338,3 @@ func mkdirAndWriteFile(cronjob *model.Cronjob, startTime time.Time, msg []byte)
 	write.Flush()
 	return path, nil
 }
-
-func loadSpec(cronjob model.Cronjob) string {
-	switch cronjob.SpecType {
-	case "perMonth":
-		return fmt.Sprintf("%v %v %v * *", cronjob.Minute, cronjob.Hour, cronjob.Day)
-	case "perWeek":
-		return fmt.Sprintf("%v %v * * %v", cronjob.Minute, cronjob.Hour, cronjob.Week)
-	case "perNDay":
-		return fmt.Sprintf("%v %v */%v * *", cronjob.Minute, cronjob.Hour, cronjob.Day)
-	case "perDay":
-		return fmt.Sprintf("%v %v * * *", cronjob.Minute, cronjob.Hour)
-	case "perNHour":
-		return fmt.Sprintf("%v */%v * * *", cronjob.Minute, cronjob.Hour)
-	case "perHour":
-		return fmt.Sprintf("%v * * * *", cronjob.Minute)
-	case "perNMinute":
-		return fmt.Sprintf("@every %vm", cronjob.Minute)
-	case "perNSecond":
-		return fmt.Sprintf("@every %vs", cronjob.Second)
-	default:
-		return ""
-	}
-}

backend/app/service/cronjob_backup.go

@@ -0,0 +1,386 @@
+package service
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
+)
+
+func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time) error {
+	var apps []model.AppInstall
+	if cronjob.AppID == "all" {
+		apps, _ = appInstallRepo.ListBy()
+	} else {
+		itemID, _ := (strconv.Atoi(cronjob.AppID))
+		app, err := appInstallRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
+		if err != nil {
+			return err
+		}
+		apps = append(apps, app)
+	}
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+	for _, app := range apps {
+		var record model.BackupRecord
+		record.From = "cronjob"
+		record.Type = "app"
+		record.CronjobID = cronjob.ID
+		record.Name = app.App.Key
+		record.DetailName = app.Name
+		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("app/%s/%s", app.App.Key, app.Name))
+		record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+		if err := handleAppBackup(&app, backupDir, record.FileName); err != nil {
+			return err
+		}
+		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+		if err != nil {
+			return err
+		}
+		record.FileDir = path.Dir(downloadPath)
+		if err := backupRepo.CreateRecord(&record); err != nil {
+			global.LOG.Errorf("save backup record failed, err: %v", err)
+			return err
+		}
+		u.removeExpiredBackup(cronjob, accountMap, record)
+	}
+	return nil
+}
+
+func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Time) error {
+	webs := loadWebsForJob(cronjob)
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+	for _, web := range webs {
+		var record model.BackupRecord
+		record.From = "cronjob"
+		record.Type = "website"
+		record.CronjobID = cronjob.ID
+		record.Name = web.PrimaryDomain
+		record.DetailName = web.Alias
+		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("website/%s", web.PrimaryDomain))
+		record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", web.PrimaryDomain, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+		if err := handleWebsiteBackup(&web, backupDir, record.FileName); err != nil {
+			return err
+		}
+		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+		if err != nil {
+			return err
+		}
+		record.FileDir = path.Dir(downloadPath)
+		if err := backupRepo.CreateRecord(&record); err != nil {
+			global.LOG.Errorf("save backup record failed, err: %v", err)
+			return err
+		}
+		u.removeExpiredBackup(cronjob, accountMap, record)
+	}
+	return nil
+}
+
+func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Time) error {
+	dbs := loadDbsForJob(cronjob)
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+	for _, dbInfo := range dbs {
+		var record model.BackupRecord
+		record.From = "cronjob"
+		record.Type = dbInfo.DBType
+		record.CronjobID = cronjob.ID
+		record.Name = dbInfo.Database
+		record.DetailName = dbInfo.Name
+		record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+
+		backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
+		record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+			if err := handleMysqlBackup(dbInfo.Database, dbInfo.DBType, dbInfo.Name, backupDir, record.FileName); err != nil {
+				return err
+			}
+		} else {
+			if err := handlePostgresqlBackup(dbInfo.Database, dbInfo.Name, backupDir, record.FileName); err != nil {
+				return err
+			}
+		}
+		downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, record.FileName))
+		if err != nil {
+			return err
+		}
+		record.FileDir = path.Dir(downloadPath)
+		if err := backupRepo.CreateRecord(&record); err != nil {
+			global.LOG.Errorf("save backup record failed, err: %v", err)
+			return err
+		}
+		u.removeExpiredBackup(cronjob, accountMap, record)
+	}
+	return nil
+}
+
+func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.Time) error {
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+	fileName := fmt.Sprintf("directory%s_%s.tar.gz", strings.ReplaceAll(cronjob.SourceDir, "/", "_"), startTime.Format("20060102150405")+common.RandStrAndNum(5))
+	backupDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("%s/%s", cronjob.Type, cronjob.Name))
+	if err := handleTar(cronjob.SourceDir, backupDir, fileName, cronjob.ExclusionRules); err != nil {
+		return err
+	}
+	var record model.BackupRecord
+	record.From = "cronjob"
+	record.Type = "directory"
+	record.CronjobID = cronjob.ID
+	record.Name = cronjob.Name
+	record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+	downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(backupDir, fileName))
+	if err != nil {
+		return err
+	}
+	record.FileDir = path.Dir(downloadPath)
+	record.FileName = fileName
+	if err := backupRepo.CreateRecord(&record); err != nil {
+		global.LOG.Errorf("save backup record failed, err: %v", err)
+		return err
+	}
+	u.removeExpiredBackup(cronjob, accountMap, record)
+	return nil
+}
+
+func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.Time) error {
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+	nameItem := startTime.Format("20060102150405") + common.RandStrAndNum(5)
+	fileName := fmt.Sprintf("system_log_%s.tar.gz", nameItem)
+	backupDir := path.Join(global.CONF.System.TmpDir, "log", nameItem)
+	if err := handleBackupLogs(backupDir, fileName); err != nil {
+		return err
+	}
+	var record model.BackupRecord
+	record.From = "cronjob"
+	record.Type = "log"
+	record.CronjobID = cronjob.ID
+	record.Name = cronjob.Name
+	record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+	downloadPath, err := u.uploadCronjobBackFile(cronjob, accountMap, path.Join(path.Dir(backupDir), fileName))
+	if err != nil {
+		return err
+	}
+	record.FileDir = path.Dir(downloadPath)
+	record.FileName = fileName
+	if err := backupRepo.CreateRecord(&record); err != nil {
+		global.LOG.Errorf("save backup record failed, err: %v", err)
+		return err
+	}
+	u.removeExpiredBackup(cronjob, accountMap, record)
+	return nil
+}
+
+func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, startTime time.Time, logPath string) error {
+	accountMap, err := loadClientMap(cronjob.BackupAccounts)
+	if err != nil {
+		return err
+	}
+
+	var record model.BackupRecord
+	record.From = "cronjob"
+	record.Type = "directory"
+	record.CronjobID = cronjob.ID
+	record.Name = cronjob.Name
+	record.Source, record.BackupType = loadRecordPath(cronjob, accountMap)
+	record.FileDir = "system_snapshot"
+
+	req := dto.SnapshotCreate{
+		From:            record.BackupType,
+		DefaultDownload: cronjob.DefaultDownload,
+	}
+	name, err := NewISnapshotService().HandleSnapshot(true, logPath, req, startTime.Format("20060102150405")+common.RandStrAndNum(5))
+	if err != nil {
+		return err
+	}
+	record.FileName = name + ".tar.gz"
+
+	if err := backupRepo.CreateRecord(&record); err != nil {
+		global.LOG.Errorf("save backup record failed, err: %v", err)
+		return err
+	}
+	u.removeExpiredBackup(cronjob, accountMap, record)
+	return nil
+}
+
+type databaseHelper struct {
+	DBType   string
+	Database string
+	Name     string
+}
+
+func loadDbsForJob(cronjob model.Cronjob) []databaseHelper {
+	var dbs []databaseHelper
+	if cronjob.DBName == "all" {
+		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+			mysqlItems, _ := mysqlRepo.List()
+			for _, mysql := range mysqlItems {
+				dbs = append(dbs, databaseHelper{
+					DBType:   cronjob.DBType,
+					Database: mysql.MysqlName,
+					Name:     mysql.Name,
+				})
+			}
+		} else {
+			pgItems, _ := postgresqlRepo.List()
+			for _, pg := range pgItems {
+				dbs = append(dbs, databaseHelper{
+					DBType:   cronjob.DBType,
+					Database: pg.PostgresqlName,
+					Name:     pg.Name,
+				})
+			}
+		}
+		return dbs
+	}
+	itemID, _ := (strconv.Atoi(cronjob.DBName))
+	if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
+		mysqlItem, _ := mysqlRepo.Get(commonRepo.WithByID(uint(itemID)))
+		dbs = append(dbs, databaseHelper{
+			DBType:   cronjob.DBType,
+			Database: mysqlItem.MysqlName,
+			Name:     mysqlItem.Name,
+		})
+	} else {
+		pgItem, _ := postgresqlRepo.Get(commonRepo.WithByID(uint(itemID)))
+		dbs = append(dbs, databaseHelper{
+			DBType:   cronjob.DBType,
+			Database: pgItem.PostgresqlName,
+			Name:     pgItem.Name,
+		})
+	}
+	return dbs
+}
+
+func loadWebsForJob(cronjob model.Cronjob) []model.Website {
+	var weblist []model.Website
+	if cronjob.Website == "all" {
+		weblist, _ = websiteRepo.List()
+		return weblist
+	}
+	itemID, _ := (strconv.Atoi(cronjob.Website))
+	webItem, _ := websiteRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
+	if webItem.ID != 0 {
+		weblist = append(weblist, webItem)
+	}
+	return weblist
+}
+
+func loadRecordPath(cronjob model.Cronjob, accountMap map[string]cronjobUploadHelper) (string, string) {
+	source := accountMap[fmt.Sprintf("%v", cronjob.DefaultDownload)].backType
+	targets := strings.Split(cronjob.BackupAccounts, ",")
+	var itemAccounts []string
+	for _, target := range targets {
+		if len(target) == 0 {
+			continue
+		}
+		if len(accountMap[target].backType) != 0 {
+			itemAccounts = append(itemAccounts, accountMap[target].backType)
+		}
+	}
+	backupType := strings.Join(itemAccounts, ",")
+	return source, backupType
+}
+
+func handleBackupLogs(targetDir, fileName string) error {
+	websites, err := websiteRepo.List()
+	if err != nil {
+		return err
+	}
+	if len(websites) != 0 {
+		nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+		if err != nil {
+			return err
+		}
+		webItem := path.Join(nginxInstall.GetPath(), "www/sites")
+		for _, website := range websites {
+			dirItem := path.Join(targetDir, "website", website.Alias)
+			if _, err := os.Stat(dirItem); err != nil && os.IsNotExist(err) {
+				if err = os.MkdirAll(dirItem, os.ModePerm); err != nil {
+					return err
+				}
+			}
+			itemDir := path.Join(webItem, website.Alias, "log")
+			logFiles, _ := os.ReadDir(itemDir)
+			if len(logFiles) != 0 {
+				for i := 0; i < len(logFiles); i++ {
+					if !logFiles[i].IsDir() {
+						_ = cpBinary([]string{path.Join(itemDir, logFiles[i].Name())}, dirItem)
+					}
+				}
+			}
+			itemDir2 := path.Join(global.CONF.System.Backup, "log/website", website.Alias)
+			logFiles2, _ := os.ReadDir(itemDir2)
+			if len(logFiles2) != 0 {
+				for i := 0; i < len(logFiles2); i++ {
+					if !logFiles2[i].IsDir() {
+						_ = cpBinary([]string{path.Join(itemDir2, logFiles2[i].Name())}, dirItem)
+					}
+				}
+			}
+		}
+		global.LOG.Debug("backup website log successful!")
+	}
+
+	systemLogDir := path.Join(global.CONF.System.BaseDir, "1panel/log")
+	systemDir := path.Join(targetDir, "system")
+	if _, err := os.Stat(systemDir); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(systemDir, os.ModePerm); err != nil {
+			return err
+		}
+	}
+	systemLogFiles, _ := os.ReadDir(systemLogDir)
+	if len(systemLogFiles) != 0 {
+		for i := 0; i < len(systemLogFiles); i++ {
+			if !systemLogFiles[i].IsDir() {
+				_ = cpBinary([]string{path.Join(systemLogDir, systemLogFiles[i].Name())}, systemDir)
+			}
+		}
+	}
+	global.LOG.Debug("backup system log successful!")
+
+	loginLogFiles, _ := os.ReadDir("/var/log")
+	loginDir := path.Join(targetDir, "login")
+	if _, err := os.Stat(loginDir); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(loginDir, os.ModePerm); err != nil {
+			return err
+		}
+	}
+	if len(loginLogFiles) != 0 {
+		for i := 0; i < len(loginLogFiles); i++ {
+			if !loginLogFiles[i].IsDir() && (strings.HasPrefix(loginLogFiles[i].Name(), "secure") || strings.HasPrefix(loginLogFiles[i].Name(), "auth.log")) {
+				_ = cpBinary([]string{path.Join("/var/log", loginLogFiles[i].Name())}, loginDir)
+			}
+		}
+	}
+	global.LOG.Debug("backup ssh log successful!")
+
+	if err := handleTar(targetDir, path.Dir(targetDir), fileName, ""); err != nil {
+		return err
+	}
+	defer func() {
+		_ = os.RemoveAll(targetDir)
+	}()
+	return nil
+}

backend/app/service/cronjob_helper.go

@@ -5,15 +5,14 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"strconv"
 	"strings"
 	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/i18n"
 
-	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/app/repo"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cloud_storage"
@@ -35,32 +34,25 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 			if len(cronjob.Script) == 0 {
 				return
 			}
+			record.Records = u.generateLogsPath(*cronjob, record.StartTime)
+			_ = cronjobRepo.UpdateRecords(record.ID, map[string]interface{}{"records": record.Records})
+			script := cronjob.Script
 			if len(cronjob.ContainerName) != 0 {
-				message, err = u.handleShell(cronjob.Type, cronjob.Name, fmt.Sprintf("docker exec %s %s", cronjob.ContainerName, cronjob.Script))
-			} else {
-				message, err = u.handleShell(cronjob.Type, cronjob.Name, cronjob.Script)
+				script = fmt.Sprintf("docker exec %s %s", cronjob.ContainerName, cronjob.Script)
 			}
-			u.HandleRmExpired("LOCAL", "", "", cronjob, nil)
-		case "snapshot":
-			messageItem := ""
-			messageItem, record.File, err = u.handleSnapshot(cronjob, record.StartTime)
-			message = []byte(messageItem)
+			err = u.handleShell(cronjob.Type, cronjob.Name, script, record.Records)
+			u.removeExpiredLog(*cronjob)
 		case "curl":
 			if len(cronjob.URL) == 0 {
 				return
 			}
-			message, err = u.handleShell(cronjob.Type, cronjob.Name, fmt.Sprintf("curl '%s'", cronjob.URL))
-			u.HandleRmExpired("LOCAL", "", "", cronjob, nil)
+			record.Records = u.generateLogsPath(*cronjob, record.StartTime)
+			_ = cronjobRepo.UpdateRecords(record.ID, map[string]interface{}{"records": record.Records})
+			err = u.handleShell(cronjob.Type, cronjob.Name, fmt.Sprintf("curl '%s'", cronjob.URL), record.Records)
+			u.removeExpiredLog(*cronjob)
 		case "ntp":
 			err = u.handleNtpSync()
-			u.HandleRmExpired("LOCAL", "", "", cronjob, nil)
-		case "website", "database", "app":
-			record.File, err = u.handleBackup(cronjob, record.StartTime)
-		case "directory":
-			if len(cronjob.SourceDir) == 0 {
-				return
-			}
-			record.File, err = u.handleBackup(cronjob, record.StartTime)
+			u.removeExpiredLog(*cronjob)
 		case "cutWebsiteLog":
 			var messageItem []string
 			messageItem, record.File, err = u.handleCutWebsiteLog(cronjob, record.StartTime)
@@ -69,13 +61,31 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 			messageItem := ""
 			messageItem, err = u.handleSystemClean()
 			message = []byte(messageItem)
-			u.HandleRmExpired("LOCAL", "", "", cronjob, nil)
+			u.removeExpiredLog(*cronjob)
+		case "website":
+			err = u.handleWebsite(*cronjob, record.StartTime)
+		case "app":
+			err = u.handleApp(*cronjob, record.StartTime)
+		case "database":
+			err = u.handleDatabase(*cronjob, record.StartTime)
+		case "directory":
+			if len(cronjob.SourceDir) == 0 {
+				return
+			}
+			err = u.handleDirectory(*cronjob, record.StartTime)
 		case "log":
-			record.File, err = u.handleSystemLog(*cronjob, record.StartTime)
+			err = u.handleSystemLog(*cronjob, record.StartTime)
+		case "snapshot":
+			record.Records = u.generateLogsPath(*cronjob, record.StartTime)
+			_ = cronjobRepo.UpdateRecords(record.ID, map[string]interface{}{"records": record.Records})
+			err = u.handleSnapshot(*cronjob, record.StartTime, record.Records)
 		}
 
 		if err != nil {
-			cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), string(message))
+			if len(message) != 0 {
+				record.Records, _ = mkdirAndWriteFile(cronjob, record.StartTime, message)
+			}
+			cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), record.Records)
 			return
 		}
 		if len(message) != 0 {
@@ -88,18 +98,17 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 	}()
 }
 
-func (u *CronjobService) handleShell(cronType, cornName, script string) ([]byte, error) {
+func (u *CronjobService) handleShell(cronType, cornName, script, logPath string) error {
 	handleDir := fmt.Sprintf("%s/task/%s/%s", constant.DataDir, cronType, cornName)
 	if _, err := os.Stat(handleDir); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(handleDir, os.ModePerm); err != nil {
-			return nil, err
+			return err
 		}
 	}
-	stdout, err := cmd.ExecCronjobWithTimeOut(script, handleDir, 24*time.Hour)
-	if err != nil {
-		return []byte(stdout), err
+	if err := cmd.ExecCronjobWithTimeOut(script, handleDir, logPath, 24*time.Hour); err != nil {
+		return err
 	}
-	return []byte(stdout), nil
+	return nil
 }
 
 func (u *CronjobService) handleNtpSync() error {
@@ -117,98 +126,6 @@ func (u *CronjobService) handleNtpSync() error {
 	return nil
 }
 
-func (u *CronjobService) handleBackup(cronjob *model.Cronjob, startTime time.Time) (string, error) {
-	backup, err := backupRepo.Get(commonRepo.WithByID(uint(cronjob.TargetDirID)))
-	if err != nil {
-		return "", err
-	}
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return "", err
-	}
-	global.LOG.Infof("start to backup %s %s to %s", cronjob.Type, cronjob.Name, backup.Type)
-
-	switch cronjob.Type {
-	case "database":
-		paths, err := u.handleDatabase(*cronjob, backup, startTime)
-		return strings.Join(paths, ","), err
-	case "app":
-		paths, err := u.handleApp(*cronjob, backup, startTime)
-		return strings.Join(paths, ","), err
-	case "website":
-		paths, err := u.handleWebsite(*cronjob, backup, startTime)
-		return strings.Join(paths, ","), err
-	default:
-		fileName := fmt.Sprintf("directory%s_%s.tar.gz", strings.ReplaceAll(cronjob.SourceDir, "/", "_"), startTime.Format("20060102150405"))
-		backupDir := path.Join(localDir, fmt.Sprintf("%s/%s", cronjob.Type, cronjob.Name))
-		itemFileDir := fmt.Sprintf("%s/%s", cronjob.Type, cronjob.Name)
-		global.LOG.Infof("handle tar %s to %s", backupDir, fileName)
-		if err := handleTar(cronjob.SourceDir, backupDir, fileName, cronjob.ExclusionRules); err != nil {
-			return "", err
-		}
-		var client cloud_storage.CloudStorageClient
-		if backup.Type != "LOCAL" {
-			if !cronjob.KeepLocal {
-				defer func() {
-					_ = os.RemoveAll(fmt.Sprintf("%s/%s", backupDir, fileName))
-				}()
-			}
-			client, err = NewIBackupService().NewClient(&backup)
-			if err != nil {
-				return "", err
-			}
-			if len(backup.BackupPath) != 0 {
-				itemFileDir = path.Join(strings.TrimPrefix(backup.BackupPath, "/"), itemFileDir)
-			}
-			if _, err = client.Upload(backupDir+"/"+fileName, itemFileDir+"/"+fileName); err != nil {
-				return "", err
-			}
-		}
-		u.HandleRmExpired(backup.Type, backup.BackupPath, localDir, cronjob, client)
-		if backup.Type == "LOCAL" || cronjob.KeepLocal {
-			return fmt.Sprintf("%s/%s", backupDir, fileName), nil
-		} else {
-			return fmt.Sprintf("%s/%s", itemFileDir, fileName), nil
-		}
-	}
-}
-
-func (u *CronjobService) HandleRmExpired(backType, backupPath, localDir string, cronjob *model.Cronjob, backClient cloud_storage.CloudStorageClient) {
-	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
-	records, _ := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(cronjob.ID)), commonRepo.WithOrderBy("created_at desc"))
-	if len(records) <= int(cronjob.RetainCopies) {
-		return
-	}
-	for i := int(cronjob.RetainCopies); i < len(records); i++ {
-		if len(records[i].File) != 0 {
-			files := strings.Split(records[i].File, ",")
-			for _, file := range files {
-				_ = os.Remove(file)
-				_ = backupRepo.DeleteRecord(context.TODO(), backupRepo.WithByFileName(path.Base(file)))
-				if backType == "LOCAL" {
-					continue
-				}
-
-				fileItem := file
-				if cronjob.KeepLocal {
-					if len(backupPath) != 0 {
-						fileItem = path.Join(strings.TrimPrefix(backupPath, "/") + strings.TrimPrefix(file, localDir+"/"))
-					} else {
-						fileItem = strings.TrimPrefix(file, localDir+"/")
-					}
-				}
-
-				if cronjob.Type == "snapshot" {
-					_ = snapshotRepo.Delete(commonRepo.WithByName(strings.TrimSuffix(path.Base(fileItem), ".tar.gz")))
-				}
-				_, _ = backClient.Delete(fileItem)
-			}
-		}
-		_ = cronjobRepo.DeleteRecord(commonRepo.WithByID(uint(records[i].ID)))
-		_ = os.Remove(records[i].Records)
-	}
-}
-
 func handleTar(sourceDir, targetDir, name, exclusionRules string) error {
 	if _, err := os.Stat(targetDir); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(targetDir, os.ModePerm); err != nil {
@@ -266,77 +183,6 @@ func handleUnTar(sourceFile, targetDir string) error {
 	return nil
 }
 
-func (u *CronjobService) handleDatabase(cronjob model.Cronjob, backup model.BackupAccount, startTime time.Time) ([]string, error) {
-	var paths []string
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return paths, err
-	}
-
-	dbs := loadDbsForJob(cronjob)
-
-	var client cloud_storage.CloudStorageClient
-	if backup.Type != "LOCAL" {
-		client, err = NewIBackupService().NewClient(&backup)
-		if err != nil {
-			return paths, err
-		}
-	}
-
-	for _, dbInfo := range dbs {
-		var record model.BackupRecord
-		record.Type = dbInfo.DBType
-		record.Source = "LOCAL"
-		record.BackupType = backup.Type
-
-		record.Name = dbInfo.Database
-		backupDir := path.Join(localDir, fmt.Sprintf("database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
-		record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format("20060102150405"))
-		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
-			if err = handleMysqlBackup(dbInfo.Database, dbInfo.Name, backupDir, record.FileName); err != nil {
-				return paths, err
-			}
-		} else {
-			if err = handlePostgresqlBackup(dbInfo.Database, dbInfo.Name, backupDir, record.FileName); err != nil {
-				return paths, err
-			}
-		}
-
-		record.DetailName = dbInfo.Name
-		record.FileDir = backupDir
-		itemFileDir := strings.TrimPrefix(backupDir, localDir+"/")
-		if !cronjob.KeepLocal && backup.Type != "LOCAL" {
-			record.Source = backup.Type
-			record.FileDir = itemFileDir
-		}
-
-		if err := backupRepo.CreateRecord(&record); err != nil {
-			global.LOG.Errorf("save backup record failed, err: %v", err)
-			return paths, err
-		}
-		if backup.Type != "LOCAL" {
-			if !cronjob.KeepLocal {
-				defer func() {
-					_ = os.RemoveAll(fmt.Sprintf("%s/%s", backupDir, record.FileName))
-				}()
-			}
-			if len(backup.BackupPath) != 0 {
-				itemFileDir = path.Join(strings.TrimPrefix(backup.BackupPath, "/"), itemFileDir)
-			}
-			if _, err = client.Upload(backupDir+"/"+record.FileName, itemFileDir+"/"+record.FileName); err != nil {
-				return paths, err
-			}
-		}
-		if backup.Type == "LOCAL" || cronjob.KeepLocal {
-			paths = append(paths, fmt.Sprintf("%s/%s", record.FileDir, record.FileName))
-		} else {
-			paths = append(paths, fmt.Sprintf("%s/%s", itemFileDir, record.FileName))
-		}
-	}
-	u.HandleRmExpired(backup.Type, backup.BackupPath, localDir, &cronjob, client)
-	return paths, nil
-}
-
 func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime time.Time) ([]string, string, error) {
 	var (
 		err       error
@@ -377,7 +223,7 @@ func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime t
 		global.LOG.Infof(msg)
 		msgs = append(msgs, msg)
 	}
-	u.HandleRmExpired("LOCAL", "", "", cronjob, nil)
+	u.removeExpiredLog(*cronjob)
 	return msgs, strings.Join(filePaths, ","), err
 }
 
@@ -400,340 +246,129 @@ func backupLogFile(dstFilePath, websiteLogDir string, fileOp files.FileOp) error
 	return nil
 }
 
-func (u *CronjobService) handleApp(cronjob model.Cronjob, backup model.BackupAccount, startTime time.Time) ([]string, error) {
-	var paths []string
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return paths, err
-	}
-
-	var applist []model.AppInstall
-	if cronjob.AppID == "all" {
-		applist, err = appInstallRepo.ListBy()
-		if err != nil {
-			return paths, err
-		}
-	} else {
-		itemID, _ := (strconv.Atoi(cronjob.AppID))
-		app, err := appInstallRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
-		if err != nil {
-			return paths, err
-		}
-		applist = append(applist, app)
-	}
-
-	var client cloud_storage.CloudStorageClient
-	if backup.Type != "LOCAL" {
-		client, err = NewIBackupService().NewClient(&backup)
-		if err != nil {
-			return paths, err
-		}
-	}
-
-	for _, app := range applist {
-		var record model.BackupRecord
-		record.Type = "app"
-		record.Name = app.App.Key
-		record.DetailName = app.Name
-		record.Source = "LOCAL"
-		record.BackupType = backup.Type
-		backupDir := path.Join(localDir, fmt.Sprintf("app/%s/%s", app.App.Key, app.Name))
-		record.FileDir = backupDir
-		itemFileDir := strings.TrimPrefix(backupDir, localDir+"/")
-		if !cronjob.KeepLocal && backup.Type != "LOCAL" {
-			record.Source = backup.Type
-			record.FileDir = strings.TrimPrefix(backupDir, localDir+"/")
-		}
-		record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format("20060102150405"))
-		if err := handleAppBackup(&app, backupDir, record.FileName); err != nil {
-			return paths, err
-		}
-		if err := backupRepo.CreateRecord(&record); err != nil {
-			global.LOG.Errorf("save backup record failed, err: %v", err)
-			return paths, err
-		}
-		if backup.Type != "LOCAL" {
-			if !cronjob.KeepLocal {
-				defer func() {
-					_ = os.RemoveAll(fmt.Sprintf("%s/%s", backupDir, record.FileName))
-				}()
-			}
-			if len(backup.BackupPath) != 0 {
-				itemFileDir = path.Join(strings.TrimPrefix(backup.BackupPath, "/"), itemFileDir)
-			}
-			if _, err = client.Upload(backupDir+"/"+record.FileName, itemFileDir+"/"+record.FileName); err != nil {
-				return paths, err
-			}
-		}
-		if backup.Type == "LOCAL" || cronjob.KeepLocal {
-			paths = append(paths, fmt.Sprintf("%s/%s", record.FileDir, record.FileName))
-		} else {
-			paths = append(paths, fmt.Sprintf("%s/%s", itemFileDir, record.FileName))
-		}
-	}
-	u.HandleRmExpired(backup.Type, backup.BackupPath, localDir, &cronjob, client)
-	return paths, nil
-}
-
-func (u *CronjobService) handleWebsite(cronjob model.Cronjob, backup model.BackupAccount, startTime time.Time) ([]string, error) {
-	var paths []string
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return paths, err
-	}
-
-	weblist := loadWebsForJob(cronjob)
-	var client cloud_storage.CloudStorageClient
-	if backup.Type != "LOCAL" {
-		client, err = NewIBackupService().NewClient(&backup)
-		if err != nil {
-			return paths, err
-		}
-	}
-
-	for _, websiteItem := range weblist {
-		var record model.BackupRecord
-		record.Type = "website"
-		record.Name = websiteItem.PrimaryDomain
-		record.DetailName = websiteItem.Alias
-		record.Source = "LOCAL"
-		record.BackupType = backup.Type
-		backupDir := path.Join(localDir, fmt.Sprintf("website/%s", websiteItem.PrimaryDomain))
-		record.FileDir = backupDir
-		itemFileDir := strings.TrimPrefix(backupDir, localDir+"/")
-		if !cronjob.KeepLocal && backup.Type != "LOCAL" {
-			record.Source = backup.Type
-			record.FileDir = strings.TrimPrefix(backupDir, localDir+"/")
-		}
-		record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", websiteItem.PrimaryDomain, startTime.Format("20060102150405"))
-		if err := handleWebsiteBackup(&websiteItem, backupDir, record.FileName); err != nil {
-			return paths, err
-		}
-		if err := backupRepo.CreateRecord(&record); err != nil {
-			global.LOG.Errorf("save backup record failed, err: %v", err)
-			return paths, err
-		}
-		if backup.Type != "LOCAL" {
-			if !cronjob.KeepLocal {
-				defer func() {
-					_ = os.RemoveAll(fmt.Sprintf("%s/%s", backupDir, record.FileName))
-				}()
-			}
-			if len(backup.BackupPath) != 0 {
-				itemFileDir = path.Join(strings.TrimPrefix(backup.BackupPath, "/"), itemFileDir)
-			}
-			if _, err = client.Upload(backupDir+"/"+record.FileName, itemFileDir+"/"+record.FileName); err != nil {
-				return paths, err
-			}
-		}
-		if backup.Type == "LOCAL" || cronjob.KeepLocal {
-			paths = append(paths, fmt.Sprintf("%s/%s", record.FileDir, record.FileName))
-		} else {
-			paths = append(paths, fmt.Sprintf("%s/%s", itemFileDir, record.FileName))
-		}
-	}
-	u.HandleRmExpired(backup.Type, backup.BackupPath, localDir, &cronjob, client)
-	return paths, nil
-}
-
-func (u *CronjobService) handleSnapshot(cronjob *model.Cronjob, startTime time.Time) (string, string, error) {
-	backup, err := backupRepo.Get(commonRepo.WithByID(uint(cronjob.TargetDirID)))
-	if err != nil {
-		return "", "", err
-	}
-	client, err := NewIBackupService().NewClient(&backup)
-	if err != nil {
-		return "", "", err
-	}
-
-	req := dto.SnapshotCreate{
-		From: backup.Type,
-	}
-	message, name, err := NewISnapshotService().HandleSnapshot(true, req, startTime.Format("20060102150405"))
-	if err != nil {
-		return message, "", err
-	}
-
-	path := path.Join(strings.TrimPrefix(backup.BackupPath, "/"), "system_snapshot", name+".tar.gz")
-
-	u.HandleRmExpired(backup.Type, backup.BackupPath, "", cronjob, client)
-	return message, path, nil
-}
-
 func (u *CronjobService) handleSystemClean() (string, error) {
 	return NewIDeviceService().CleanForCronjob()
 }
 
-func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.Time) (string, error) {
-	backup, err := backupRepo.Get(commonRepo.WithByID(uint(cronjob.TargetDirID)))
+func loadClientMap(backupAccounts string) (map[string]cronjobUploadHelper, error) {
+	clients := make(map[string]cronjobUploadHelper)
+	accounts, err := backupRepo.List()
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-
-	pathItem := path.Join(global.CONF.System.BaseDir, "1panel/tmp/log", startTime.Format("20060102150405"))
-	websites, err := websiteRepo.List()
-	if err != nil {
-		return "", err
-	}
-	if len(websites) != 0 {
-		nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
-		if err != nil {
-			return "", err
+	targets := strings.Split(backupAccounts, ",")
+	for _, target := range targets {
+		if len(target) == 0 {
+			continue
 		}
-		webItem := path.Join(nginxInstall.GetPath(), "www/sites")
-		for _, website := range websites {
-			dirItem := path.Join(pathItem, "website", website.Alias)
-			if _, err := os.Stat(dirItem); err != nil && os.IsNotExist(err) {
-				if err = os.MkdirAll(dirItem, os.ModePerm); err != nil {
-					return "", err
+		for _, account := range accounts {
+			if target == account.Type {
+				client, err := NewIBackupService().NewClient(&account)
+				if err != nil {
+					return nil, err
 				}
-			}
-			itemDir := path.Join(webItem, website.Alias, "log")
-			logFiles, _ := os.ReadDir(itemDir)
-			if len(logFiles) != 0 {
-				for i := 0; i < len(logFiles); i++ {
-					if !logFiles[i].IsDir() {
-						_ = cpBinary([]string{path.Join(itemDir, logFiles[i].Name())}, dirItem)
-					}
+				pathItem := account.BackupPath
+				if account.BackupPath != "/" {
+					pathItem = strings.TrimPrefix(account.BackupPath, "/")
 				}
-			}
-			itemDir2 := path.Join(global.CONF.System.Backup, "log/website", website.Alias)
-			logFiles2, _ := os.ReadDir(itemDir2)
-			if len(logFiles2) != 0 {
-				for i := 0; i < len(logFiles2); i++ {
-					if !logFiles2[i].IsDir() {
-						_ = cpBinary([]string{path.Join(itemDir2, logFiles2[i].Name())}, dirItem)
-					}
+				clients[target] = cronjobUploadHelper{
+					client:     client,
+					backupPath: pathItem,
+					backType:   account.Type,
 				}
 			}
 		}
-		global.LOG.Debug("backup website log successful!")
 	}
+	return clients, nil
+}
 
-	systemLogDir := path.Join(global.CONF.System.BaseDir, "1panel/log")
-	systemDir := path.Join(pathItem, "system")
-	if _, err := os.Stat(systemDir); err != nil && os.IsNotExist(err) {
-		if err = os.MkdirAll(systemDir, os.ModePerm); err != nil {
-			return "", err
-		}
-	}
-	systemLogFiles, _ := os.ReadDir(systemLogDir)
-	if len(systemLogFiles) != 0 {
-		for i := 0; i < len(systemLogFiles); i++ {
-			if !systemLogFiles[i].IsDir() {
-				_ = cpBinary([]string{path.Join(systemLogDir, systemLogFiles[i].Name())}, systemDir)
-			}
-		}
-	}
-	global.LOG.Debug("backup system log successful!")
+type cronjobUploadHelper struct {
+	backupPath string
+	backType   string
+	client     cloud_storage.CloudStorageClient
+}
 
-	loginLogFiles, _ := os.ReadDir("/var/log")
-	loginDir := path.Join(pathItem, "login")
-	if _, err := os.Stat(loginDir); err != nil && os.IsNotExist(err) {
-		if err = os.MkdirAll(loginDir, os.ModePerm); err != nil {
-			return "", err
-		}
-	}
-	if len(loginLogFiles) != 0 {
-		for i := 0; i < len(loginLogFiles); i++ {
-			if !loginLogFiles[i].IsDir() && (strings.HasPrefix(loginLogFiles[i].Name(), "secure") || strings.HasPrefix(loginLogFiles[i].Name(), "auth.log")) {
-				_ = cpBinary([]string{path.Join("/var/log", loginLogFiles[i].Name())}, loginDir)
-			}
-		}
-	}
-	global.LOG.Debug("backup ssh log successful!")
-
-	fileName := fmt.Sprintf("system_log_%s.tar.gz", startTime.Format("20060102150405"))
-	targetDir := path.Dir(pathItem)
-	if err := handleTar(pathItem, targetDir, fileName, ""); err != nil {
-		return "", err
-	}
+func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, accountMap map[string]cronjobUploadHelper, file string) (string, error) {
 	defer func() {
-		os.RemoveAll(pathItem)
-		os.RemoveAll(path.Join(targetDir, fileName))
+		_ = os.Remove(file)
 	}()
+	accounts := strings.Split(cronjob.BackupAccounts, ",")
+	cloudSrc := strings.TrimPrefix(file, global.CONF.System.TmpDir+"/")
+	for _, account := range accounts {
+		if len(account) != 0 {
+			global.LOG.Debugf("start upload file to %s, dir: %s", account, path.Join(accountMap[account].backupPath, cloudSrc))
+			if _, err := accountMap[account].client.Upload(file, path.Join(accountMap[account].backupPath, cloudSrc)); err != nil {
+				return "", err
+			}
+			global.LOG.Debugf("upload successful!")
+		}
+	}
+	return cloudSrc, nil
+}
 
-	client, err := NewIBackupService().NewClient(&backup)
-	if err != nil {
-		return "", err
+func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap map[string]cronjobUploadHelper, record model.BackupRecord) {
+	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
+	var opts []repo.DBOption
+	opts = append(opts, commonRepo.WithByFrom("cronjob"))
+	opts = append(opts, backupRepo.WithByCronID(cronjob.ID))
+	opts = append(opts, commonRepo.WithOrderBy("created_at desc"))
+	if record.ID != 0 {
+		opts = append(opts, backupRepo.WithByType(record.Type))
+		opts = append(opts, commonRepo.WithByName(record.Name))
+		opts = append(opts, backupRepo.WithByDetailName(record.DetailName))
+	}
+	records, _ := backupRepo.ListRecord(opts...)
+	if len(records) <= int(cronjob.RetainCopies) {
+		return
+	}
+	for i := int(cronjob.RetainCopies); i < len(records); i++ {
+		accounts := strings.Split(cronjob.BackupAccounts, ",")
+		if cronjob.Type == "snapshot" {
+			for _, account := range accounts {
+				if len(account) != 0 {
+					_, _ = accountMap[account].client.Delete(path.Join(accountMap[account].backupPath, "system_snapshot", records[i].FileName))
+				}
+			}
+			_ = snapshotRepo.Delete(commonRepo.WithByName(strings.TrimSuffix(records[i].FileName, ".tar.gz")))
+		} else {
+			for _, account := range accounts {
+				if len(account) != 0 {
+					_, _ = accountMap[account].client.Delete(path.Join(accountMap[account].backupPath, records[i].FileDir, records[i].FileName))
+				}
+			}
+		}
+		_ = backupRepo.DeleteRecord(context.Background(), commonRepo.WithByID(records[i].ID))
+	}
+}
+
+func (u *CronjobService) removeExpiredLog(cronjob model.Cronjob) {
+	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
+	records, _ := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(cronjob.ID)), commonRepo.WithOrderBy("created_at desc"))
+	if len(records) <= int(cronjob.RetainCopies) {
+		return
+	}
+	for i := int(cronjob.RetainCopies); i < len(records); i++ {
+		if len(records[i].File) != 0 {
+			files := strings.Split(records[i].File, ",")
+			for _, file := range files {
+				_ = os.Remove(file)
+			}
+		}
+		_ = cronjobRepo.DeleteRecord(commonRepo.WithByID(uint(records[i].ID)))
+		_ = os.Remove(records[i].Records)
+	}
+}
+
+func (u *CronjobService) generateLogsPath(cronjob model.Cronjob, startTime time.Time) string {
+	dir := fmt.Sprintf("%s/task/%s/%s", constant.DataDir, cronjob.Type, cronjob.Name)
+	if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) {
+		_ = os.MkdirAll(dir, os.ModePerm)
 	}
 
-	targetPath := "log/" + fileName
-	if len(backup.BackupPath) != 0 {
-		targetPath = strings.TrimPrefix(backup.BackupPath, "/") + "/log/" + fileName
-	}
-
-	if _, err = client.Upload(path.Join(targetDir, fileName), targetPath); err != nil {
-		return "", err
-	}
-
-	u.HandleRmExpired(backup.Type, backup.BackupPath, "", &cronjob, client)
-	return targetPath, nil
+	path := fmt.Sprintf("%s/%s.log", dir, startTime.Format("20060102150405"))
+	return path
 }
 
 func hasBackup(cronjobType string) bool {
 	return cronjobType == "app" || cronjobType == "database" || cronjobType == "website" || cronjobType == "directory" || cronjobType == "snapshot" || cronjobType == "log"
 }
-
-type databaseHelper struct {
-	DBType   string
-	Database string
-	Name     string
-}
-
-func loadDbsForJob(cronjob model.Cronjob) []databaseHelper {
-	var dbs []databaseHelper
-	if cronjob.DBName == "all" {
-		if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
-			mysqlItems, _ := mysqlRepo.List()
-			for _, mysql := range mysqlItems {
-				dbs = append(dbs, databaseHelper{
-					DBType:   cronjob.DBType,
-					Database: mysql.MysqlName,
-					Name:     mysql.Name,
-				})
-			}
-		} else {
-			pgItems, _ := postgresqlRepo.List()
-			for _, pg := range pgItems {
-				dbs = append(dbs, databaseHelper{
-					DBType:   cronjob.DBType,
-					Database: pg.PostgresqlName,
-					Name:     pg.Name,
-				})
-			}
-		}
-		return dbs
-	}
-	itemID, _ := (strconv.Atoi(cronjob.DBName))
-	if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" {
-		mysqlItem, _ := mysqlRepo.Get(commonRepo.WithByID(uint(itemID)))
-		dbs = append(dbs, databaseHelper{
-			DBType:   cronjob.DBType,
-			Database: mysqlItem.MysqlName,
-			Name:     mysqlItem.Name,
-		})
-	} else {
-		pgItem, _ := postgresqlRepo.Get(commonRepo.WithByID(uint(itemID)))
-		dbs = append(dbs, databaseHelper{
-			DBType:   cronjob.DBType,
-			Database: pgItem.PostgresqlName,
-			Name:     pgItem.Name,
-		})
-	}
-	return dbs
-}
-
-func loadWebsForJob(cronjob model.Cronjob) []model.Website {
-	var weblist []model.Website
-	if cronjob.Website == "all" {
-		weblist, _ = websiteRepo.List()
-		return weblist
-	}
-	itemID, _ := (strconv.Atoi(cronjob.Website))
-	webItem, _ := websiteRepo.GetFirst(commonRepo.WithByID(uint(itemID)))
-	if webItem.ID != 0 {
-		weblist = append(weblist, webItem)
-	}
-	return weblist
-}

backend/app/service/dashboard.go

@@ -22,6 +22,7 @@ import (
 type DashboardService struct{}
 
 type IDashboardService interface {
+	LoadOsInfo() (*dto.OsInfo, error)
 	LoadBaseInfo(ioOption string, netOption string) (*dto.DashboardBase, error)
 	LoadCurrentInfo(ioOption string, netOption string) *dto.DashboardCurrent
 
@@ -49,6 +50,27 @@ func (u *DashboardService) Restart(operation string) error {
 	return nil
 }
 
+func (u *DashboardService) LoadOsInfo() (*dto.OsInfo, error) {
+	var baseInfo dto.OsInfo
+	hostInfo, err := host.Info()
+	if err != nil {
+		return nil, err
+	}
+	baseInfo.OS = hostInfo.OS
+	baseInfo.Platform = hostInfo.Platform
+	baseInfo.PlatformFamily = hostInfo.PlatformFamily
+	baseInfo.KernelArch = hostInfo.KernelArch
+	baseInfo.KernelVersion = hostInfo.KernelVersion
+
+	if baseInfo.KernelArch == "armv7l" {
+		baseInfo.KernelArch = "armv7"
+	}
+	if baseInfo.KernelArch == "x86_64" {
+		baseInfo.KernelArch = "amd64"
+	}
+	return &baseInfo, nil
+}
+
 func (u *DashboardService) LoadBaseInfo(ioOption string, netOption string) (*dto.DashboardBase, error) {
 	var baseInfo dto.DashboardBase
 	hostInfo, err := host.Info()
@@ -183,7 +205,10 @@ func loadDiskInfo() []dto.DiskInfo {
 	var datas []dto.DiskInfo
 	stdout, err := cmd.ExecWithTimeOut("df -hT -P|grep '/'|grep -v tmpfs|grep -v 'snap/core'|grep -v udev", 2*time.Second)
 	if err != nil {
-		return datas
+		stdout, err = cmd.ExecWithTimeOut("df -lhT -P|grep '/'|grep -v tmpfs|grep -v 'snap/core'|grep -v udev", 1*time.Second)
+		if err != nil {
+			return datas
+		}
 	}
 	lines := strings.Split(stdout, "\n")
 

backend/app/service/database_mysql.go

@@ -190,11 +190,13 @@ func (u *MysqlService) LoadFromRemote(req dto.MysqlLoadDB) error {
 	if err != nil {
 		return err
 	}
+	deleteList := databases
 	for _, data := range datas {
 		hasOld := false
-		for _, oldData := range databases {
-			if strings.EqualFold(oldData.Name, data.Name) && strings.EqualFold(oldData.MysqlName, data.MysqlName) {
+		for i := 0; i < len(databases); i++ {
+			if strings.EqualFold(databases[i].Name, data.Name) && strings.EqualFold(databases[i].MysqlName, data.MysqlName) {
 				hasOld = true
+				deleteList = append(deleteList[:i], deleteList[i+1:]...)
 				break
 			}
 		}
@@ -208,6 +210,9 @@ func (u *MysqlService) LoadFromRemote(req dto.MysqlLoadDB) error {
 			}
 		}
 	}
+	for _, delItem := range deleteList {
+		_ = mysqlRepo.Update(delItem.ID, map[string]interface{}{"is_delete": true})
+	}
 	return nil
 }
 
@@ -342,7 +347,7 @@ func (u *MysqlService) ChangePassword(req dto.ChangeDBInfo) error {
 			}
 
 			global.LOG.Infof("start to update mysql password used by app %s-%s", appModel.Key, appInstall.Name)
-			if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", true, req.Value); err != nil {
+			if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", req.Value); err != nil {
 				return err
 			}
 		}
@@ -355,7 +360,7 @@ func (u *MysqlService) ChangePassword(req dto.ChangeDBInfo) error {
 		return nil
 	}
 
-	if err := updateInstallInfoInDB(req.Type, req.Database, "password", false, req.Value); err != nil {
+	if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
 		return err
 	}
 	return nil

backend/app/service/database_postgresql.go

@@ -216,11 +216,13 @@ func (u *PostgresqlService) LoadFromRemote(database string) error {
 	if err != nil {
 		return err
 	}
+	deleteList := databases
 	for _, data := range datas {
 		hasOld := false
-		for _, oldData := range databases {
-			if strings.EqualFold(oldData.Name, data.Name) && strings.EqualFold(oldData.PostgresqlName, data.PostgresqlName) {
+		for i := 0; i < len(databases); i++ {
+			if strings.EqualFold(databases[i].Name, data.Name) && strings.EqualFold(databases[i].PostgresqlName, data.PostgresqlName) {
 				hasOld = true
+				deleteList = append(deleteList[:i], deleteList[i+1:]...)
 				break
 			}
 		}
@@ -234,6 +236,9 @@ func (u *PostgresqlService) LoadFromRemote(database string) error {
 			}
 		}
 	}
+	for _, delItem := range deleteList {
+		_ = postgresqlRepo.Update(delItem.ID, map[string]interface{}{"is_delete": true})
+	}
 	return nil
 }
 
@@ -393,7 +398,7 @@ func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
 			}
 
 			global.LOG.Infof("start to update postgresql password used by app %s-%s", appModel.Key, appInstall.Name)
-			if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", true, req.Value); err != nil {
+			if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", req.Value); err != nil {
 				return err
 			}
 		}
@@ -406,7 +411,7 @@ func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
 		return nil
 	}
 
-	if err := updateInstallInfoInDB(req.Type, req.Database, "password", false, req.Value); err != nil {
+	if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
 		return err
 	}
 	return nil

backend/app/service/database_redis.go

@@ -44,7 +44,7 @@ func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
 	confs = append(confs, redisConfig{key: "timeout", value: req.Timeout})
 	confs = append(confs, redisConfig{key: "maxclients", value: req.Maxclients})
 	confs = append(confs, redisConfig{key: "maxmemory", value: req.Maxmemory})
-	if err := confSet(redisInfo.Name, confs); err != nil {
+	if err := confSet(redisInfo.Name, "", confs); err != nil {
 		return err
 	}
 	if _, err := compose.Restart(fmt.Sprintf("%s/redis/%s/docker-compose.yml", constant.AppInstallDir, redisInfo.Name)); err != nil {
@@ -55,10 +55,10 @@ func (u *RedisService) UpdateConf(req dto.RedisConfUpdate) error {
 }
 
 func (u *RedisService) ChangePassword(req dto.ChangeRedisPass) error {
-	if err := updateInstallInfoInDB("redis", "", "password", true, req.Value); err != nil {
+	if err := updateInstallInfoInDB("redis", "", "password", req.Value); err != nil {
 		return err
 	}
-	if err := updateInstallInfoInDB("redis-commander", "", "password", true, req.Value); err != nil {
+	if err := updateInstallInfoInDB("redis-commander", "", "password", req.Value); err != nil {
 		return err
 	}
 
@@ -78,7 +78,7 @@ func (u *RedisService) UpdatePersistenceConf(req dto.RedisConfPersistenceUpdate)
 		confs = append(confs, redisConfig{key: "appendonly", value: req.Appendonly})
 		confs = append(confs, redisConfig{key: "appendfsync", value: req.Appendfsync})
 	}
-	if err := confSet(redisInfo.Name, confs); err != nil {
+	if err := confSet(redisInfo.Name, req.Type, confs); err != nil {
 		return err
 	}
 	if _, err := compose.Restart(fmt.Sprintf("%s/redis/%s/docker-compose.yml", constant.AppInstallDir, redisInfo.Name)); err != nil {
@@ -213,7 +213,7 @@ type redisConfig struct {
 	value string
 }
 
-func confSet(redisName string, changeConf []redisConfig) error {
+func confSet(redisName string, updateType string, changeConf []redisConfig) error {
 	path := fmt.Sprintf("%s/redis/%s/conf/redis.conf", constant.AppInstallDir, redisName)
 	lineBytes, err := os.ReadFile(path)
 	if err != nil {
@@ -221,19 +221,38 @@ func confSet(redisName string, changeConf []redisConfig) error {
 	}
 	files := strings.Split(string(lineBytes), "\n")
 
-	startIndex, endIndex := 0, 0
+	startIndex, endIndex, emptyLine := 0, 0, 0
 	var newFiles []string
 	for i := 0; i < len(files); i++ {
 		if files[i] == "# Redis configuration rewrite by 1Panel" {
 			startIndex = i
+			newFiles = append(newFiles, files[i])
+			continue
 		}
 		if files[i] == "# End Redis configuration rewrite by 1Panel" {
 			endIndex = i
 			break
 		}
+		if startIndex == 0 && strings.HasPrefix(files[i], "save ") {
+			newFiles = append(newFiles, "#   "+files[i])
+			continue
+		}
+		if startIndex != 0 && endIndex == 0 && (len(files[i]) == 0 || (updateType == "rbd" && strings.HasPrefix(files[i], "save "))) {
+			emptyLine++
+			continue
+		}
 		newFiles = append(newFiles, files[i])
 	}
+	endIndex = endIndex - emptyLine
 	for _, item := range changeConf {
+		if item.key == "save" {
+			saveVal := strings.Split(item.value, ",")
+			for i := 0; i < len(saveVal); i++ {
+				newFiles = append(newFiles, "save "+saveVal[i])
+			}
+			continue
+		}
+
 		isExist := false
 		for i := startIndex; i < endIndex; i++ {
 			if strings.HasPrefix(newFiles[i], item.key) || strings.HasPrefix(newFiles[i], "# "+item.key) {

backend/app/service/docker.go

@@ -181,7 +181,7 @@ func (u *DockerService) UpdateConf(req dto.SettingUpdate) error {
 		} else {
 			daemonMap["iptables"] = false
 		}
-	case "Dirver":
+	case "Driver":
 		if opts, ok := daemonMap["exec-opts"]; ok {
 			if optsValue, isArray := opts.([]interface{}); isArray {
 				for i := 0; i < len(optsValue); i++ {

backend/app/service/fail2ban.go

@@ -107,7 +107,7 @@ func (u *Fail2BanService) UpdateConf(req dto.Fail2BanUpdate) error {
 		if req.Value == "firewallcmd-ipset" || req.Value == "ufw" {
 			itemName := "ufw"
 			if req.Value == "firewallcmd-ipset" {
-				itemName = "firewallcmd"
+				itemName = "firewalld"
 			}
 			client, err := firewall.NewFirewallClient()
 			if err != nil {

backend/app/service/monitor.go

@@ -211,6 +211,6 @@ func StartMonitor(removeBefore bool, interval string) error {
 	go service.saveIODataToDB(ctx, float64(intervalItem))
 	go service.saveNetDataToDB(ctx, float64(intervalItem))
 
-	global.MonitorCronID = int(monitorID)
+	global.MonitorCronID = monitorID
 	return nil
 }

backend/app/service/nginx_utils.go

@@ -37,7 +37,10 @@ func getNginxFull(website *model.Website) (dto.NginxFull, error) {
 	if err != nil {
 		return nginxFull, err
 	}
-	config := parser.NewStringParser(string(content)).Parse()
+	config, err := parser.NewStringParser(string(content)).Parse()
+	if err != nil {
+		return dto.NginxFull{}, err
+	}
 	config.FilePath = nginxConfig.FilePath
 	nginxConfig.OldContent = string(content)
 	nginxConfig.Config = config
@@ -54,7 +57,10 @@ func getNginxFull(website *model.Website) (dto.NginxFull, error) {
 		if err != nil {
 			return nginxFull, err
 		}
-		siteConfig := parser.NewStringParser(string(siteNginxContent)).Parse()
+		siteConfig, err := parser.NewStringParser(string(siteNginxContent)).Parse()
+		if err != nil {
+			return dto.NginxFull{}, err
+		}
 		siteConfig.FilePath = siteConfigPath
 		siteNginxConfig.Config = siteConfig
 		siteNginxConfig.OldContent = string(siteNginxContent)
@@ -156,15 +162,22 @@ func deleteNginxConfig(scope string, params []dto.NginxParam, website *model.Web
 }
 
 func getNginxParamsFromStaticFile(scope dto.NginxKey, newParams []dto.NginxParam) []dto.NginxParam {
-	newConfig := &components.Config{}
+	var (
+		newConfig = &components.Config{}
+		err       error
+	)
+
 	updateScope := "in"
 	switch scope {
 	case dto.SSL:
-		newConfig = parser.NewStringParser(string(nginx_conf.SSL)).Parse()
+		newConfig, err = parser.NewStringParser(string(nginx_conf.SSL)).Parse()
 	case dto.CACHE:
-		newConfig = parser.NewStringParser(string(nginx_conf.Cache)).Parse()
+		newConfig, err = parser.NewStringParser(string(nginx_conf.Cache)).Parse()
 	case dto.ProxyCache:
-		newConfig = parser.NewStringParser(string(nginx_conf.ProxyCache)).Parse()
+		newConfig, err = parser.NewStringParser(string(nginx_conf.ProxyCache)).Parse()
+	}
+	if err != nil {
+		return nil
 	}
 	for _, dir := range newConfig.GetDirectives() {
 		addParam := dto.NginxParam{

backend/app/service/recycle_bin.go

@@ -153,22 +153,20 @@ func (r RecycleBinService) Clear() error {
 }
 
 func getClashDir(realPath string) (string, error) {
-	trimmedPath := strings.Trim(realPath, "/")
-	parts := strings.Split(trimmedPath, "/")
-	dir := ""
-	if len(parts) > 0 {
-		dir = parts[0]
-		partitions, err := disk.Partitions(false)
-		if err != nil {
-			return "", err
+	partitions, err := disk.Partitions(false)
+	if err != nil {
+		return "", err
+	}
+	for _, p := range partitions {
+		if p.Mountpoint == "/" {
+			continue
 		}
-		for _, p := range partitions {
-			if p.Mountpoint == dir {
-				if err = createClashDir(path.Join(p.Mountpoint, ".1panel_clash")); err != nil {
-					return "", err
-				}
-				return dir, nil
+		if strings.HasPrefix(realPath, p.Mountpoint) {
+			clashDir := path.Join(p.Mountpoint, ".1panel_clash")
+			if err = createClashDir(path.Join(p.Mountpoint, ".1panel_clash")); err != nil {
+				return "", err
 			}
+			return clashDir, nil
 		}
 	}
 	return constant.RecycleBinDir, createClashDir(constant.RecycleBinDir)

backend/app/service/runtime.go

@@ -42,6 +42,7 @@ type IRuntimeService interface {
 	GetNodeModules(req request.NodeModuleReq) ([]response.NodeModule, error)
 	OperateNodeModules(req request.NodeModuleOperateReq) error
 	SyncForRestart() error
+	SyncRuntimeStatus() error
 }
 
 func NewRuntimeService() IRuntimeService {
@@ -586,3 +587,16 @@ func (r *RuntimeService) SyncForRestart() error {
 	}
 	return nil
 }
+
+func (r *RuntimeService) SyncRuntimeStatus() error {
+	runtimes, err := runtimeRepo.List()
+	if err != nil {
+		return err
+	}
+	for _, runtime := range runtimes {
+		if runtime.Type == constant.RuntimeNode {
+			_ = SyncRuntimeContainerStatus(&runtime)
+		}
+	}
+	return nil
+}

backend/app/service/runtime_utils.go

@@ -181,33 +181,20 @@ func SyncRuntimeContainerStatus(runtime *model.Runtime) error {
 	}
 	container := containers[0]
 
-	interval := 10 * time.Second
-	retries := 60
-	for i := 0; i < retries; i++ {
-		resp, err := cli.InspectContainer(container.ID)
-		if err != nil {
-			time.Sleep(interval)
-			continue
+	switch container.State {
+	case "exited":
+		runtime.Status = constant.RuntimeError
+	case "running":
+		runtime.Status = constant.RuntimeRunning
+	case "paused":
+		runtime.Status = constant.RuntimeStopped
+	default:
+		if runtime.Status != constant.RuntimeBuildIng {
+			runtime.Status = constant.RuntimeStopped
 		}
-		if resp.State.Health != nil {
-			status := strings.ToLower(resp.State.Health.Status)
-			switch status {
-			case "starting":
-				runtime.Status = constant.RuntimeStarting
-				_ = runtimeRepo.Save(runtime)
-			case "healthy":
-				runtime.Status = constant.RuntimeRunning
-				_ = runtimeRepo.Save(runtime)
-				return nil
-			case "unhealthy":
-				runtime.Status = constant.RuntimeUnhealthy
-				_ = runtimeRepo.Save(runtime)
-				return nil
-			}
-		}
-		time.Sleep(interval)
 	}
-	return nil
+
+	return runtimeRepo.Save(runtime)
 }
 
 func buildRuntime(runtime *model.Runtime, oldImageID string, rebuild bool) {

backend/app/service/setting.go

@@ -198,6 +198,9 @@ func (u *SettingService) UpdateSSL(c *gin.Context, req dto.SSLUpdate) error {
 		}
 		_ = os.Remove(path.Join(secretDir, "server.crt"))
 		_ = os.Remove(path.Join(secretDir, "server.key"))
+		sID, _ := c.Cookie(constant.SessionName)
+		c.SetCookie(constant.SessionName, sID, 0, "", "", false, true)
+
 		go func() {
 			_, err := cmd.Exec("systemctl restart 1panel.service")
 			if err != nil {
@@ -277,7 +280,7 @@ func (u *SettingService) UpdateSSL(c *gin.Context, req dto.SSLUpdate) error {
 	if err := fileOp.WriteFile(path.Join(secretDir, "server.key.tmp"), strings.NewReader(key), 0600); err != nil {
 		return err
 	}
-	if err := checkCertValid(req.Domain); err != nil {
+	if err := checkCertValid(); err != nil {
 		return err
 	}
 	if err := fileOp.Rename(path.Join(secretDir, "server.crt.tmp"), path.Join(secretDir, "server.crt")); err != nil {
@@ -289,6 +292,9 @@ func (u *SettingService) UpdateSSL(c *gin.Context, req dto.SSLUpdate) error {
 	if err := settingRepo.Update("SSL", req.SSL); err != nil {
 		return err
 	}
+
+	sID, _ := c.Cookie(constant.SessionName)
+	c.SetCookie(constant.SessionName, sID, 0, "", "", true, true)
 	go func() {
 		time.Sleep(1 * time.Second)
 		_, err := cmd.Exec("systemctl restart 1panel.service")
@@ -412,7 +418,7 @@ func loadInfoFromCert() (*dto.SSLInfo, error) {
 	}, nil
 }
 
-func checkCertValid(domain string) error {
+func checkCertValid() error {
 	certificate, err := os.ReadFile(path.Join(global.CONF.System.BaseDir, "1panel/secret/server.crt.tmp"))
 	if err != nil {
 		return err

backend/app/service/snapshot.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"regexp"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -18,10 +16,10 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
-	"github.com/1Panel-dev/1Panel/backend/utils/docker"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/jinzhu/copier"
 	"github.com/pkg/errors"
+	"github.com/shirou/gopsutil/v3/host"
 )
 
 type SnapshotService struct {
@@ -41,7 +39,7 @@ type ISnapshotService interface {
 	UpdateDescription(req dto.UpdateDescription) error
 	readFromJson(path string) (SnapshotJson, error)
 
-	HandleSnapshot(isCronjob bool, req dto.SnapshotCreate, timeNow string) (string, string, error)
+	HandleSnapshot(isCronjob bool, logPath string, req dto.SnapshotCreate, timeNow string) (string, error)
 }
 
 func NewISnapshotService() ISnapshotService {
@@ -74,26 +72,19 @@ func (u *SnapshotService) SnapshotImport(req dto.SnapshotImport) error {
 	for _, snap := range req.Names {
 		shortName := strings.TrimPrefix(snap, "snapshot_")
 		nameItems := strings.Split(shortName, "_")
-		if !strings.HasPrefix(shortName, "1panel_v") || !strings.HasSuffix(shortName, ".tar.gz") || len(nameItems) != 3 {
-			return fmt.Errorf("incorrect snapshot name format of %s", shortName)
-		}
-		formatTime, err := time.Parse("20060102150405", strings.ReplaceAll(nameItems[2], ".tar.gz", ""))
-		if err != nil {
+		if !strings.HasPrefix(shortName, "1panel_v") || !strings.HasSuffix(shortName, ".tar.gz") || len(nameItems) < 3 {
 			return fmt.Errorf("incorrect snapshot name format of %s", shortName)
 		}
 		if strings.HasSuffix(snap, ".tar.gz") {
 			snap = strings.ReplaceAll(snap, ".tar.gz", "")
 		}
 		itemSnap := model.Snapshot{
-			Name:        snap,
-			From:        req.From,
-			Version:     nameItems[1],
-			Description: req.Description,
-			Status:      constant.StatusSuccess,
-			BaseModel: model.BaseModel{
-				CreatedAt: formatTime,
-				UpdatedAt: formatTime,
-			},
+			Name:            snap,
+			From:            req.From,
+			DefaultDownload: req.From,
+			Version:         nameItems[1],
+			Description:     req.Description,
+			Status:          constant.StatusSuccess,
 		}
 		if err := snapshotRepo.Create(&itemSnap); err != nil {
 			return err
@@ -132,7 +123,7 @@ type SnapshotJson struct {
 }
 
 func (u *SnapshotService) SnapshotCreate(req dto.SnapshotCreate) error {
-	if _, _, err := u.HandleSnapshot(false, req, time.Now().Format("20060102150405")); err != nil {
+	if _, err := u.HandleSnapshot(false, "", req, time.Now().Format("20060102150405")); err != nil {
 		return err
 	}
 	return nil
@@ -144,26 +135,13 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 	if err != nil {
 		return err
 	}
+	if hasOs(snap.Name) && !strings.Contains(snap.Name, loadOs()) {
+		return fmt.Errorf("Restoring snapshots(%s) between different server architectures(%s) is not supported.", snap.Name, loadOs())
+	}
 	if !req.IsNew && len(snap.InterruptStep) != 0 && len(snap.RollbackStatus) != 0 {
 		return fmt.Errorf("the snapshot has been rolled back and cannot be restored again")
 	}
-	isNewSnapshot := isNewSnapVersion(snap.Version)
-	isReTry := false
-	if len(snap.InterruptStep) != 0 && !req.IsNew {
-		isReTry = true
-	}
-	backup, err := backupRepo.Get(commonRepo.WithByType(snap.From))
-	if err != nil {
-		return err
-	}
-	client, err := NewIBackupService().NewClient(&backup)
-	if err != nil {
-		return err
-	}
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return err
-	}
+
 	baseDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("system/%s", snap.Name))
 	if _, err := os.Stat(baseDir); err != nil && os.IsNotExist(err) {
 		_ = os.MkdirAll(baseDir, os.ModePerm)
@@ -171,151 +149,7 @@ func (u *SnapshotService) SnapshotRecover(req dto.SnapshotRecover) error {
 
 	_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"recover_status": constant.StatusWaiting})
 	_ = settingRepo.Update("SystemStatus", "Recovering")
-	go func() {
-		_ = global.Cron.Stop()
-		defer func() {
-			global.Cron.Start()
-		}()
-		operation := "recover"
-		if isReTry {
-			operation = "re-recover"
-		}
-		if !isReTry || snap.InterruptStep == "Download" || (isReTry && req.ReDownload) {
-			itemBackupPath := strings.TrimPrefix(backup.BackupPath, "/")
-			itemBackupPath = strings.TrimSuffix(itemBackupPath, "/")
-			ok, err := client.Download(fmt.Sprintf("%s/system_snapshot/%s.tar.gz", itemBackupPath, snap.Name), fmt.Sprintf("%s/%s.tar.gz", baseDir, snap.Name))
-			if err != nil || !ok {
-				if req.ReDownload {
-					updateRecoverStatus(snap.ID, snap.InterruptStep, constant.StatusFailed, fmt.Sprintf("download file %s from %s failed, err: %v", snap.Name, backup.Type, err))
-					return
-				}
-				updateRecoverStatus(snap.ID, "Download", constant.StatusFailed, fmt.Sprintf("download file %s from %s failed, err: %v", snap.Name, backup.Type, err))
-				return
-			}
-			isReTry = false
-		}
-		fileOp := files.NewFileOp()
-		if !isReTry || snap.InterruptStep == "Decompress" || (isReTry && req.ReDownload) {
-			if err := handleUnTar(fmt.Sprintf("%s/%s.tar.gz", baseDir, snap.Name), baseDir); err != nil {
-				if req.ReDownload {
-					updateRecoverStatus(snap.ID, snap.InterruptStep, constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
-					return
-				}
-				updateRecoverStatus(snap.ID, "Decompress", constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
-				return
-			}
-			isReTry = false
-		}
-		rootDir := fmt.Sprintf("%s/%s", baseDir, snap.Name)
-
-		snapJson, err := u.readFromJson(fmt.Sprintf("%s/snapshot.json", rootDir))
-		if err != nil {
-			updateRecoverStatus(snap.ID, "Readjson", constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
-			return
-		}
-		if snap.InterruptStep == "Readjson" {
-			isReTry = false
-		}
-		u.OriginalPath = fmt.Sprintf("%s/1panel_original/original_%s", snapJson.BaseDir, snap.Name)
-		_ = os.MkdirAll(u.OriginalPath, os.ModePerm)
-
-		snapJson.OldBaseDir = global.CONF.System.BaseDir
-		snapJson.OldPanelDataDir = path.Join(global.CONF.System.BaseDir, "1panel")
-		snapJson.OldBackupDataDir = localDir
-		recoverPanelDir := fmt.Sprintf("%s/%s/1panel", baseDir, snap.Name)
-		liveRestore := false
-
-		if !isNewSnapshot {
-			if !isReTry || snap.InterruptStep == "LoadDockerJson" {
-				snapJson.OldDockerDataDir, liveRestore, err = u.loadDockerDataDir()
-				if err != nil {
-					updateRecoverStatus(snap.ID, "LoadDockerJson", constant.StatusFailed, fmt.Sprintf("load docker data dir failed, err: %v", err))
-					return
-				}
-				isReTry = false
-			}
-			if liveRestore {
-				if err := u.updateLiveRestore(false); err != nil {
-					updateRecoverStatus(snap.ID, "UpdateLiveRestore", constant.StatusFailed, fmt.Sprintf("update docker daemon.json live-restore conf failed, err: %v", err))
-					return
-				}
-				isReTry = false
-			}
-			_ = u.saveJson(snapJson, rootDir)
-
-			_, _ = cmd.Exec("systemctl stop docker")
-			if !isReTry || snap.InterruptStep == "DockerDir" {
-				if err := u.handleDockerDatas(fileOp, operation, rootDir, snapJson.DockerDataDir); err != nil {
-					updateRecoverStatus(snap.ID, "DockerDir", constant.StatusFailed, err.Error())
-					return
-				}
-				isReTry = false
-			}
-		} else {
-			if !isReTry || snap.InterruptStep == "DockerDir" {
-				if err := u.handleDockerDatasWithSave(fileOp, operation, rootDir, ""); err != nil {
-					updateRecoverStatus(snap.ID, "DockerDir", constant.StatusFailed, err.Error())
-					return
-				}
-				isReTry = false
-			}
-		}
-
-		if !isReTry || snap.InterruptStep == "DaemonJson" {
-			if err := u.handleDaemonJson(fileOp, operation, rootDir+"/docker/daemon.json", u.OriginalPath); err != nil {
-				updateRecoverStatus(snap.ID, "DaemonJson", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-		_, _ = cmd.Exec("systemctl restart docker")
-
-		if !isReTry || snap.InterruptStep == "1PanelBinary" {
-			if err := u.handlePanelBinary(fileOp, operation, recoverPanelDir+"/1panel", u.OriginalPath+"/1panel"); err != nil {
-				updateRecoverStatus(snap.ID, "1PanelBinary", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-		if !isReTry || snap.InterruptStep == "1PctlBinary" {
-			if err := u.handlePanelctlBinary(fileOp, operation, recoverPanelDir+"/1pctl", u.OriginalPath+"/1pctl"); err != nil {
-				updateRecoverStatus(snap.ID, "1PctlBinary", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-		if !isReTry || snap.InterruptStep == "1PanelService" {
-			if err := u.handlePanelService(fileOp, operation, recoverPanelDir+"/1panel.service", u.OriginalPath+"/1panel.service"); err != nil {
-				updateRecoverStatus(snap.ID, "1PanelService", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-
-		if !isReTry || snap.InterruptStep == "1PanelBackups" {
-			if err := u.handleBackupDatas(fileOp, operation, rootDir, snapJson.BackupDataDir); err != nil {
-				updateRecoverStatus(snap.ID, "1PanelBackups", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-
-		if !isReTry || snap.InterruptStep == "1PanelData" {
-			if err := u.handlePanelDatas(snap.ID, fileOp, operation, rootDir, snapJson.PanelDataDir, localDir, snapJson.OldDockerDataDir); err != nil {
-				updateRecoverStatus(snap.ID, "1PanelData", constant.StatusFailed, err.Error())
-				return
-			}
-			isReTry = false
-		}
-
-		if isNewSnapshot {
-			_ = rebuildAllAppInstall()
-		}
-
-		_ = os.RemoveAll(rootDir)
-		global.LOG.Info("recover successful")
-		_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
-	}()
+	go u.HandleSnapshotRecover(snap, true, req)
 	return nil
 }
 
@@ -325,132 +159,9 @@ func (u *SnapshotService) SnapshotRollback(req dto.SnapshotRecover) error {
 	if err != nil {
 		return err
 	}
-	if snap.InterruptStep == "Download" || snap.InterruptStep == "Decompress" || snap.InterruptStep == "Readjson" {
-		return nil
-	}
-	localDir, err := loadLocalDir()
-	if err != nil {
-		return err
-	}
-	fileOp := files.NewFileOp()
-	isNewSnapshot := isNewSnapVersion(snap.Version)
-
-	rootDir := path.Join(localDir, fmt.Sprintf("system/%s/%s", snap.Name, snap.Name))
-
-	_ = settingRepo.Update("SystemStatus", "Rollbacking")
-	_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"rollback_status": constant.StatusWaiting})
-	go func() {
-		_ = global.Cron.Stop()
-		defer func() {
-			global.Cron.Start()
-		}()
-		snapJson, err := u.readFromJson(fmt.Sprintf("%s/snapshot.json", rootDir))
-		if err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
-			return
-		}
-		u.OriginalPath = fmt.Sprintf("%s/1panel_original/original_%s", snapJson.OldBaseDir, snap.Name)
-		if _, err := os.Stat(u.OriginalPath); err != nil && os.IsNotExist(err) {
-			return
-		}
-
-		if !isNewSnapshot {
-			_, _ = cmd.Exec("systemctl stop docker")
-			if err := u.handleDockerDatas(fileOp, "rollback", u.OriginalPath, snapJson.OldDockerDataDir); err != nil {
-				updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-				return
-			}
-			defer func() {
-				_, _ = cmd.Exec("systemctl restart docker")
-			}()
-			if snap.InterruptStep == "DockerDir" {
-				return
-			}
-			if snapJson.LiveRestoreEnabled {
-				if err := u.updateLiveRestore(true); err != nil {
-					updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-					return
-				}
-			}
-			if snap.InterruptStep == "UpdateLiveRestore" {
-				return
-			}
-		} else {
-			if err := u.handleDockerDatasWithSave(fileOp, "rollback", u.OriginalPath, ""); err != nil {
-				updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-				return
-			}
-			defer func() {
-				_ = rebuildAllAppInstall()
-			}()
-			if snap.InterruptStep == "DockerDir" {
-				return
-			}
-		}
-
-		if err := u.handleDaemonJson(fileOp, "rollback", u.OriginalPath+"/daemon.json", ""); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "DaemonJson" {
-			return
-		}
-
-		if err := u.handlePanelBinary(fileOp, "rollback", u.OriginalPath+"/1panel", ""); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "1PanelBinary" {
-			return
-		}
-
-		if err := u.handlePanelctlBinary(fileOp, "rollback", u.OriginalPath+"/1pctl", ""); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "1PctlBinary" {
-			return
-		}
-
-		if err := u.handlePanelService(fileOp, "rollback", u.OriginalPath+"/1panel.service", ""); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "1PanelService" {
-			_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
-			return
-		}
-
-		if err := u.handleBackupDatas(fileOp, "rollback", u.OriginalPath, snapJson.OldBackupDataDir); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "1PanelBackups" {
-			_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
-			return
-		}
-
-		if err := u.handlePanelDatas(snap.ID, fileOp, "rollback", u.OriginalPath, snapJson.OldPanelDataDir, "", ""); err != nil {
-			updateRollbackStatus(snap.ID, constant.StatusFailed, err.Error())
-			return
-		}
-		if snap.InterruptStep == "1PanelData" {
-			_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
-			return
-		}
-
-		_ = os.RemoveAll(rootDir)
-		global.LOG.Info("rollback successful")
-		_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
-	}()
-	return nil
-}
-
-func (u *SnapshotService) saveJson(snapJson SnapshotJson, path string) error {
-	remarkInfo, _ := json.MarshalIndent(snapJson, "", "\t")
-	if err := os.WriteFile(fmt.Sprintf("%s/snapshot.json", path), remarkInfo, 0640); err != nil {
-		return err
-	}
+	req.IsNew = false
+	snap.InterruptStep = "Readjson"
+	go u.HandleSnapshotRecover(snap, false, req)
 	return nil
 }
 
@@ -469,10 +180,10 @@ func (u *SnapshotService) readFromJson(path string) (SnapshotJson, error) {
 	return snap, nil
 }
 
-func (u *SnapshotService) HandleSnapshot(isCronjob bool, req dto.SnapshotCreate, timeNow string) (string, string, error) {
+func (u *SnapshotService) HandleSnapshot(isCronjob bool, logPath string, req dto.SnapshotCreate, timeNow string) (string, error) {
 	localDir, err := loadLocalDir()
 	if err != nil {
-		return "", "", err
+		return "", err
 	}
 	var (
 		rootDir    string
@@ -482,18 +193,20 @@ func (u *SnapshotService) HandleSnapshot(isCronjob bool, req dto.SnapshotCreate,
 
 	if req.ID == 0 {
 		versionItem, _ := settingRepo.Get(settingRepo.WithByKey("SystemVersion"))
-		name := fmt.Sprintf("1panel_%s_%s", versionItem.Value, timeNow)
+
+		name := fmt.Sprintf("1panel_%s_%s_%s", versionItem.Value, loadOs(), timeNow)
 		if isCronjob {
-			name = fmt.Sprintf("snapshot_1panel_%s_%s", versionItem.Value, timeNow)
+			name = fmt.Sprintf("snapshot_1panel_%s_%s_%s", versionItem.Value, loadOs(), timeNow)
 		}
 		rootDir = path.Join(localDir, "system", name)
 
 		snap = model.Snapshot{
-			Name:        name,
-			Description: req.Description,
-			From:        req.From,
-			Version:     versionItem.Value,
-			Status:      constant.StatusWaiting,
+			Name:            name,
+			Description:     req.Description,
+			From:            req.From,
+			DefaultDownload: req.DefaultDownload,
+			Version:         versionItem.Value,
+			Status:          constant.StatusWaiting,
 		}
 		_ = snapshotRepo.Create(&snap)
 		snapStatus.SnapID = snap.ID
@@ -501,8 +214,9 @@ func (u *SnapshotService) HandleSnapshot(isCronjob bool, req dto.SnapshotCreate,
 	} else {
 		snap, err = snapshotRepo.Get(commonRepo.WithByID(req.ID))
 		if err != nil {
-			return "", "", err
+			return "", err
 		}
+		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusWaiting})
 		snapStatus, _ = snapshotRepo.GetStatus(snap.ID)
 		if snapStatus.ID == 0 {
 			snapStatus.SnapID = snap.ID
@@ -523,7 +237,7 @@ func (u *SnapshotService) HandleSnapshot(isCronjob bool, req dto.SnapshotCreate,
 		BackupDataDir: localDir,
 		PanelDataDir:  path.Join(global.CONF.System.BaseDir, "1panel"),
 	}
-
+	loadLogByStatus(snapStatus, logPath)
 	if snapStatus.PanelInfo != constant.StatusDone {
 		wg.Add(1)
 		go snapJson(itemHelper, jsonItem, rootDir)
@@ -552,278 +266,61 @@ func (u *SnapshotService) HandleSnapshot(isCronjob bool, req dto.SnapshotCreate,
 				_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
 				return
 			}
-			snapPanelData(itemHelper, localDir, backupPanelDir)
+			if snapStatus.PanelData != constant.StatusDone {
+				snapPanelData(itemHelper, localDir, backupPanelDir)
+			}
 			if snapStatus.PanelData != constant.StatusDone {
 				_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
 				return
 			}
-			snapCompress(itemHelper, rootDir)
+			if snapStatus.Compress != constant.StatusDone {
+				snapCompress(itemHelper, rootDir)
+			}
 			if snapStatus.Compress != constant.StatusDone {
 				_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
 				return
 			}
-			snapUpload(itemHelper, req.From, fmt.Sprintf("%s.tar.gz", rootDir))
+			if snapStatus.Upload != constant.StatusDone {
+				snapUpload(itemHelper, req.From, fmt.Sprintf("%s.tar.gz", rootDir))
+			}
 			if snapStatus.Upload != constant.StatusDone {
 				_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
 				return
 			}
 			_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusSuccess})
 		}()
-		return "", "", nil
+		return "", nil
 	}
 	wg.Wait()
 	if !checkIsAllDone(snap.ID) {
 		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
-		return loadLogByStatus(snapStatus), snap.Name, fmt.Errorf("snapshot %s backup failed", snap.Name)
+		loadLogByStatus(snapStatus, logPath)
+		return snap.Name, fmt.Errorf("snapshot %s backup failed", snap.Name)
 	}
+	loadLogByStatus(snapStatus, logPath)
+	snapPanelData(itemHelper, localDir, backupPanelDir)
+	if snapStatus.PanelData != constant.StatusDone {
+		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
+		loadLogByStatus(snapStatus, logPath)
+		return snap.Name, fmt.Errorf("snapshot %s 1panel data failed", snap.Name)
+	}
+	loadLogByStatus(snapStatus, logPath)
 	snapCompress(itemHelper, rootDir)
 	if snapStatus.Compress != constant.StatusDone {
 		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
-		return loadLogByStatus(snapStatus), snap.Name, fmt.Errorf("snapshot %s compress failed", snap.Name)
+		loadLogByStatus(snapStatus, logPath)
+		return snap.Name, fmt.Errorf("snapshot %s compress failed", snap.Name)
 	}
+	loadLogByStatus(snapStatus, logPath)
 	snapUpload(itemHelper, req.From, fmt.Sprintf("%s.tar.gz", rootDir))
 	if snapStatus.Upload != constant.StatusDone {
 		_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed})
-		return loadLogByStatus(snapStatus), snap.Name, fmt.Errorf("snapshot %s upload failed", snap.Name)
+		loadLogByStatus(snapStatus, logPath)
+		return snap.Name, fmt.Errorf("snapshot %s upload failed", snap.Name)
 	}
 	_ = snapshotRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusSuccess})
-	return loadLogByStatus(snapStatus), snap.Name, nil
-}
-
-func (u *SnapshotService) handleDockerDatas(fileOp files.FileOp, operation string, source, target string) error {
-	switch operation {
-	case "snapshot":
-		if err := handleSnapTar(source, target, "docker_data.tar.gz", ""); err != nil {
-			return fmt.Errorf("backup docker data failed, err: %v", err)
-		}
-	case "recover":
-		if err := handleSnapTar(target, u.OriginalPath, "docker_data.tar.gz", ""); err != nil {
-			return fmt.Errorf("backup docker data failed, err: %v", err)
-		}
-		if err := u.handleUnTar(source+"/docker/docker_data.tar.gz", target); err != nil {
-			return fmt.Errorf("recover docker data failed, err: %v", err)
-		}
-	case "re-recover":
-		if err := u.handleUnTar(source+"/docker/docker_data.tar.gz", target); err != nil {
-			return fmt.Errorf("re-recover docker data failed, err: %v", err)
-		}
-	case "rollback":
-		if err := u.handleUnTar(source+"/docker_data.tar.gz", target); err != nil {
-			return fmt.Errorf("rollback docker data failed, err: %v", err)
-		}
-	}
-	global.LOG.Info("handle docker data dir successful!")
-	return nil
-}
-
-func (u *SnapshotService) handleDockerDatasWithSave(fileOp files.FileOp, operation, source, target string) error {
-	switch operation {
-	case "recover":
-		if err := u.handleDockerDatasWithSave(fileOp, "snapshot", "", u.OriginalPath); err != nil {
-			return fmt.Errorf("backup docker data failed, err: %v", err)
-		}
-		std, err := cmd.Execf("docker load < %s", path.Join(source, "docker/docker_image.tar"))
-		if err != nil {
-			return errors.New(std)
-		}
-	case "re-recover":
-		std, err := cmd.Execf("docker load < %s", path.Join(source, "docker/docker_image.tar"))
-		if err != nil {
-			return errors.New(std)
-		}
-	case "rollback":
-		std, err := cmd.Execf("docker load < %s", path.Join(source, "docker_image.tar"))
-		if err != nil {
-			return errors.New(std)
-		}
-	}
-	global.LOG.Info("handle docker data successful!")
-	return nil
-}
-
-func (u *SnapshotService) handleDaemonJson(fileOp files.FileOp, operation string, source, target string) error {
-	daemonJsonPath := "/etc/docker/daemon.json"
-	if operation == "snapshot" || operation == "recover" {
-		_, err := os.Stat(daemonJsonPath)
-		if os.IsNotExist(err) {
-			global.LOG.Info("no daemon.json in snapshot and system now, nothing happened")
-		}
-		if err == nil {
-			if err := fileOp.CopyFile(daemonJsonPath, target); err != nil {
-				return fmt.Errorf("backup docker daemon.json failed, err: %v", err)
-			}
-		}
-	}
-	if operation == "recover" || operation == "rollback" || operation == "re-recover" {
-		_, sourceErr := os.Stat(source)
-		if os.IsNotExist(sourceErr) {
-			_ = os.Remove(daemonJsonPath)
-		}
-		if sourceErr == nil {
-			if err := fileOp.CopyFile(source, "/etc/docker"); err != nil {
-				return fmt.Errorf("recover docker daemon.json failed, err: %v", err)
-			}
-		}
-	}
-	global.LOG.Info("handle docker daemon.json successful!")
-	return nil
-}
-
-func (u *SnapshotService) handlePanelBinary(fileOp files.FileOp, operation string, source, target string) error {
-	panelPath := "/usr/local/bin/1panel"
-	if operation == "snapshot" || operation == "recover" {
-		if _, err := os.Stat(panelPath); err != nil {
-			return fmt.Errorf("1panel binary is not found in %s, err: %v", panelPath, err)
-		} else {
-			if err := cpBinary([]string{panelPath}, target); err != nil {
-				return fmt.Errorf("backup 1panel binary failed, err: %v", err)
-			}
-		}
-	}
-	if operation == "recover" || operation == "rollback" || operation == "re-recover" {
-		if _, err := os.Stat(source); err != nil {
-			return fmt.Errorf("1panel binary is not found in snapshot, err: %v", err)
-		} else {
-			if err := cpBinary([]string{source}, "/usr/local/bin/1panel"); err != nil {
-				return fmt.Errorf("recover 1panel binary failed, err: %v", err)
-			}
-		}
-	}
-	global.LOG.Info("handle binary panel successful!")
-	return nil
-}
-
-func (u *SnapshotService) handlePanelctlBinary(fileOp files.FileOp, operation string, source, target string) error {
-	panelctlPath := "/usr/local/bin/1pctl"
-	if operation == "snapshot" || operation == "recover" {
-		if _, err := os.Stat(panelctlPath); err != nil {
-			return fmt.Errorf("1pctl binary is not found in %s, err: %v", panelctlPath, err)
-		} else {
-			if err := cpBinary([]string{panelctlPath}, target); err != nil {
-				return fmt.Errorf("backup 1pctl binary failed, err: %v", err)
-			}
-		}
-	}
-	if operation == "recover" || operation == "rollback" || operation == "re-recover" {
-		if _, err := os.Stat(source); err != nil {
-			return fmt.Errorf("1pctl binary is not found in snapshot, err: %v", err)
-		} else {
-			if err := cpBinary([]string{source}, "/usr/local/bin/1pctl"); err != nil {
-				return fmt.Errorf("recover 1pctl binary failed, err: %v", err)
-			}
-		}
-	}
-	global.LOG.Info("handle binary 1pactl successful!")
-	return nil
-}
-
-func (u *SnapshotService) handlePanelService(fileOp files.FileOp, operation string, source, target string) error {
-	panelServicePath := "/etc/systemd/system/1panel.service"
-	if operation == "snapshot" || operation == "recover" {
-		if _, err := os.Stat(panelServicePath); err != nil {
-			return fmt.Errorf("1panel service is not found in %s, err: %v", panelServicePath, err)
-		} else {
-			if err := cpBinary([]string{panelServicePath}, target); err != nil {
-				return fmt.Errorf("backup 1panel service failed, err: %v", err)
-			}
-		}
-	}
-	if operation == "recover" || operation == "rollback" || operation == "re-recover" {
-		if _, err := os.Stat(source); err != nil {
-			return fmt.Errorf("1panel service is not found in snapshot, err: %v", err)
-		} else {
-			if err := cpBinary([]string{source}, "/etc/systemd/system/1panel.service"); err != nil {
-				return fmt.Errorf("recover 1panel service failed, err: %v", err)
-			}
-		}
-	}
-	global.LOG.Info("handle panel service successful!")
-	return nil
-}
-
-func (u *SnapshotService) handleBackupDatas(fileOp files.FileOp, operation string, source, target string) error {
-	switch operation {
-	case "recover":
-		if err := handleSnapTar(target, u.OriginalPath, "1panel_backup.tar.gz", "./system;"); err != nil {
-			return fmt.Errorf("restore original local backup dir data failed, err: %v", err)
-		}
-		if err := u.handleUnTar(source+"/1panel/1panel_backup.tar.gz", target); err != nil {
-			return fmt.Errorf("recover local backup dir data failed, err: %v", err)
-		}
-	case "re-recover":
-		if err := u.handleUnTar(source+"/1panel/1panel_backup.tar.gz", target); err != nil {
-			return fmt.Errorf("retry recover  local backup dir data failed, err: %v", err)
-		}
-	case "rollback":
-		if err := u.handleUnTar(source+"/1panel_backup.tar.gz", target); err != nil {
-			return fmt.Errorf("rollback local backup dir data failed, err: %v", err)
-		}
-	}
-	global.LOG.Info("handle backup data successful!")
-	return nil
-}
-
-func (u *SnapshotService) handlePanelDatas(snapID uint, fileOp files.FileOp, operation string, source, target, backupDir, dockerDir string) error {
-	switch operation {
-	case "snapshot":
-		exclusionRules := "./tmp;./log;./cache;"
-		if strings.Contains(backupDir, source) {
-			exclusionRules += ("." + strings.ReplaceAll(backupDir, source, "") + ";")
-		}
-		if strings.Contains(dockerDir, source) {
-			exclusionRules += ("." + strings.ReplaceAll(dockerDir, source, "") + ";")
-		}
-
-		if err := handleSnapTar(source, target, "1panel_data.tar.gz", exclusionRules); err != nil {
-			return fmt.Errorf("backup panel data failed, err: %v", err)
-		}
-	case "recover":
-		exclusionRules := "./tmp;./log;./cache;./db/1Panel.db-*;"
-		if strings.Contains(backupDir, target) {
-			exclusionRules += ("." + strings.ReplaceAll(backupDir, target, "") + ";")
-		}
-		if strings.Contains(dockerDir, target) {
-			exclusionRules += ("." + strings.ReplaceAll(dockerDir, target, "") + ";")
-		}
-
-		_ = snapshotRepo.Update(snapID, map[string]interface{}{"recover_status": ""})
-		checkPointOfWal()
-		if err := handleSnapTar(target, u.OriginalPath, "1panel_data.tar.gz", exclusionRules); err != nil {
-			return fmt.Errorf("restore original panel data failed, err: %v", err)
-		}
-		_ = snapshotRepo.Update(snapID, map[string]interface{}{"recover_status": constant.StatusWaiting})
-
-		_ = fileOp.Fs.RemoveAll(path.Join(target, "apps"))
-		checkPointOfWal()
-		if err := u.handleUnTar(source+"/1panel/1panel_data.tar.gz", target); err != nil {
-			return fmt.Errorf("recover panel data failed, err: %v", err)
-		}
-	case "re-recover":
-		_ = fileOp.Fs.RemoveAll(path.Join(target, "apps"))
-		checkPointOfWal()
-		if err := u.handleUnTar(source+"/1panel/1panel_data.tar.gz", target); err != nil {
-			return fmt.Errorf("retry recover panel data failed, err: %v", err)
-		}
-	case "rollback":
-		_ = fileOp.Fs.RemoveAll(path.Join(target, "apps"))
-		checkPointOfWal()
-		if err := u.handleUnTar(source+"/1panel_data.tar.gz", target); err != nil {
-			return fmt.Errorf("rollback panel data failed, err: %v", err)
-		}
-	}
-	return nil
-}
-
-func (u *SnapshotService) loadDockerDataDir() (string, bool, error) {
-	client, err := docker.NewDockerClient()
-	if err != nil {
-		return "", false, fmt.Errorf("new docker client failed, err: %v", err)
-	}
-	info, err := client.Info(context.Background())
-	if err != nil {
-		return "", false, fmt.Errorf("load docker info failed, err: %v", err)
-	}
-	return info.DockerRootDir, info.LiveRestoreEnabled, nil
+	loadLogByStatus(snapStatus, logPath)
+	return snap.Name, nil
 }
 
 func (u *SnapshotService) Delete(req dto.BatchDeleteReq) error {
@@ -848,21 +345,22 @@ func (u *SnapshotService) Delete(req dto.BatchDeleteReq) error {
 	return nil
 }
 
-func updateRecoverStatus(id uint, interruptStep, status string, message string) {
-	if status != constant.StatusSuccess {
-		global.LOG.Errorf("recover failed, err: %s", message)
+func updateRecoverStatus(id uint, isRecover bool, interruptStep, status, message string) {
+	if isRecover {
+		if status != constant.StatusSuccess {
+			global.LOG.Errorf("recover failed, err: %s", message)
+		}
+		if err := snapshotRepo.Update(id, map[string]interface{}{
+			"interrupt_step":    interruptStep,
+			"recover_status":    status,
+			"recover_message":   message,
+			"last_recovered_at": time.Now().Format("2006-01-02 15:04:05"),
+		}); err != nil {
+			global.LOG.Errorf("update snap recover status failed, err: %v", err)
+		}
+		_ = settingRepo.Update("SystemStatus", "Free")
+		return
 	}
-	if err := snapshotRepo.Update(id, map[string]interface{}{
-		"interrupt_step":    interruptStep,
-		"recover_status":    status,
-		"recover_message":   message,
-		"last_recovered_at": time.Now().Format("2006-01-02 15:04:05"),
-	}); err != nil {
-		global.LOG.Errorf("update snap recover status failed, err: %v", err)
-	}
-	_ = settingRepo.Update("SystemStatus", "Free")
-}
-func updateRollbackStatus(id uint, status string, message string) {
 	_ = settingRepo.Update("SystemStatus", "Free")
 	if status == constant.StatusSuccess {
 		if err := snapshotRepo.Update(id, map[string]interface{}{
@@ -896,53 +394,6 @@ func cpBinary(src []string, dst string) error {
 	return nil
 }
 
-func (u *SnapshotService) updateLiveRestore(enabled bool) error {
-	if _, err := os.Stat(constant.DaemonJsonPath); err != nil {
-		return fmt.Errorf("load docker daemon.json conf failed, err: %v", err)
-	}
-	file, err := os.ReadFile(constant.DaemonJsonPath)
-	if err != nil {
-		return err
-	}
-	daemonMap := make(map[string]interface{})
-	_ = json.Unmarshal(file, &daemonMap)
-
-	if !enabled {
-		delete(daemonMap, "live-restore")
-	} else {
-		daemonMap["live-restore"] = enabled
-	}
-	newJson, err := json.MarshalIndent(daemonMap, "", "\t")
-	if err != nil {
-		return err
-	}
-	if err := os.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
-		return err
-	}
-
-	stdout, err := cmd.Exec("systemctl restart docker")
-	if err != nil {
-		return errors.New(stdout)
-	}
-
-	ticker := time.NewTicker(3 * time.Second)
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
-	defer cancel()
-	for range ticker.C {
-		select {
-		case <-ctx.Done():
-			return errors.New("the docker service cannot be restarted")
-		default:
-			stdout, err := cmd.Exec("systemctl is-active docker")
-			if string(stdout) == "active\n" && err == nil {
-				global.LOG.Info("docker restart with new live-restore successful!")
-				return nil
-			}
-		}
-	}
-	return nil
-}
-
 func (u *SnapshotService) handleUnTar(sourceDir, targetDir string) error {
 	if _, err := os.Stat(targetDir); err != nil && os.IsNotExist(err) {
 		if err = os.MkdirAll(targetDir, os.ModePerm); err != nil {
@@ -995,67 +446,35 @@ func rebuildAllAppInstall() error {
 	return nil
 }
 
-func isNewSnapVersion(version string) bool {
-	versionItem := "v1.5.0"
-	if version == versionItem {
-		return true
-	}
-	version1s := strings.Split(version, ".")
-	version2s := strings.Split(versionItem, ".")
-
-	n := min(len(version1s), len(version2s))
-	re := regexp.MustCompile("[0-9]+")
-	for i := 0; i < n; i++ {
-		sVersion1s := re.FindAllString(version1s[i], -1)
-		sVersion2s := re.FindAllString(version2s[i], -1)
-		if len(sVersion1s) == 0 {
-			return false
-		}
-		if len(sVersion2s) == 0 {
-			return false
-		}
-		v1num, _ := strconv.Atoi(sVersion1s[0])
-		v2num, _ := strconv.Atoi(sVersion2s[0])
-		if v1num == v2num {
-			continue
-		} else {
-			return v1num > v2num
-		}
-	}
-	return true
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
 func checkIsAllDone(snapID uint) bool {
 	status, err := snapshotRepo.GetStatus(snapID)
 	if err != nil {
 		return false
 	}
-	if status.Panel != constant.StatusDone {
-		return false
-	}
-	if status.PanelInfo != constant.StatusDone {
-		return false
-	}
-	if status.DaemonJson != constant.StatusDone {
-		return false
-	}
-	if status.AppData != constant.StatusDone {
-		return false
-	}
-	if status.BackupData != constant.StatusDone {
-		return false
-	}
-	return true
+	isOK, _ := checkAllDone(status)
+	return isOK
 }
 
-func loadLogByStatus(status model.SnapshotStatus) string {
+func checkAllDone(status model.SnapshotStatus) (bool, string) {
+	if status.Panel != constant.StatusDone {
+		return false, status.Panel
+	}
+	if status.PanelInfo != constant.StatusDone {
+		return false, status.PanelInfo
+	}
+	if status.DaemonJson != constant.StatusDone {
+		return false, status.DaemonJson
+	}
+	if status.AppData != constant.StatusDone {
+		return false, status.AppData
+	}
+	if status.BackupData != constant.StatusDone {
+		return false, status.BackupData
+	}
+	return true, ""
+}
+
+func loadLogByStatus(status model.SnapshotStatus, logPath string) {
 	logs := ""
 	logs += fmt.Sprintf("Write 1Panel basic information: %s \n", status.PanelInfo)
 	logs += fmt.Sprintf("Backup 1Panel system files: %s \n", status.Panel)
@@ -1067,5 +486,30 @@ func loadLogByStatus(status model.SnapshotStatus) string {
 	logs += fmt.Sprintf("Snapshot size: %s \n", status.Size)
 	logs += fmt.Sprintf("Upload snapshot file: %s \n", status.Upload)
 
-	return logs
+	file, err := os.OpenFile(logPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+	_, _ = file.Write([]byte(logs))
+}
+
+func hasOs(name string) bool {
+	return strings.Contains(name, "amd64") ||
+		strings.Contains(name, "arm64") ||
+		strings.Contains(name, "armv7") ||
+		strings.Contains(name, "ppc64le") ||
+		strings.Contains(name, "s390x")
+}
+
+func loadOs() string {
+	hostInfo, _ := host.Info()
+	switch hostInfo.KernelArch {
+	case "x86_64":
+		return "amd64"
+	case "armv7l":
+		return "armv7"
+	default:
+		return hostInfo.KernelArch
+	}
 }

backend/app/service/snapshot_create.go

@@ -97,21 +97,23 @@ func snapAppData(snap snapHelper, targetDir string) {
 			}
 		}
 	}
-	for _, rumtime := range runtimes {
+	for _, runtime := range runtimes {
 		for _, existImage := range existImages {
-			if rumtime.Image == existImage && !duplicateMap[rumtime.Image] {
-				imageSaveList = append(imageSaveList, rumtime.Image)
-				duplicateMap[rumtime.Image] = true
+			if runtime.Image == existImage && !duplicateMap[runtime.Image] {
+				imageSaveList = append(imageSaveList, runtime.Image)
+				duplicateMap[runtime.Image] = true
 			}
 		}
 	}
 
-	global.LOG.Debugf("docker save %s | gzip -c > %s", strings.Join(imageSaveList, " "), path.Join(targetDir, "docker_image.tar"))
-	std, err := cmd.Execf("docker save %s | gzip -c > %s", strings.Join(imageSaveList, " "), path.Join(targetDir, "docker_image.tar"))
-	if err != nil {
-		snap.Status.AppData = err.Error()
-		_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"app_data": std})
-		return
+	if len(imageSaveList) != 0 {
+		global.LOG.Debugf("docker save %s | gzip -c > %s", strings.Join(imageSaveList, " "), path.Join(targetDir, "docker_image.tar"))
+		std, err := cmd.Execf("docker save %s | gzip -c > %s", strings.Join(imageSaveList, " "), path.Join(targetDir, "docker_image.tar"))
+		if err != nil {
+			snap.Status.AppData = err.Error()
+			_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"app_data": std})
+			return
+		}
 	}
 	snap.Status.AppData = constant.StatusDone
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"app_data": constant.StatusDone})
@@ -121,7 +123,7 @@ func snapBackup(snap snapHelper, localDir, targetDir string) {
 	defer snap.Wg.Done()
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"backup_data": constant.Running})
 	status := constant.StatusDone
-	if err := handleSnapTar(localDir, targetDir, "1panel_backup.tar.gz", "./system;"); err != nil {
+	if err := handleSnapTar(localDir, targetDir, "1panel_backup.tar.gz", "./system;./system_snapshot;"); err != nil {
 		status = err.Error()
 	}
 	snap.Status.BackupData = status
@@ -136,8 +138,17 @@ func snapPanelData(snap snapHelper, localDir, targetDir string) {
 	if strings.Contains(localDir, dataDir) {
 		exclusionRules += ("." + strings.ReplaceAll(localDir, dataDir, "") + ";")
 	}
-
+	ignoreVal, _ := settingRepo.Get(settingRepo.WithByKey("SnapshotIgnore"))
+	rules := strings.Split(ignoreVal.Value, ",")
+	for _, ignore := range rules {
+		if len(ignore) == 0 || cmd.CheckIllegal(ignore) {
+			continue
+		}
+		exclusionRules += ("." + strings.ReplaceAll(ignore, dataDir, "") + ";")
+	}
 	_ = snapshotRepo.Update(snap.SnapID, map[string]interface{}{"status": "OnSaveData"})
+	sysIP, _ := settingRepo.Get(settingRepo.WithByKey("SystemIP"))
+	_ = settingRepo.Update("SystemIP", "")
 	checkPointOfWal()
 	if err := handleSnapTar(dataDir, targetDir, "1panel_data.tar.gz", exclusionRules); err != nil {
 		status = err.Error()
@@ -146,13 +157,10 @@ func snapPanelData(snap snapHelper, localDir, targetDir string) {
 
 	snap.Status.PanelData = status
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"panel_data": status})
+	_ = settingRepo.Update("SystemIP", sysIP.Value)
 }
 
 func snapCompress(snap snapHelper, rootDir string) {
-	defer func() {
-		global.LOG.Debugf("remove snapshot file %s", rootDir)
-		_ = os.RemoveAll(rootDir)
-	}()
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"compress": constant.StatusRunning})
 	tmpDir := path.Join(global.CONF.System.TmpDir, "system")
 	fileName := fmt.Sprintf("%s.tar.gz", path.Base(rootDir))
@@ -173,37 +181,36 @@ func snapCompress(snap snapHelper, rootDir string) {
 	snap.Status.Compress = constant.StatusDone
 	snap.Status.Size = size
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"compress": constant.StatusDone, "size": size})
+
+	global.LOG.Debugf("remove snapshot file %s", rootDir)
+	_ = os.RemoveAll(rootDir)
 }
 
-func snapUpload(snap snapHelper, account string, file string) {
+func snapUpload(snap snapHelper, accounts string, file string) {
 	source := path.Join(global.CONF.System.TmpDir, "system", path.Base(file))
-	defer func() {
-		global.LOG.Debugf("remove snapshot file %s", source)
-		_ = os.Remove(source)
-	}()
-
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": constant.StatusUploading})
-	backup, err := backupRepo.Get(commonRepo.WithByType(account))
+	accountMap, err := loadClientMap(accounts)
 	if err != nil {
 		snap.Status.Upload = err.Error()
 		_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": err.Error()})
 		return
 	}
-	client, err := NewIBackupService().NewClient(&backup)
-	if err != nil {
-		snap.Status.Upload = err.Error()
-		_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": err.Error()})
-		return
-	}
-	target := path.Join(strings.TrimPrefix(backup.BackupPath, "/"), "system_snapshot", path.Base(file))
-	global.LOG.Debugf("start upload snapshot to %s, dir: %s", backup.Type, target)
-	if _, err := client.Upload(source, target); err != nil {
-		snap.Status.Upload = err.Error()
-		_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": err.Error()})
-		return
+	targetAccounts := strings.Split(accounts, ",")
+	for _, item := range targetAccounts {
+		global.LOG.Debugf("start upload snapshot to %s, path: %s", item, path.Join(accountMap[item].backupPath, "system_snapshot", path.Base(file)))
+		if _, err := accountMap[item].client.Upload(source, path.Join(accountMap[item].backupPath, "system_snapshot", path.Base(file))); err != nil {
+			global.LOG.Debugf("upload to %s failed, err: %v", item, err)
+			snap.Status.Upload = err.Error()
+			_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": err.Error()})
+			return
+		}
+		global.LOG.Debugf("upload to %s successful", item)
 	}
 	snap.Status.Upload = constant.StatusDone
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"upload": constant.StatusDone})
+
+	global.LOG.Debugf("remove snapshot file %s", source)
+	_ = os.Remove(source)
 }
 
 func handleSnapTar(sourceDir, targetDir, name, exclusionRules string) error {
@@ -213,6 +220,7 @@ func handleSnapTar(sourceDir, targetDir, name, exclusionRules string) error {
 		}
 	}
 
+	exMap := make(map[string]struct{})
 	exStr := ""
 	excludes := strings.Split(exclusionRules, ";")
 	excludes = append(excludes, "*.sock")
@@ -220,8 +228,12 @@ func handleSnapTar(sourceDir, targetDir, name, exclusionRules string) error {
 		if len(exclude) == 0 {
 			continue
 		}
+		if _, ok := exMap[exclude]; ok {
+			continue
+		}
 		exStr += " --exclude "
 		exStr += exclude
+		exMap[exclude] = struct{}{}
 	}
 
 	commands := fmt.Sprintf("tar --warning=no-file-changed --ignore-failed-read -zcf %s %s -C %s .", targetDir+"/"+name, exStr, sourceDir)

backend/app/service/snapshot_recover.go

@@ -0,0 +1,263 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+	"sync"
+
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
+	"github.com/pkg/errors"
+)
+
+func (u *SnapshotService) HandleSnapshotRecover(snap model.Snapshot, isRecover bool, req dto.SnapshotRecover) {
+	_ = global.Cron.Stop()
+	defer func() {
+		global.Cron.Start()
+	}()
+
+	snapFileDir := ""
+	if isRecover {
+		baseDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("system/%s", snap.Name))
+		if _, err := os.Stat(baseDir); err != nil && os.IsNotExist(err) {
+			_ = os.MkdirAll(baseDir, os.ModePerm)
+		}
+		if req.IsNew || snap.InterruptStep == "Backup" {
+			if err := backupBeforeRecover(snap); err != nil {
+				updateRecoverStatus(snap.ID, isRecover, "Backup", constant.StatusFailed, fmt.Sprintf("handle backup before recover failed, err: %v", err))
+				return
+			}
+			global.LOG.Debug("handle backup before recover successful!")
+			req.IsNew = true
+		}
+		if req.IsNew || snap.InterruptStep == "Download" || req.ReDownload {
+			if err := handleDownloadSnapshot(snap, baseDir); err != nil {
+				updateRecoverStatus(snap.ID, isRecover, "Backup", constant.StatusFailed, err.Error())
+				return
+			}
+			global.LOG.Debugf("download snapshot file to %s successful!", baseDir)
+			req.IsNew = true
+		}
+		if req.IsNew || snap.InterruptStep == "Decompress" {
+			if err := handleUnTar(fmt.Sprintf("%s/%s.tar.gz", baseDir, snap.Name), baseDir); err != nil {
+				updateRecoverStatus(snap.ID, isRecover, "Decompress", constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
+				return
+			}
+			global.LOG.Debug("decompress snapshot file successful!", baseDir)
+			req.IsNew = true
+		}
+		snapFileDir = fmt.Sprintf("%s/%s", baseDir, snap.Name)
+	} else {
+		snapFileDir = fmt.Sprintf("%s/1panel_original/original_%s", global.CONF.System.BaseDir, snap.Name)
+		if _, err := os.Stat(snapFileDir); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "", constant.StatusFailed, fmt.Sprintf("cannot find the backup file %s, please try to recover again.", snapFileDir))
+			return
+		}
+	}
+	snapJson, err := u.readFromJson(fmt.Sprintf("%s/snapshot.json", snapFileDir))
+	if err != nil {
+		updateRecoverStatus(snap.ID, isRecover, "Readjson", constant.StatusFailed, fmt.Sprintf("decompress file failed, err: %v", err))
+		return
+	}
+	if snap.InterruptStep == "Readjson" {
+		req.IsNew = true
+	}
+	if req.IsNew || snap.InterruptStep == "AppData" {
+		if err := recoverAppData(snapFileDir); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "DockerDir", constant.StatusFailed, fmt.Sprintf("handle recover app data failed, err: %v", err))
+			return
+		}
+		global.LOG.Debug("recover app data from snapshot file successful!")
+		req.IsNew = true
+	}
+	if req.IsNew || snap.InterruptStep == "DaemonJson" {
+		fileOp := files.NewFileOp()
+		if err := recoverDaemonJson(snapFileDir, fileOp); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "DaemonJson", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover daemon.json from snapshot file successful!")
+		req.IsNew = true
+	}
+
+	if req.IsNew || snap.InterruptStep == "1PanelBinary" {
+		if err := recoverPanel(path.Join(snapFileDir, "1panel/1panel"), "/usr/local/bin/1panel"); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "1PanelBinary", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover 1panel binary from snapshot file successful!")
+		req.IsNew = true
+	}
+	if req.IsNew || snap.InterruptStep == "1PctlBinary" {
+		if err := recoverPanel(path.Join(snapFileDir, "1panel/1pctl"), "/usr/local/bin/1pctl"); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "1PctlBinary", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover 1pctl from snapshot file successful!")
+		req.IsNew = true
+	}
+	if req.IsNew || snap.InterruptStep == "1PanelService" {
+		if err := recoverPanel(path.Join(snapFileDir, "1panel/1panel.service"), "/etc/systemd/system/1panel.service"); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "1PanelService", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover 1panel service from snapshot file successful!")
+		req.IsNew = true
+	}
+
+	if req.IsNew || snap.InterruptStep == "1PanelBackups" {
+		if err := u.handleUnTar(path.Join(snapFileDir, "/1panel/1panel_backup.tar.gz"), snapJson.BackupDataDir); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "1PanelBackups", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover 1panel backups from snapshot file successful!")
+		req.IsNew = true
+	}
+
+	if req.IsNew || snap.InterruptStep == "1PanelData" {
+		checkPointOfWal()
+		if err := u.handleUnTar(path.Join(snapFileDir, "/1panel/1panel_data.tar.gz"), path.Join(snapJson.BaseDir, "1panel")); err != nil {
+			updateRecoverStatus(snap.ID, isRecover, "1PanelData", constant.StatusFailed, err.Error())
+			return
+		}
+		global.LOG.Debug("recover 1panel data from snapshot file successful!")
+		req.IsNew = true
+	}
+	_ = rebuildAllAppInstall()
+	restartCompose(path.Join(snapJson.BaseDir, "1panel/docker/compose"))
+
+	global.LOG.Info("recover successful")
+	if !isRecover {
+		oriPath := fmt.Sprintf("%s/1panel_original/original_%s", global.CONF.System.BaseDir, snap.Name)
+		global.LOG.Debugf("remove the file %s after the operation is successful", oriPath)
+		_ = os.RemoveAll(oriPath)
+	} else {
+		global.LOG.Debugf("remove the file %s after the operation is successful", path.Dir(snapFileDir))
+		_ = os.RemoveAll(path.Dir(snapFileDir))
+	}
+	_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
+}
+
+func backupBeforeRecover(snap model.Snapshot) error {
+	baseDir := fmt.Sprintf("%s/1panel_original/original_%s", global.CONF.System.BaseDir, snap.Name)
+	var wg sync.WaitGroup
+	var status model.SnapshotStatus
+	itemHelper := snapHelper{SnapID: 0, Status: &status, Wg: &wg, FileOp: files.NewFileOp(), Ctx: context.Background()}
+
+	jsonItem := SnapshotJson{
+		BaseDir:       global.CONF.System.BaseDir,
+		BackupDataDir: global.CONF.System.Backup,
+		PanelDataDir:  path.Join(global.CONF.System.BaseDir, "1panel"),
+	}
+	_ = os.MkdirAll(path.Join(baseDir, "1panel"), os.ModePerm)
+	_ = os.MkdirAll(path.Join(baseDir, "docker"), os.ModePerm)
+
+	wg.Add(5)
+	itemHelper.Wg = &wg
+	go snapJson(itemHelper, jsonItem, baseDir)
+	go snapPanel(itemHelper, path.Join(baseDir, "1panel"))
+	go snapDaemonJson(itemHelper, path.Join(baseDir, "docker"))
+	go snapAppData(itemHelper, path.Join(baseDir, "docker"))
+	go snapBackup(itemHelper, global.CONF.System.Backup, path.Join(baseDir, "1panel"))
+	wg.Wait()
+
+	allDone, msg := checkAllDone(status)
+	if !allDone {
+		return errors.New(msg)
+	}
+	snapPanelData(itemHelper, global.CONF.System.BaseDir, path.Join(baseDir, "1panel"))
+	if status.PanelData != constant.StatusDone {
+		return errors.New(status.PanelData)
+	}
+	return nil
+}
+
+func handleDownloadSnapshot(snap model.Snapshot, targetDir string) error {
+	backup, err := backupRepo.Get(commonRepo.WithByType(snap.DefaultDownload))
+	if err != nil {
+		return err
+	}
+	client, err := NewIBackupService().NewClient(&backup)
+	if err != nil {
+		return err
+	}
+	pathItem := backup.BackupPath
+	if backup.BackupPath != "/" {
+		pathItem = strings.TrimPrefix(backup.BackupPath, "/")
+	}
+	filePath := fmt.Sprintf("%s/%s.tar.gz", targetDir, snap.Name)
+	_ = os.RemoveAll(filePath)
+	ok, err := client.Download(path.Join(pathItem, fmt.Sprintf("system_snapshot/%s.tar.gz", snap.Name)), filePath)
+	if err != nil || !ok {
+		return fmt.Errorf("download file %s from %s failed, err: %v", snap.Name, backup.Type, err)
+	}
+	return nil
+}
+
+func recoverAppData(src string) error {
+	if _, err := os.Stat(path.Join(src, "docker/docker_image.tar")); err != nil {
+		global.LOG.Debug("no such docker images in snapshot")
+		return nil
+	}
+	std, err := cmd.Execf("docker load < %s", path.Join(src, "docker/docker_image.tar"))
+	if err != nil {
+		return errors.New(std)
+	}
+	return err
+}
+
+func recoverDaemonJson(src string, fileOp files.FileOp) error {
+	daemonJsonPath := "/etc/docker/daemon.json"
+	_, errSrc := os.Stat(path.Join(src, "docker/daemon.json"))
+	_, errPath := os.Stat(daemonJsonPath)
+	if os.IsNotExist(errSrc) && os.IsNotExist(errPath) {
+		global.LOG.Debug("the daemon.json file does not exist, nothing happens.")
+		return nil
+	}
+	if errSrc == nil {
+		if err := fileOp.CopyFile(path.Join(src, "docker/daemon.json"), "/etc/docker"); err != nil {
+			return fmt.Errorf("recover docker daemon.json failed, err: %v", err)
+		}
+	}
+
+	_, _ = cmd.Exec("systemctl restart docker")
+	return nil
+}
+
+func recoverPanel(src string, dst string) error {
+	if _, err := os.Stat(src); err != nil {
+		return fmt.Errorf("file is not found in %s, err: %v", src, err)
+	}
+	global.LOG.Debugf(fmt.Sprintf("\\cp -f %s %s", src, dst))
+	stdout, err := cmd.Exec(fmt.Sprintf("\\cp -f %s %s", src, dst))
+	if err != nil {
+		return fmt.Errorf("cp file failed, stdout: %v, err: %v", stdout, err)
+	}
+	return nil
+}
+
+func restartCompose(composePath string) {
+	composes, err := composeRepo.ListRecord()
+	if err != nil {
+		return
+	}
+	for _, compose := range composes {
+		pathItem := path.Join(composePath, compose.Name, "docker-compose.yml")
+		if _, err := os.Stat(pathItem); err != nil {
+			continue
+		}
+		upCmd := fmt.Sprintf("docker-compose -f %s up -d", pathItem)
+		stdout, err := cmd.Exec(upCmd)
+		if err != nil {
+			global.LOG.Debugf("%s failed, err: %v", upCmd, stdout)
+		}
+	}
+	global.LOG.Debug("restart all compose successful!")
+}

backend/app/service/ssh.go

@@ -104,7 +104,7 @@ func (u *SSHService) GetSSHInfo() (*dto.SSHInfo, error) {
 			data.PubkeyAuthentication = strings.ReplaceAll(line, "PubkeyAuthentication ", "")
 		}
 		if strings.HasPrefix(line, "PermitRootLogin ") {
-			data.PermitRootLogin = strings.ReplaceAll(line, "PermitRootLogin ", "")
+			data.PermitRootLogin = strings.ReplaceAll(strings.ReplaceAll(line, "PermitRootLogin ", ""), "prohibit-password", "without-password")
 		}
 		if strings.HasPrefix(line, "UseDNS ") {
 			data.UseDNS = strings.ReplaceAll(line, "UseDNS ", "")
@@ -177,7 +177,11 @@ func (u *SSHService) Update(req dto.SSHUpdate) error {
 			},
 		}
 		if err := NewIFirewallService().UpdatePortRule(ruleItem); err != nil {
-			global.LOG.Errorf("reset firewall rules %s -> %s failed, err: %v", req.OldValue, req.OldValue, err)
+			global.LOG.Errorf("reset firewall rules %s -> %s failed, err: %v", req.OldValue, req.NewValue, err)
+		}
+
+		if err = NewIHostService().Update(1, map[string]interface{}{"port": req.NewValue}); err != nil {
+			global.LOG.Errorf("reset host port %s -> %s failed, err: %v", req.OldValue, req.NewValue, err)
 		}
 	}
 

backend/app/service/upgrade.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"os"
 	"path"
-	"runtime"
 	"strings"
 	"time"
 
@@ -133,24 +132,24 @@ func (u *UpgradeService) Upgrade(req dto.Upgrade) error {
 
 		if err := cpBinary([]string{tmpDir + "/1panel"}, "/usr/local/bin/1panel"); err != nil {
 			global.LOG.Errorf("upgrade 1panel failed, err: %v", err)
-			u.handleRollback(fileOp, originalDir, 1)
+			u.handleRollback(originalDir, 1)
 			return
 		}
 
 		if err := cpBinary([]string{tmpDir + "/1pctl"}, "/usr/local/bin/1pctl"); err != nil {
 			global.LOG.Errorf("upgrade 1pctl failed, err: %v", err)
-			u.handleRollback(fileOp, originalDir, 2)
+			u.handleRollback(originalDir, 2)
 			return
 		}
 		if _, err := cmd.Execf("sed -i -e 's#BASE_DIR=.*#BASE_DIR=%s#g' /usr/local/bin/1pctl", global.CONF.System.BaseDir); err != nil {
 			global.LOG.Errorf("upgrade basedir in 1pctl failed, err: %v", err)
-			u.handleRollback(fileOp, originalDir, 2)
+			u.handleRollback(originalDir, 2)
 			return
 		}
 
 		if err := cpBinary([]string{tmpDir + "/1panel.service"}, "/etc/systemd/system/1panel.service"); err != nil {
 			global.LOG.Errorf("upgrade 1panel.service failed, err: %v", err)
-			u.handleRollback(fileOp, originalDir, 3)
+			u.handleRollback(originalDir, 3)
 			return
 		}
 
@@ -181,7 +180,7 @@ func (u *UpgradeService) handleBackup(fileOp files.FileOp, originalDir string) e
 	return nil
 }
 
-func (u *UpgradeService) handleRollback(fileOp files.FileOp, originalDir string, errStep int) {
+func (u *UpgradeService) handleRollback(originalDir string, errStep int) {
 	dbPath := global.CONF.System.DbPath + "/1Panel.db"
 	_ = settingRepo.Update("SystemStatus", "Free")
 	if err := cpBinary([]string{originalDir + "/1Panel.db"}, dbPath); err != nil {
@@ -250,19 +249,24 @@ func (u *UpgradeService) loadReleaseNotes(path string) (string, error) {
 }
 
 func loadArch() (string, error) {
-	switch runtime.GOARCH {
-	case "amd64", "ppc64le", "s390x", "arm64":
-		return runtime.GOARCH, nil
-	case "arm":
-		std, err := cmd.Exec("uname -m")
-		if err != nil {
-			return "", fmt.Errorf("std: %s, err: %s", std, err.Error())
-		}
-		if std == "armv7l\n" {
-			return "armv7", nil
-		}
-		return "", fmt.Errorf("unsupport such arch: arm-%s", std)
-	default:
-		return "", fmt.Errorf("unsupport such arch: %s", runtime.GOARCH)
+	std, err := cmd.Exec("uname -a")
+	if err != nil {
+		return "", fmt.Errorf("std: %s, err: %s", std, err.Error())
 	}
+	if strings.Contains(std, "x86_64") {
+		return "amd64", nil
+	}
+	if strings.Contains(std, "arm64") || strings.Contains(std, "aarch64") {
+		return "arm64", nil
+	}
+	if strings.Contains(std, "armv7l") {
+		return "armv7", nil
+	}
+	if strings.Contains(std, "ppc64le") {
+		return "ppc64le", nil
+	}
+	if strings.Contains(std, "s390x") {
+		return "s390x", nil
+	}
+	return "", fmt.Errorf("unsupported such arch: %s", std)
 }

backend/app/service/website.go

@@ -119,7 +119,16 @@ func (w WebsiteService) PageWebsite(req request.WebsiteSearch) (int64, []respons
 	}
 	opts = append(opts, commonRepo.WithOrderRuleBy(req.OrderBy, req.Order))
 	if req.Name != "" {
-		opts = append(opts, websiteRepo.WithDomainLike(req.Name))
+		domains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithDomainLike(req.Name))
+		if len(domains) > 0 {
+			var websiteIds []uint
+			for _, domain := range domains {
+				websiteIds = append(websiteIds, domain.WebsiteID)
+			}
+			opts = append(opts, websiteRepo.WithIDs(websiteIds))
+		} else {
+			opts = append(opts, websiteRepo.WithDomainLike(req.Name))
+		}
 	}
 	if req.WebsiteGroupID != 0 {
 		opts = append(opts, websiteRepo.WithGroupID(req.WebsiteGroupID))
@@ -820,30 +829,27 @@ func (w WebsiteService) PreInstallCheck(req request.WebsiteInstallCheckReq) ([]r
 	} else {
 		checkIds = append(req.InstallIds, appInstall.ID)
 	}
-	for _, id := range checkIds {
-		if err := syncByID(id); err != nil {
-			return nil, err
-		}
-	}
 	if len(checkIds) > 0 {
 		installList, _ := appInstallRepo.ListBy(commonRepo.WithIdsIn(checkIds))
 		for _, install := range installList {
+			if err = syncAppInstallStatus(&install); err != nil {
+				return nil, err
+			}
 			res = append(res, response.WebsitePreInstallCheck{
 				Name:    install.Name,
 				Status:  install.Status,
 				Version: install.Version,
 				AppName: install.App.Name,
 			})
-			if install.Status != constant.StatusRunning {
+			if install.Status != constant.Running {
 				showErr = true
 			}
 		}
 	}
 	if showErr {
 		return res, nil
-	} else {
-		return nil, nil
 	}
+	return nil, nil
 }
 
 func (w WebsiteService) GetWafConfig(req request.WebsiteWafReq) (response.WebsiteWafConfig, error) {
@@ -1511,13 +1517,19 @@ func (w WebsiteService) OperateProxy(req request.WebsiteProxyConfig) (err error)
 
 	switch req.Operate {
 	case "create":
-		config = parser.NewStringParser(string(nginx_conf.Proxy)).Parse()
+		config, err = parser.NewStringParser(string(nginx_conf.Proxy)).Parse()
+		if err != nil {
+			return
+		}
 	case "edit":
 		par, err = parser.NewParser(includePath)
 		if err != nil {
 			return
 		}
-		config = par.Parse()
+		config, err = par.Parse()
+		if err != nil {
+			return
+		}
 		oldContent, err = fileOp.GetContent(includePath)
 		if err != nil {
 			return
@@ -1533,6 +1545,7 @@ func (w WebsiteService) OperateProxy(req request.WebsiteProxyConfig) (err error)
 		_ = fileOp.Rename(backPath, includePath)
 		return updateNginxConfig(constant.NginxScopeServer, nil, &website)
 	}
+
 	config.FilePath = includePath
 	directives := config.Directives
 	location, ok := directives[0].(*components.Location)
@@ -1610,7 +1623,10 @@ func (w WebsiteService) GetProxies(id uint) (res []request.WebsiteProxyConfig, e
 			return
 		}
 		proxyConfig.Content = string(content)
-		config = parser.NewStringParser(string(content)).Parse()
+		config, err = parser.NewStringParser(string(content)).Parse()
+		if err != nil {
+			return nil, err
+		}
 		directives := config.GetDirectives()
 
 		location, ok := directives[0].(*components.Location)
@@ -2057,7 +2073,10 @@ func (w WebsiteService) OperateRedirect(req request.NginxRedirectReq) (err error
 		if err != nil {
 			return
 		}
-		config = oldPar.Parse()
+		config, err = oldPar.Parse()
+		if err != nil {
+			return
+		}
 		oldContent, err = fileOp.GetContent(includePath)
 		if err != nil {
 			return
@@ -2198,7 +2217,10 @@ func (w WebsiteService) GetRedirect(id uint) (res []response.NginxRedirectConfig
 			return
 		}
 		redirectConfig.Content = string(content)
-		config = parser.NewStringParser(string(content)).Parse()
+		config, err = parser.NewStringParser(string(content)).Parse()
+		if err != nil {
+			return
+		}
 
 		dirs := config.GetDirectives()
 		if len(dirs) > 0 {

backend/app/service/website_dns_account.go

@@ -1,13 +1,13 @@
 package service
 
 import (
+	"encoding/json"
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
-	"gopkg.in/square/go-jose.v2/json"
 )
 
 type WebsiteDnsAccountService struct {

backend/app/service/website_utils.go

@@ -2,13 +2,6 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/buserr"
-	"github.com/1Panel-dev/1Panel/backend/global"
-	"github.com/1Panel-dev/1Panel/backend/i18n"
-	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
-	"github.com/1Panel-dev/1Panel/backend/utils/common"
-	"github.com/1Panel-dev/1Panel/backend/utils/nginx/components"
-	"gopkg.in/yaml.v3"
 	"log"
 	"os"
 	"path"
@@ -18,6 +11,14 @@ import (
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/buserr"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/i18n"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
+	"github.com/1Panel-dev/1Panel/backend/utils/nginx/components"
+	"gopkg.in/yaml.v3"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -114,7 +115,7 @@ func createIndexFile(website *model.Website, runtime *model.Runtime) error {
 	return nil
 }
 
-func createProxyFile(website *model.Website, runtime *model.Runtime) error {
+func createProxyFile(website *model.Website) error {
 	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
 	if err != nil {
 		return err
@@ -132,7 +133,10 @@ func createProxyFile(website *model.Website, runtime *model.Runtime) error {
 			return err
 		}
 	}
-	config := parser.NewStringParser(string(nginx_conf.Proxy)).Parse()
+	config, err := parser.NewStringParser(string(nginx_conf.Proxy)).Parse()
+	if err != nil {
+		return err
+	}
 	config.FilePath = filePath
 	directives := config.Directives
 	location, ok := directives[0].(*components.Location)
@@ -188,7 +192,7 @@ func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website,
 			}
 		}
 		if website.Type == constant.Proxy {
-			if err := createProxyFile(website, runtime); err != nil {
+			if err := createProxyFile(website); err != nil {
 				return err
 			}
 		}
@@ -208,7 +212,10 @@ func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain, a
 	nginxFileName := website.Alias + ".conf"
 	configPath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "conf", "conf.d", nginxFileName)
 	nginxContent := string(nginx_conf.WebsiteDefault)
-	config := parser.NewStringParser(nginxContent).Parse()
+	config, err := parser.NewStringParser(nginxContent).Parse()
+	if err != nil {
+		return err
+	}
 	servers := config.FindServers()
 	if len(servers) == 0 {
 		return errors.New("nginx config is not valid")
@@ -301,7 +308,7 @@ func delNginxConfig(website model.Website, force bool) error {
 	if err := fileOp.DeleteFile(configPath); err != nil {
 		return err
 	}
-	sitePath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "www", "sites", website.PrimaryDomain)
+	sitePath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "www", "sites", website.Alias)
 	if fileOp.Stat(sitePath) {
 		_ = fileOp.DeleteDir(sitePath)
 	}
@@ -556,7 +563,15 @@ func opWebsite(website *model.Website, operate string) error {
 		case constant.Deployment:
 			server.RemoveDirective("location", []string{"/"})
 		case constant.Runtime:
-			server.RemoveDirective("location", []string{"~", "[^/]\\.php(/|$)"})
+			runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(website.RuntimeID))
+			if err != nil {
+				return err
+			}
+			if runtime.Type == constant.RuntimePHP {
+				server.RemoveDirective("location", []string{"~", "[^/]\\.php(/|$)"})
+			} else {
+				server.RemoveDirective("location", []string{"/"})
+			}
 		}
 		server.UpdateRoot("/usr/share/nginx/html/stop")
 		website.Status = constant.WebStopped
@@ -594,10 +609,19 @@ func opWebsite(website *model.Website, operate string) error {
 		case constant.Runtime:
 			server.UpdateRoot(rootIndex)
 			localPath := ""
-			if website.ProxyType == constant.RuntimeProxyUnix {
-				localPath = path.Join(nginxInstall.Install.GetPath(), rootIndex, "index.php")
+			runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(website.RuntimeID))
+			if err != nil {
+				return err
+			}
+			if runtime.Type == constant.RuntimePHP {
+				if website.ProxyType == constant.RuntimeProxyUnix {
+					localPath = path.Join(nginxInstall.Install.GetPath(), rootIndex, "index.php")
+				}
+				server.UpdatePHPProxy([]string{website.Proxy}, localPath)
+			} else {
+				proxy := fmt.Sprintf("http://127.0.0.1:%d", runtime.Port)
+				server.UpdateRootProxy([]string{proxy})
 			}
-			server.UpdatePHPProxy([]string{website.Proxy}, localPath)
 		}
 		website.Status = constant.WebRunning
 		now := time.Now()
@@ -855,7 +879,10 @@ func ChangeHSTSConfig(enable bool, nginxInstall model.AppInstall, website model.
 				if err != nil {
 					return err
 				}
-				config := par.Parse()
+				config, err := par.Parse()
+				if err != nil {
+					return err
+				}
 				config.FilePath = path
 				directives := config.Directives
 				location, ok := directives[0].(*components.Location)

backend/constant/app.go

@@ -12,6 +12,7 @@ const (
 	Rebuilding  = "Rebuilding"
 	Syncing     = "Syncing"
 	SyncSuccess = "SyncSuccess"
+	Paused      = "Paused"
 	SyncErr     = "SyncErr"
 
 	ContainerPrefix = "1Panel-"

backend/constant/backup.go

@@ -12,6 +12,7 @@ const (
 	Cos          = "COS"
 	Kodo         = "KODO"
 	WebDAV       = "WebDAV"
+	Local        = "LOCAL"
 
 	OneDriveRedirectURI = "http://localhost/login/authorized"
 )

backend/constant/errs.go

@@ -62,6 +62,7 @@ var (
 	ErrAppNameExist        = "ErrAppNameExist"
 	ErrFileNotFound        = "ErrFileNotFound"
 	ErrFileParseApp        = "ErrFileParseApp"
+	ErrAppParamKey         = "ErrAppParamKey"
 )
 
 // website

backend/cron/cron.go

@@ -44,6 +44,12 @@ func Run() {
 	if _, err := global.Cron.AddJob("@daily", job.NewAppStoreJob()); err != nil {
 		global.LOG.Errorf("can not add  appstore corn job: %s", err.Error())
 	}
+
+	var backup model.BackupAccount
+	_ = global.DB.Where("type = ?", "OneDrive").Find(&backup).Error
+	if backup.ID != 0 {
+		service.StartRefreshOneDriveToken()
+	}
 	global.Cron.Start()
 
 	var cronJobs []model.Cronjob
@@ -60,11 +66,11 @@ func Run() {
 		global.LOG.Errorf("start my cronjob failed, err: %v", err)
 	}
 	for i := 0; i < len(cronJobs); i++ {
-		entryID, err := service.NewICronjobService().StartJob(&cronJobs[i])
+		entryIDs, err := service.NewICronjobService().StartJob(&cronJobs[i])
 		if err != nil {
 			global.LOG.Errorf("start %s job %s failed, err: %v", cronJobs[i].Type, cronJobs[i].Name, err)
 		}
-		if err := repo.NewICronjobRepo().Update(cronJobs[i].ID, map[string]interface{}{"entry_id": entryID}); err != nil {
+		if err := repo.NewICronjobRepo().Update(cronJobs[i].ID, map[string]interface{}{"entry_ids": entryIDs}); err != nil {
 			global.LOG.Errorf("update cronjob %s %s failed, err: %v", cronJobs[i].Type, cronJobs[i].Name, err)
 		}
 	}

backend/global/global.go

@@ -5,6 +5,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/init/cache/badger_db"
 	"github.com/1Panel-dev/1Panel/backend/init/session/psession"
 	"github.com/go-playground/validator/v10"
+	"github.com/nicksnyder/go-i18n/v2/i18n"
 	"github.com/robfig/cron/v3"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
@@ -20,6 +21,9 @@ var (
 	CACHE   *badger_db.Cache
 	Viper   *viper.Viper
 
-	Cron          *cron.Cron
-	MonitorCronID int
+	Cron           *cron.Cron
+	MonitorCronID  cron.EntryID
+	OneDriveCronID cron.EntryID
+
+	I18n *i18n.Localizer
 )

backend/i18n/i18n.go

@@ -2,9 +2,9 @@ package i18n
 
 import (
 	"embed"
+	"github.com/1Panel-dev/1Panel/backend/global"
 	"strings"
 
-	ginI18n "github.com/gin-contrib/i18n"
 	"github.com/gin-gonic/gin"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
 	"golang.org/x/text/language"
@@ -12,13 +12,13 @@ import (
 )
 
 func GetMsgWithMap(key string, maps map[string]interface{}) string {
-	content := ""
+	var content string
 	if maps == nil {
-		content = ginI18n.MustGetMessage(&i18n.LocalizeConfig{
+		content, _ = global.I18n.Localize(&i18n.LocalizeConfig{
 			MessageID: key,
 		})
 	} else {
-		content = ginI18n.MustGetMessage(&i18n.LocalizeConfig{
+		content, _ = global.I18n.Localize(&i18n.LocalizeConfig{
 			MessageID:    key,
 			TemplateData: maps,
 		})
@@ -32,13 +32,13 @@ func GetMsgWithMap(key string, maps map[string]interface{}) string {
 }
 
 func GetErrMsg(key string, maps map[string]interface{}) string {
-	content := ""
+	var content string
 	if maps == nil {
-		content = ginI18n.MustGetMessage(&i18n.LocalizeConfig{
+		content, _ = global.I18n.Localize(&i18n.LocalizeConfig{
 			MessageID: key,
 		})
 	} else {
-		content = ginI18n.MustGetMessage(&i18n.LocalizeConfig{
+		content, _ = global.I18n.Localize(&i18n.LocalizeConfig{
 			MessageID:    key,
 			TemplateData: maps,
 		})
@@ -47,7 +47,7 @@ func GetErrMsg(key string, maps map[string]interface{}) string {
 }
 
 func GetMsgByKey(key string) string {
-	content := ginI18n.MustGetMessage(&i18n.LocalizeConfig{
+	content, _ := global.I18n.Localize(&i18n.LocalizeConfig{
 		MessageID: key,
 	})
 	return content
@@ -55,24 +55,22 @@ func GetMsgByKey(key string) string {
 
 //go:embed lang/*
 var fs embed.FS
+var bundle *i18n.Bundle
 
-func GinI18nLocalize() gin.HandlerFunc {
-	return ginI18n.Localize(
-		ginI18n.WithBundle(&ginI18n.BundleCfg{
-			RootPath:         "./lang",
-			AcceptLanguage:   []language.Tag{language.Chinese, language.English, language.TraditionalChinese},
-			DefaultLanguage:  language.Chinese,
-			FormatBundleFile: "yaml",
-			UnmarshalFunc:    yaml.Unmarshal,
-			Loader:           &ginI18n.EmbedLoader{FS: fs},
-		}),
-		ginI18n.WithGetLngHandle(
-			func(context *gin.Context, defaultLng string) string {
-				lng := context.GetHeader("Accept-Language")
-				if lng == "" {
-					return defaultLng
-				}
-				return lng
-			},
-		))
+func UseI18n() gin.HandlerFunc {
+	return func(context *gin.Context) {
+		lang := context.GetHeader("Accept-Language")
+		if lang == "" {
+			lang = "zh"
+		}
+		global.I18n = i18n.NewLocalizer(bundle, lang)
+	}
+}
+
+func Init() {
+	bundle = i18n.NewBundle(language.Chinese)
+	bundle.RegisterUnmarshalFunc("yaml", yaml.Unmarshal)
+	_, _ = bundle.LoadMessageFileFS(fs, "lang/zh.yaml")
+	_, _ = bundle.LoadMessageFileFS(fs, "lang/en.yaml")
+	_, _ = bundle.LoadMessageFileFS(fs, "lang/zh-Hant.yaml")
 }

backend/i18n/lang/en.yaml

@@ -59,6 +59,8 @@ ErrVersionTooLow: 'The current 1Panel version is too low to update the app store
 ErrAppNameExist: 'App name is already exist'
 AppStoreIsSyncing: 'The App Store is syncing, please try again later'
 ErrGetCompose: "Failed to obtain docker-compose.yml file! {{ .detail }}"
+ErrAppWarn: "Abnormal status, please check the log"
+ErrAppParamKey: "Parameter {{ .name }} field exception"
 
 #file
 ErrFileCanNotRead: "File can not read"
@@ -164,3 +166,9 @@ CutWebsiteLogSuccess: "{{ .name }} website log cut successfully, backup path {{
 #toolbox
 ErrNotExistUser: "The current user does not exist. Please modify and retry!"
 ErrBanAction: "Setting failed, the current {{ .name }} service is unavailable, please check and try again!"
+
+#waf
+ErrScope: "Modification of this configuration is not supported"
+ErrStateChange: "State modification failed"
+ErrRuleExist: "Rule is Exist"
+ErrRuleNotExist: "Rule is not Exist"

backend/i18n/lang/zh-Hant.yaml

@@ -59,6 +59,8 @@ ErrVersionTooLow: '當前 1Panel 版本過低，無法更新應用商店，請
 ErrAppNameExist: '應用名稱已存在'
 AppStoreIsSyncing: '應用程式商店正在同步中，請稍後再試'
 ErrGetCompose: "docker-compose.yml 檔案取得失敗！{{ .detail }}"
+ErrAppWarn: "狀態異常，請查看日誌"
+ErrAppParamKey: "參數 {{ .name }} 欄位異常"
 
 #file
 ErrFileCanNotRead: "此文件不支持預覽"
@@ -165,3 +167,9 @@ CutWebsiteLogSuccess: "{{ .name }} 網站日誌切割成功，備份路徑 {{ .p
 #toolbox
 ErrNotExistUser: "當前使用者不存在，請修改後重試！"
 ErrBanAction: "設置失敗，當前 {{ .name }} 服務不可用，請檢查後重試！"
+
+#waf
+ErrScope: "不支援修改此配置"
+ErrStateChange: "狀態修改失敗"
+ErrRuleExist: "規則名稱已存在"
+ErrRuleNotExist: "規則不存在"

backend/i18n/lang/zh.yaml

@@ -59,6 +59,8 @@ ErrVersionTooLow: '当前 1Panel 版本过低，无法更新应用商店，请
 ErrAppNameExist: '应用名称已存在'
 AppStoreIsSyncing: '应用商店正在同步中，请稍后再试'
 ErrGetCompose: "docker-compose.yml 文件获取失败！{{ .detail }}"
+ErrAppWarn: "状态异常，请查看日志"
+ErrAppParamKey: "参数 {{ .name }} 字段异常"
 
 #file
 ErrFileCanNotRead: "此文件不支持预览"
@@ -163,4 +165,10 @@ CutWebsiteLogSuccess: "{{ .name }} 网站日志切割成功，备份路径 {{ .p
 
 #toolbox
 ErrNotExistUser: "当前用户不存在，请修改后重试！"
-ErrBanAction: "设置失败，当前 {{ .name }} 服务不可用，请检查后重试！"
+ErrBanAction: "设置失败，当前 {{ .name }} 服务不可用，请检查后重试！"
+
+#waf
+ErrScope: "不支持修改此配置"
+ErrStateChange: "状态修改失败"
+ErrRuleExist: "规则名称已存在"
+ErrRuleNotExist: "规则不存在"

backend/init/business/business.go

@@ -23,7 +23,7 @@ func syncApp() {
 
 func syncInstalledApp() {
 	if err := service.NewIAppInstalledService().SyncAll(true); err != nil {
-		global.LOG.Errorf("sync instaled app error: %s", err.Error())
+		global.LOG.Errorf("sync installed app error: %s", err.Error())
 	}
 }
 

backend/init/cache/badger_db/badger_db.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/dgraph-io/badger/v4"
-	"github.com/pkg/errors"
 )
 
 type Cache struct {
@@ -18,18 +17,6 @@ func NewCacheDB(db *badger.DB) *Cache {
 	}
 }
 
-func (c *Cache) SetNX(key string, value interface{}) error {
-	err := c.db.Update(func(txn *badger.Txn) error {
-		_, err := txn.Get([]byte(key))
-		if errors.Is(err, badger.ErrKeyNotFound) {
-			v := []byte(fmt.Sprintf("%v", value))
-			return txn.Set([]byte(key), v)
-		}
-		return err
-	})
-	return err
-}
-
 func (c *Cache) Set(key string, value interface{}) error {
 	err := c.db.Update(func(txn *badger.Txn) error {
 		v := []byte(fmt.Sprintf("%v", value))

backend/init/db/db.go

@@ -6,24 +6,22 @@ import (
 	"os"
 	"time"
 
-	"gorm.io/gorm/logger"
-
+	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/glebarez/sqlite"
 	"gorm.io/gorm"
-
-	"github.com/1Panel-dev/1Panel/backend/global"
+	"gorm.io/gorm/logger"
 )
 
 func Init() {
 	if _, err := os.Stat(global.CONF.System.DbPath); err != nil {
 		if err := os.MkdirAll(global.CONF.System.DbPath, os.ModePerm); err != nil {
-			panic(fmt.Errorf("init db dir falied, err: %v", err))
+			panic(fmt.Errorf("init db dir failed, err: %v", err))
 		}
 	}
 	fullPath := global.CONF.System.DbPath + "/" + global.CONF.System.DbFile
 	if _, err := os.Stat(fullPath); err != nil {
 		if _, err := os.Create(fullPath); err != nil {
-			panic(fmt.Errorf("init db file falied, err: %v", err))
+			panic(fmt.Errorf("init db file failed, err: %v", err))
 		}
 	}
 

backend/init/hook/hook.go

@@ -2,7 +2,10 @@ package hook
 
 import (
 	"encoding/base64"
+	"encoding/json"
+	"os"
 
+	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/app/repo"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
@@ -70,50 +73,103 @@ func Init() {
 		_, _ = cmd.Execf("%s sed -i '/CHANGE_USER_INFO=true/d' /usr/local/bin/1pctl", sudo)
 	}
 
+	handleCronjobStatus()
 	handleSnapStatus()
+	loadLocalDir()
 }
 
 func handleSnapStatus() {
+	msgFailed := "the task was interrupted due to the restart of the 1panel service"
+	_ = global.DB.Model(&model.Snapshot{}).Where("status = ?", "OnSaveData").
+		Updates(map[string]interface{}{"status": constant.StatusSuccess}).Error
+
+	_ = global.DB.Model(&model.Snapshot{}).Where("status = ?", constant.StatusWaiting).
+		Updates(map[string]interface{}{
+			"status":  constant.StatusFailed,
+			"message": msgFailed,
+		}).Error
+
+	_ = global.DB.Model(&model.Snapshot{}).Where("recover_status = ?", constant.StatusWaiting).
+		Updates(map[string]interface{}{
+			"recover_status":  constant.StatusFailed,
+			"recover_message": msgFailed,
+		}).Error
+
+	_ = global.DB.Model(&model.Snapshot{}).Where("rollback_status = ?", constant.StatusWaiting).
+		Updates(map[string]interface{}{
+			"rollback_status":  constant.StatusFailed,
+			"rollback_message": msgFailed,
+		}).Error
+
 	snapRepo := repo.NewISnapshotRepo()
-	snaps, _ := snapRepo.GetList()
-	for _, snap := range snaps {
-		if snap.Status == "OnSaveData" {
-			_ = snapRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusSuccess})
-		}
-		if snap.Status == constant.StatusWaiting {
-			_ = snapRepo.Update(snap.ID, map[string]interface{}{"status": constant.StatusFailed, "message": "the task was interrupted due to the restart of the 1panel service"})
-		}
-	}
 
 	status, _ := snapRepo.GetStatusList()
-	for _, statu := range status {
+	for _, item := range status {
 		updates := make(map[string]interface{})
-		if statu.Panel == constant.StatusRunning {
+		if item.Panel == constant.StatusRunning {
 			updates["panel"] = constant.StatusFailed
 		}
-		if statu.PanelInfo == constant.StatusRunning {
+		if item.PanelInfo == constant.StatusRunning {
 			updates["panel_info"] = constant.StatusFailed
 		}
-		if statu.DaemonJson == constant.StatusRunning {
+		if item.DaemonJson == constant.StatusRunning {
 			updates["daemon_json"] = constant.StatusFailed
 		}
-		if statu.AppData == constant.StatusRunning {
+		if item.AppData == constant.StatusRunning {
 			updates["app_data"] = constant.StatusFailed
 		}
-		if statu.PanelData == constant.StatusRunning {
+		if item.PanelData == constant.StatusRunning {
 			updates["panel_data"] = constant.StatusFailed
 		}
-		if statu.BackupData == constant.StatusRunning {
+		if item.BackupData == constant.StatusRunning {
 			updates["backup_data"] = constant.StatusFailed
 		}
-		if statu.Compress == constant.StatusRunning {
+		if item.Compress == constant.StatusRunning {
 			updates["compress"] = constant.StatusFailed
 		}
-		if statu.Upload == constant.StatusUploading {
+		if item.Upload == constant.StatusUploading {
 			updates["upload"] = constant.StatusFailed
 		}
 		if len(updates) != 0 {
-			_ = snapRepo.UpdateStatus(statu.ID, updates)
+			_ = snapRepo.UpdateStatus(item.ID, updates)
 		}
 	}
 }
+
+func handleCronjobStatus() {
+	_ = global.DB.Model(&model.JobRecords{}).Where("status = ?", constant.StatusWaiting).
+		Updates(map[string]interface{}{
+			"status":  constant.StatusFailed,
+			"message": "the task was interrupted due to the restart of the 1panel service",
+		}).Error
+}
+
+func loadLocalDir() {
+	var backup model.BackupAccount
+	_ = global.DB.Where("type = ?", "LOCAL").First(&backup).Error
+	if backup.ID == 0 {
+		global.LOG.Errorf("no such backup account `%s` in db", "LOCAL")
+		return
+	}
+	varMap := make(map[string]interface{})
+	if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
+		global.LOG.Errorf("json unmarshal backup.Vars: %v failed, err: %v", backup.Vars, err)
+		return
+	}
+	if _, ok := varMap["dir"]; !ok {
+		global.LOG.Error("load local backup dir failed")
+		return
+	}
+	baseDir, ok := varMap["dir"].(string)
+	if ok {
+		if _, err := os.Stat(baseDir); err != nil && os.IsNotExist(err) {
+			if err = os.MkdirAll(baseDir, os.ModePerm); err != nil {
+				global.LOG.Errorf("mkdir %s failed, err: %v", baseDir, err)
+				return
+			}
+		}
+		global.CONF.System.Backup = baseDir
+		return
+	}
+	global.LOG.Errorf("error type dir: %T", varMap["dir"])
+}

backend/init/log/log.go

@@ -56,8 +56,8 @@ type MineFormatter struct{}
 func (s *MineFormatter) Format(entry *logrus.Entry) ([]byte, error) {
 	detailInfo := ""
 	if entry.Caller != nil {
-		funcion := strings.ReplaceAll(entry.Caller.Function, "github.com/1Panel-dev/1Panel/backend/", "")
-		detailInfo = fmt.Sprintf("(%s: %d)", funcion, entry.Caller.Line)
+		function := strings.ReplaceAll(entry.Caller.Function, "github.com/1Panel-dev/1Panel/backend/", "")
+		detailInfo = fmt.Sprintf("(%s: %d)", function, entry.Caller.Line)
 	}
 	if len(entry.Data) == 0 {
 		msg := fmt.Sprintf("[%s] [%s] %s %s \n", time.Now().Format(TimeFormat), strings.ToUpper(entry.Level.String()), entry.Message, detailInfo)

backend/init/migration/migrate.go

@@ -66,6 +66,15 @@ func Init() {
 		migrations.AddTableDatabasePostgresql,
 		migrations.AddPostgresqlSuperUser,
 		migrations.UpdateCronjobWithWebsite,
+		migrations.UpdateOneDriveToken,
+		migrations.UpdateCronjobSpec,
+		migrations.UpdateBackupRecordPath,
+		migrations.UpdateSnapshotRecords,
+
+		migrations.UpdateWebDavConf,
+
+		migrations.AddSnapshotIgnore,
+		migrations.AddDatabaseIsDelete,
 	})
 	if err := m.Migrate(); err != nil {
 		global.LOG.Error(err)

backend/init/migration/migrations/init.go

@@ -85,7 +85,7 @@ var AddTableSetting = &gormigrate.Migration{
 		if err := tx.Create(&model.Setting{Key: "Language", Value: "zh"}).Error; err != nil {
 			return err
 		}
-		if err := tx.Create(&model.Setting{Key: "Theme", Value: "light"}).Error; err != nil {
+		if err := tx.Create(&model.Setting{Key: "Theme", Value: "auto"}).Error; err != nil {
 			return err
 		}
 

backend/init/migration/migrations/v_1_10.go

@@ -0,0 +1,27 @@
+package migrations
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/go-gormigrate/gormigrate/v2"
+	"gorm.io/gorm"
+)
+
+var AddSnapshotIgnore = &gormigrate.Migration{
+	ID: "20240311-add-snapshot-ignore",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.Create(&model.Setting{Key: "SnapshotIgnore", Value: "*.sock"}).Error; err != nil {
+			return err
+		}
+		return nil
+	},
+}
+
+var AddDatabaseIsDelete = &gormigrate.Migration{
+	ID: "20240314-add-database-is-delete",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.AutoMigrate(&model.DatabaseMysql{}, &model.DatabasePostgresql{}); err != nil {
+			return err
+		}
+		return nil
+	},
+}

backend/init/migration/migrations/v_1_9.go

@@ -1,11 +1,21 @@
 package migrations
 
 import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path"
+	"strings"
+	"time"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/app/repo"
 	"github.com/1Panel-dev/1Panel/backend/app/service"
+	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/cloud_storage/client"
 	"github.com/go-gormigrate/gormigrate/v2"
 	"gorm.io/gorm"
 )
@@ -114,6 +124,12 @@ var AddTablePHPExtensions = &gormigrate.Migration{
 		if err := tx.Create(&model.PHPExtensions{Name: "默认", Extensions: "bcmath,gd,gettext,intl,pcntl,shmop,soap,sockets,sysvsem,xmlrpc,zip"}).Error; err != nil {
 			return err
 		}
+		if err := tx.Create(&model.PHPExtensions{Name: "苹果CMS-V10", Extensions: "mysqli,pdo_mysql,zip,gd,redis,memcache,memcached"}).Error; err != nil {
+			return err
+		}
+		if err := tx.Create(&model.PHPExtensions{Name: "SeaCMS", Extensions: "mysqli,pdo_mysql,gd,curl"}).Error; err != nil {
+			return err
+		}
 		return nil
 	},
 }
@@ -188,3 +204,282 @@ var UpdateCronjobWithWebsite = &gormigrate.Migration{
 		return nil
 	},
 }
+
+var UpdateOneDriveToken = &gormigrate.Migration{
+	ID: "20240117-update-onedrive-token",
+	Migrate: func(tx *gorm.DB) error {
+		var (
+			backup        model.BackupAccount
+			clientSetting model.Setting
+			secretSetting model.Setting
+		)
+		_ = tx.Where("type = ?", "OneDrive").First(&backup).Error
+		if backup.ID == 0 {
+			return nil
+		}
+		if len(backup.Credential) == 0 {
+			global.LOG.Error("OneDrive configuration lacks token information, please rebind.")
+			return nil
+		}
+
+		_ = tx.Where("key = ?", "OneDriveID").First(&clientSetting).Error
+		if clientSetting.ID == 0 {
+			global.LOG.Error("system configuration lacks clientID information, please retry.")
+			return nil
+		}
+		_ = tx.Where("key = ?", "OneDriveSc").First(&secretSetting).Error
+		if secretSetting.ID == 0 {
+			global.LOG.Error("system configuration lacks clientID information, please retry.")
+			return nil
+		}
+		idItem, _ := base64.StdEncoding.DecodeString(clientSetting.Value)
+		global.CONF.System.OneDriveID = string(idItem)
+		scItem, _ := base64.StdEncoding.DecodeString(secretSetting.Value)
+		global.CONF.System.OneDriveSc = string(scItem)
+
+		varMap := make(map[string]interface{})
+		varMap["isCN"] = false
+		varMap["client_id"] = global.CONF.System.OneDriveID
+		varMap["client_secret"] = global.CONF.System.OneDriveSc
+		varMap["redirect_uri"] = constant.OneDriveRedirectURI
+		varMap["refresh_token"] = backup.Credential
+		token, refreshToken, err := client.RefreshToken("refresh_token", varMap)
+		varMap["refresh_status"] = constant.StatusSuccess
+		varMap["refresh_time"] = time.Now().Format("2006-01-02 15:04:05")
+		if err != nil {
+			varMap["refresh_msg"] = err.Error()
+			varMap["refresh_status"] = constant.StatusFailed
+		}
+		varMap["refresh_token"] = refreshToken
+		itemVars, _ := json.Marshal(varMap)
+		if err := tx.Model(&model.BackupAccount{}).
+			Where("id = ?", backup.ID).
+			Updates(map[string]interface{}{
+				"credential": token,
+				"vars":       string(itemVars),
+			}).Error; err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var UpdateCronjobSpec = &gormigrate.Migration{
+	ID: "20240122-update-cronjob-spec",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.AutoMigrate(&model.Cronjob{}); err != nil {
+			return err
+		}
+		if err := tx.AutoMigrate(&model.BackupRecord{}); err != nil {
+			return err
+		}
+		var (
+			jobs           []model.Cronjob
+			backupAccounts []model.BackupAccount
+		)
+		mapAccount := make(map[uint]model.BackupAccount)
+		if err := tx.Find(&jobs).Error; err != nil {
+			return err
+		}
+		_ = tx.Find(&backupAccounts).Error
+		for _, item := range backupAccounts {
+			mapAccount[item.ID] = item
+		}
+		for _, job := range jobs {
+			if job.KeepLocal && mapAccount[uint(job.TargetDirID)].Type != constant.Local {
+				if err := tx.Model(&model.Cronjob{}).
+					Where("id = ?", job.ID).
+					Updates(map[string]interface{}{
+						"backup_accounts":  fmt.Sprintf("%v,%v", mapAccount[uint(job.TargetDirID)].Type, constant.Local),
+						"default_download": constant.Local,
+					}).Error; err != nil {
+					return err
+				}
+				job.DefaultDownload = constant.Local
+			} else {
+				if err := tx.Model(&model.Cronjob{}).
+					Where("id = ?", job.ID).
+					Updates(map[string]interface{}{
+						"backup_accounts":  mapAccount[uint(job.TargetDirID)].Type,
+						"default_download": mapAccount[uint(job.TargetDirID)].Type,
+					}).Error; err != nil {
+					return err
+				}
+				job.DefaultDownload = mapAccount[uint(job.TargetDirID)].Type
+			}
+			if job.Type != "directory" && job.Type != "database" && job.Type != "website" && job.Type != "app" && job.Type != "snapshot" && job.Type != "log" {
+				continue
+			}
+
+			itemPath := mapAccount[uint(job.TargetDirID)].BackupPath
+			if job.DefaultDownload == constant.Local || itemPath == "/" {
+				itemPath = ""
+			} else {
+				itemPath = strings.TrimPrefix(itemPath, "/") + "/"
+			}
+
+			var records []model.JobRecords
+			_ = tx.Where("cronjob_id = ?", job.ID).Find(&records).Error
+			for _, record := range records {
+				if job.Type == "snapshot" && record.Status == constant.StatusSuccess {
+					var snaps []model.Snapshot
+					_ = tx.Where("name like ?", "snapshot_"+"%").Find(&snaps).Error
+					for _, snap := range snaps {
+						item := model.BackupRecord{
+							From:       "cronjob",
+							CronjobID:  job.ID,
+							Type:       "snapshot",
+							Name:       job.Name,
+							FileDir:    "system_snapshot",
+							FileName:   snap.Name + ".tar.gz",
+							Source:     snap.From,
+							BackupType: snap.From,
+							BaseModel: model.BaseModel{
+								CreatedAt: record.CreatedAt,
+							},
+						}
+						_ = tx.Create(&item).Error
+					}
+					continue
+				}
+				if job.Type == "log" && record.Status == constant.StatusSuccess {
+					item := model.BackupRecord{
+						From:       "cronjob",
+						CronjobID:  job.ID,
+						Type:       "log",
+						Name:       job.Name,
+						FileDir:    path.Dir(strings.TrimPrefix(record.File, itemPath)),
+						FileName:   path.Base(record.File),
+						Source:     mapAccount[uint(job.TargetDirID)].Type,
+						BackupType: mapAccount[uint(job.TargetDirID)].Type,
+						BaseModel: model.BaseModel{
+							CreatedAt: record.CreatedAt,
+						},
+					}
+					_ = tx.Create(&item).Error
+					continue
+				}
+				if job.Type == "directory" && record.Status == constant.StatusSuccess {
+					item := model.BackupRecord{
+						From:       "cronjob",
+						CronjobID:  job.ID,
+						Type:       "directory",
+						Name:       job.Name,
+						FileDir:    path.Dir(strings.TrimPrefix(record.File, itemPath)),
+						FileName:   path.Base(record.File),
+						BackupType: mapAccount[uint(job.TargetDirID)].Type,
+						BaseModel: model.BaseModel{
+							CreatedAt: record.CreatedAt,
+						},
+					}
+					if record.FromLocal {
+						item.Source = constant.Local
+					} else {
+						item.Source = mapAccount[uint(job.TargetDirID)].Type
+					}
+					_ = tx.Create(&item).Error
+					continue
+				}
+				if strings.Contains(record.File, ",") {
+					files := strings.Split(record.File, ",")
+					for _, file := range files {
+						_ = tx.Model(&model.BackupRecord{}).
+							Where("file_dir = ? AND file_name = ?", path.Dir(strings.TrimPrefix(file, itemPath)), path.Base(file)).
+							Updates(map[string]interface{}{"cronjob_id": job.ID, "from": "cronjob"}).Error
+					}
+				} else {
+					_ = tx.Model(&model.BackupRecord{}).
+						Where("file_dir = ? AND file_name = ?", path.Dir(strings.TrimPrefix(record.File, itemPath)), path.Base(record.File)).
+						Updates(map[string]interface{}{"cronjob_id": job.ID, "from": "cronjob"}).Error
+				}
+			}
+		}
+
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN spec_type;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN week;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN day;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN hour;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN minute;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN second;").Error
+		_ = tx.Exec("ALTER TABLE cronjobs DROP COLUMN entry_id;").Error
+
+		return nil
+	},
+}
+
+var UpdateBackupRecordPath = &gormigrate.Migration{
+	ID: "20240124-update-cronjob-spec",
+	Migrate: func(tx *gorm.DB) error {
+		var (
+			backupRecords []model.BackupRecord
+			localAccount  model.BackupAccount
+		)
+
+		_ = tx.Where("type = ?", "LOCAL").First(&localAccount).Error
+		if localAccount.ID == 0 {
+			return nil
+		}
+		varMap := make(map[string]string)
+		if err := json.Unmarshal([]byte(localAccount.Vars), &varMap); err != nil {
+			return err
+		}
+		dir, ok := varMap["dir"]
+		if !ok {
+			return errors.New("load local backup dir failed")
+		}
+		if dir != "/" {
+			dir += "/"
+		}
+		_ = tx.Where("source = ?", "LOCAL").Find(&backupRecords).Error
+		for _, record := range backupRecords {
+			_ = tx.Model(&model.BackupRecord{}).
+				Where("id = ?", record.ID).
+				Updates(map[string]interface{}{"file_dir": strings.TrimPrefix(record.FileDir, dir)}).Error
+		}
+		return nil
+	},
+}
+
+var UpdateSnapshotRecords = &gormigrate.Migration{
+	ID: "20240124-update-snapshot-records",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.AutoMigrate(&model.Snapshot{}); err != nil {
+			return err
+		}
+		var snaps []model.Snapshot
+		_ = tx.Find(&snaps).Error
+		for _, snap := range snaps {
+			_ = tx.Model(&model.Snapshot{}).
+				Where("id = ?", snap.ID).
+				Updates(map[string]interface{}{"default_download": snap.From}).Error
+		}
+		return nil
+	},
+}
+
+var UpdateWebDavConf = &gormigrate.Migration{
+	ID: "20240205-update-webdav-conf",
+	Migrate: func(tx *gorm.DB) error {
+		var backup model.BackupAccount
+		_ = tx.Where("type = ?", constant.WebDAV).First(&backup).Error
+		if backup.ID == 0 {
+			return nil
+		}
+		varMap := make(map[string]interface{})
+		if err := json.Unmarshal([]byte(backup.Vars), &varMap); err != nil {
+			return err
+		}
+		delete(varMap, "addressItem")
+		if port, ok := varMap["port"]; ok {
+			varMap["address"] = fmt.Sprintf("%s:%v", varMap["address"], port)
+			delete(varMap, "port")
+		}
+
+		vars, _ := json.Marshal(varMap)
+		if err := tx.Model(&model.BackupAccount{}).Where("id = ?", backup.ID).Updates(map[string]interface{}{"vars": string(vars)}).Error; err != nil {
+			return err
+		}
+		return nil
+	},
+}

backend/init/router/router.go

@@ -9,11 +9,9 @@ import (
 	"github.com/1Panel-dev/1Panel/cmd/server/docs"
 	"github.com/1Panel-dev/1Panel/cmd/server/web"
 	"github.com/gin-contrib/gzip"
-	ginI18n "github.com/gin-contrib/i18n"
 	"github.com/gin-gonic/gin"
 	swaggerfiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
-	"html/template"
 	"net/http"
 )
 
@@ -53,10 +51,7 @@ func Routers() *gin.Engine {
 		c.Writer.Flush()
 	})
 
-	Router.Use(i18n.GinI18nLocalize())
-	Router.SetFuncMap(template.FuncMap{
-		"Localize": ginI18n.GetMessage,
-	})
+	Router.Use(i18n.UseI18n())
 
 	swaggerRouter := Router.Group("1panel")
 	docs.SwaggerInfo.BasePath = "/api/v1"

backend/router/ro_dashboard.go

@@ -16,6 +16,7 @@ func (s *DashboardRouter) InitRouter(Router *gin.RouterGroup) {
 		Use(middleware.PasswordExpired())
 	baseApi := v1.ApiGroupApp.BaseApi
 	{
+		cmdRouter.GET("/base/os", baseApi.LoadDashboardOsInfo)
 		cmdRouter.GET("/base/:ioOption/:netOption", baseApi.LoadDashboardBaseInfo)
 		cmdRouter.GET("/current/:ioOption/:netOption", baseApi.LoadDashboardCurrentInfo)
 		cmdRouter.POST("/system/restart/:operation", baseApi.SystemRestart)

backend/router/ro_runtime.go

@@ -20,6 +20,7 @@ func (r *RuntimeRouter) InitRouter(Router *gin.RouterGroup) {
 		groupRouter.POST("/del", baseApi.DeleteRuntime)
 		groupRouter.POST("/update", baseApi.UpdateRuntime)
 		groupRouter.GET("/:id", baseApi.GetRuntime)
+		groupRouter.POST("/sync", baseApi.SyncStatus)
 
 		groupRouter.POST("/node/package", baseApi.GetNodePackageRunScript)
 		groupRouter.POST("/operate", baseApi.OperateRuntime)

backend/router/ro_setting.go

@@ -45,6 +45,7 @@ func (s *SettingRouter) InitRouter(Router *gin.RouterGroup) {
 		settingRouter.GET("/backup/search", baseApi.ListBackup)
 		settingRouter.GET("/backup/onedrive", baseApi.LoadOneDriveInfo)
 		settingRouter.POST("/backup/backup", baseApi.Backup)
+		settingRouter.POST("/backup/refresh/onedrive", baseApi.RefreshOneDriveToken)
 		settingRouter.POST("/backup/recover", baseApi.Recover)
 		settingRouter.POST("/backup/recover/byupload", baseApi.RecoverByUpload)
 		settingRouter.POST("/backup/search/files", baseApi.LoadFilesFromBackup)
@@ -53,6 +54,7 @@ func (s *SettingRouter) InitRouter(Router *gin.RouterGroup) {
 		settingRouter.POST("/backup/del", baseApi.DeleteBackup)
 		settingRouter.POST("/backup/update", baseApi.UpdateBackup)
 		settingRouter.POST("/backup/record/search", baseApi.SearchBackupRecords)
+		settingRouter.POST("/backup/record/search/bycronjob", baseApi.SearchBackupRecordsByCronjob)
 		settingRouter.POST("/backup/record/download", baseApi.DownloadRecord)
 		settingRouter.POST("/backup/record/del", baseApi.DeleteBackupRecord)
 

backend/server/server.go

@@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"encoding/gob"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/i18n"
 	"net"
 	"net/http"
 	"os"
@@ -31,6 +32,7 @@ import (
 
 func Start() {
 	viper.Init()
+	i18n.Init()
 	log.Init()
 	db.Init()
 	migration.Init()

backend/utils/cloud_storage/client/cos.go

@@ -17,11 +17,11 @@ type cosClient struct {
 }
 
 func NewCosClient(vars map[string]interface{}) (*cosClient, error) {
-	region := loadParamFromVars("region", true, vars)
-	accessKey := loadParamFromVars("accessKey", true, vars)
-	secretKey := loadParamFromVars("secretKey", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
-	scType := loadParamFromVars("scType", true, vars)
+	region := loadParamFromVars("region", vars)
+	accessKey := loadParamFromVars("accessKey", vars)
+	secretKey := loadParamFromVars("secretKey", vars)
+	bucket := loadParamFromVars("bucket", vars)
+	scType := loadParamFromVars("scType", vars)
 	if len(scType) == 0 {
 		scType = "Standard"
 	}

backend/utils/cloud_storage/client/helper.go

@@ -6,9 +6,9 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/global"
 )
 
-func loadParamFromVars(key string, isString bool, vars map[string]interface{}) string {
+func loadParamFromVars(key string, vars map[string]interface{}) string {
 	if _, ok := vars[key]; !ok {
-		if key != "bucket" {
+		if key != "bucket" && key != "port" {
 			global.LOG.Errorf("load param %s from vars failed, err: not exist!", key)
 		}
 		return ""

backend/utils/cloud_storage/client/kodo.go

@@ -17,10 +17,10 @@ type kodoClient struct {
 }
 
 func NewKodoClient(vars map[string]interface{}) (*kodoClient, error) {
-	accessKey := loadParamFromVars("accessKey", true, vars)
-	secretKey := loadParamFromVars("secretKey", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
-	domain := loadParamFromVars("domain", true, vars)
+	accessKey := loadParamFromVars("accessKey", vars)
+	secretKey := loadParamFromVars("secretKey", vars)
+	bucket := loadParamFromVars("bucket", vars)
+	domain := loadParamFromVars("domain", vars)
 
 	conn := auth.New(accessKey, secretKey)
 	cfg := storage.Config{

backend/utils/cloud_storage/client/local.go

@@ -0,0 +1,99 @@
+package client
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+)
+
+type localClient struct {
+	dir string
+}
+
+func NewLocalClient(vars map[string]interface{}) (*localClient, error) {
+	dir := loadParamFromVars("dir", vars)
+	return &localClient{dir: dir}, nil
+}
+
+func (c localClient) ListBuckets() ([]interface{}, error) {
+	return nil, nil
+}
+
+func (c localClient) Exist(file string) (bool, error) {
+	_, err := os.Stat(path.Join(c.dir, file))
+	return err == nil, err
+}
+
+func (c localClient) Size(file string) (int64, error) {
+	fileInfo, err := os.Stat(path.Join(c.dir, file))
+	if err != nil {
+		return 0, err
+	}
+	return fileInfo.Size(), nil
+}
+
+func (c localClient) Delete(file string) (bool, error) {
+	if err := os.RemoveAll(path.Join(c.dir, file)); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (c localClient) Upload(src, target string) (bool, error) {
+	targetFilePath := path.Join(c.dir, target)
+	if _, err := os.Stat(path.Dir(targetFilePath)); err != nil {
+		if os.IsNotExist(err) {
+			if err = os.MkdirAll(path.Dir(targetFilePath), os.ModePerm); err != nil {
+				return false, err
+			}
+		} else {
+			return false, err
+		}
+	}
+
+	stdout, err := cmd.Execf("\\cp -f %s %s", src, path.Join(c.dir, target))
+	if err != nil {
+		return false, fmt.Errorf("cp file failed, stdout: %v, err: %v", stdout, err)
+	}
+	return true, nil
+}
+
+func (c localClient) Download(src, target string) (bool, error) {
+	localPath := path.Join(c.dir, src)
+	if _, err := os.Stat(path.Dir(target)); err != nil {
+		if os.IsNotExist(err) {
+			if err = os.MkdirAll(path.Dir(target), os.ModePerm); err != nil {
+				return false, err
+			}
+		} else {
+			return false, err
+		}
+	}
+
+	stdout, err := cmd.Execf("\\cp -f %s %s", localPath, target)
+	if err != nil {
+		return false, fmt.Errorf("cp file failed, stdout: %v, err: %v", stdout, err)
+	}
+	return true, nil
+}
+
+func (c localClient) ListObjects(prefix string) ([]string, error) {
+	var files []string
+	itemPath := path.Join(c.dir, prefix)
+	if _, err := os.Stat(itemPath); err != nil {
+		return files, nil
+	}
+	if err := filepath.Walk(itemPath, func(path string, info os.FileInfo, err error) error {
+		if !info.IsDir() {
+			files = append(files, info.Name())
+		}
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+
+	return files, nil
+}

backend/utils/cloud_storage/client/minio.go

@@ -19,10 +19,10 @@ type minIoClient struct {
 }
 
 func NewMinIoClient(vars map[string]interface{}) (*minIoClient, error) {
-	endpoint := loadParamFromVars("endpoint", true, vars)
-	accessKeyID := loadParamFromVars("accessKey", true, vars)
-	secretAccessKey := loadParamFromVars("secretKey", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
+	endpoint := loadParamFromVars("endpoint", vars)
+	accessKeyID := loadParamFromVars("accessKey", vars)
+	secretAccessKey := loadParamFromVars("secretKey", vars)
+	bucket := loadParamFromVars("bucket", vars)
 	ssl := strings.Split(endpoint, ":")[0]
 	if len(ssl) == 0 || (ssl != "https" && ssl != "http") {
 		return nil, constant.ErrInvalidParams

backend/utils/cloud_storage/client/onedrive.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"crypto/tls"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -14,10 +15,9 @@ import (
 	"path"
 	"strconv"
 	"strings"
+	"time"
 
-	"github.com/1Panel-dev/1Panel/backend/app/model"
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	odsdk "github.com/goh-chunlin/go-onedrive/onedrive"
 	"golang.org/x/oauth2"
 )
@@ -27,21 +27,18 @@ type oneDriveClient struct {
 }
 
 func NewOneDriveClient(vars map[string]interface{}) (*oneDriveClient, error) {
-	token := loadParamFromVars("accessToken", true, vars)
+	token := loadParamFromVars("accessToken", vars)
+	isCN := loadParamFromVars("isCN", vars)
 	ctx := context.Background()
-
-	newToken, err := refreshToken(token)
-	if err != nil {
-		return nil, err
-	}
-	_ = global.DB.Model(&model.Group{}).Where("type = ?", "OneDrive").Updates(map[string]interface{}{"credential": newToken}).Error
-
 	ts := oauth2.StaticTokenSource(
-		&oauth2.Token{AccessToken: newToken},
+		&oauth2.Token{AccessToken: token},
 	)
 	tc := oauth2.NewClient(ctx, ts)
 
 	client := odsdk.NewClient(tc)
+	if isCN == "true" {
+		client.BaseURL, _ = url.Parse("https://microsoftgraph.chinacloudapi.cn/v1.0/")
+	}
 	return &oneDriveClient{client: *client}, nil
 }
 
@@ -108,78 +105,24 @@ func (o oneDriveClient) Upload(src, target string) (bool, error) {
 	}
 
 	ctx := context.Background()
-	file, err := os.Open(src)
+	folderID, err := o.loadIDByPath(path.Dir(target))
 	if err != nil {
 		return false, err
 	}
-	defer file.Close()
-	fileInfo, err := file.Stat()
+	fileInfo, err := os.Stat(src)
 	if err != nil {
 		return false, err
 	}
 	if fileInfo.IsDir() {
 		return false, errors.New("Only file is allowed to be uploaded here.")
 	}
-	fileName := fileInfo.Name()
-	fileSize := fileInfo.Size()
-
-	folderID, err := o.loadIDByPath(path.Dir(target))
-	if err != nil {
-		return false, err
+	var isOk bool
+	if fileInfo.Size() < 4*1024*1024 {
+		isOk, err = o.upSmall(src, folderID, fileInfo.Size())
+	} else {
+		isOk, err = o.upBig(ctx, src, folderID, fileInfo.Size())
 	}
-	apiURL := fmt.Sprintf("me/drive/items/%s:/%s:/createUploadSession", url.PathEscape(folderID), fileName)
-	sessionCreationRequestInside := NewUploadSessionCreationRequest{
-		ConflictBehavior: "rename",
-	}
-
-	sessionCreationRequest := struct {
-		Item        NewUploadSessionCreationRequest `json:"item"`
-		DeferCommit bool                            `json:"deferCommit"`
-	}{sessionCreationRequestInside, false}
-
-	sessionCreationReq, err := o.client.NewRequest("POST", apiURL, sessionCreationRequest)
-	if err != nil {
-		return false, err
-	}
-
-	var sessionCreationResp *NewUploadSessionCreationResponse
-	err = o.client.Do(ctx, sessionCreationReq, false, &sessionCreationResp)
-	if err != nil {
-		return false, fmt.Errorf("session creation failed %w", err)
-	}
-
-	fileSessionUploadUrl := sessionCreationResp.UploadURL
-
-	sizePerSplit := int64(3200 * 1024)
-	buffer := make([]byte, 3200*1024)
-	splitCount := fileSize / sizePerSplit
-	if fileSize%sizePerSplit != 0 {
-		splitCount += 1
-	}
-	bfReader := bufio.NewReader(file)
-	var fileUploadResp *UploadSessionUploadResponse
-	for splitNow := int64(0); splitNow < splitCount; splitNow++ {
-		length, err := bfReader.Read(buffer)
-		if err != nil {
-			return false, err
-		}
-		if int64(length) < sizePerSplit {
-			bufferLast := buffer[:length]
-			buffer = bufferLast
-		}
-		sessionFileUploadReq, err := o.NewSessionFileUploadRequest(fileSessionUploadUrl, splitNow*sizePerSplit, fileSize, bytes.NewReader(buffer))
-		if err != nil {
-			return false, err
-		}
-		if err := o.client.Do(ctx, sessionFileUploadReq, false, &fileUploadResp); err != nil {
-			return false, err
-		}
-	}
-	if fileUploadResp.Id == "" {
-		return false, errors.New("something went wrong. file upload incomplete. consider upload the file in a step-by-step manner")
-	}
-
-	return true, nil
+	return isOk, err
 }
 
 func (o oneDriveClient) Download(src, target string) (bool, error) {
@@ -253,38 +196,52 @@ func (o *oneDriveClient) loadIDByPath(path string) (string, error) {
 	return driveItem.Id, nil
 }
 
-func refreshToken(oldToken string) (string, error) {
+func RefreshToken(grantType string, varMap map[string]interface{}) (string, string, error) {
 	data := url.Values{}
-	data.Set("client_id", global.CONF.System.OneDriveID)
-	data.Set("client_secret", global.CONF.System.OneDriveSc)
-	data.Set("grant_type", "refresh_token")
-	data.Set("refresh_token", oldToken)
-	data.Set("redirect_uri", constant.OneDriveRedirectURI)
+	isCN := loadParamFromVars("isCN", varMap)
+	data.Set("client_id", loadParamFromVars("client_id", varMap))
+	data.Set("client_secret", loadParamFromVars("client_secret", varMap))
+	if grantType == "refresh_token" {
+		data.Set("grant_type", "refresh_token")
+		data.Set("refresh_token", loadParamFromVars("refresh_token", varMap))
+	} else {
+		data.Set("grant_type", "authorization_code")
+		data.Set("code", loadParamFromVars("code", varMap))
+	}
+	data.Set("redirect_uri", loadParamFromVars("redirect_uri", varMap))
 	client := &http.Client{}
-	req, err := http.NewRequest("POST", "https://login.microsoftonline.com/common/oauth2/v2.0/token", strings.NewReader(data.Encode()))
+	url := "https://login.microsoftonline.com/common/oauth2/v2.0/token"
+	if isCN == "true" {
+		url = "https://login.chinacloudapi.cn/common/oauth2/v2.0/token"
+	}
+	req, err := http.NewRequest("POST", url, strings.NewReader(data.Encode()))
 	if err != nil {
-		return "", fmt.Errorf("new http post client for access token failed, err: %v", err)
+		return "", "", fmt.Errorf("new http post client for access token failed, err: %v", err)
 	}
 	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	resp, err := client.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("request for access token failed, err: %v", err)
+		return "", "", fmt.Errorf("request for access token failed, err: %v", err)
 	}
 	respBody, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", fmt.Errorf("read data from response body failed, err: %v", err)
+		return "", "", fmt.Errorf("read data from response body failed, err: %v", err)
 	}
 	defer resp.Body.Close()
 
 	tokenMap := map[string]interface{}{}
 	if err := json.Unmarshal(respBody, &tokenMap); err != nil {
-		return "", fmt.Errorf("unmarshal data from response body failed, err: %v", err)
+		return "", "", fmt.Errorf("unmarshal data from response body failed, err: %v", err)
 	}
 	accessToken, ok := tokenMap["access_token"].(string)
 	if !ok {
-		return "", errors.New("no such access token in response")
+		return "", "", errors.New("no such access token in response")
 	}
-	return accessToken, nil
+	refreshToken, ok := tokenMap["refresh_token"].(string)
+	if !ok {
+		return "", "", errors.New("no such access token in response")
+	}
+	return accessToken, refreshToken, nil
 }
 
 func (o *oneDriveClient) createFolder(parent string) error {
@@ -344,3 +301,97 @@ func (o *oneDriveClient) NewSessionFileUploadRequest(absoluteUrl string, grandOf
 
 	return req, err
 }
+
+func (o *oneDriveClient) upSmall(srcPath, folderID string, fileSize int64) (bool, error) {
+	file, err := os.Open(srcPath)
+	if err != nil {
+		return false, err
+	}
+	defer file.Close()
+
+	buffer := make([]byte, fileSize)
+	_, _ = file.Read(buffer)
+	fileReader := bytes.NewReader(buffer)
+	apiURL := fmt.Sprintf("me/drive/items/%s:/%s:/content?@microsoft.graph.conflictBehavior=rename", url.PathEscape(folderID), path.Base(srcPath))
+
+	mimeType := files.GetMimeType(srcPath)
+	req, err := o.client.NewFileUploadRequest(apiURL, mimeType, fileReader)
+	if err != nil {
+		return false, err
+	}
+	var response *DriveItem
+	if err := o.client.Do(context.Background(), req, false, &response); err != nil {
+		return false, fmt.Errorf("do request for list failed, err: %v", err)
+	}
+	return true, nil
+}
+
+func (o *oneDriveClient) upBig(ctx context.Context, srcPath, folderID string, fileSize int64) (bool, error) {
+	file, err := os.Open(srcPath)
+	if err != nil {
+		return false, err
+	}
+	defer file.Close()
+
+	apiURL := fmt.Sprintf("me/drive/items/%s:/%s:/createUploadSession", url.PathEscape(folderID), path.Base(srcPath))
+	sessionCreationRequestInside := NewUploadSessionCreationRequest{
+		ConflictBehavior: "rename",
+	}
+
+	sessionCreationRequest := struct {
+		Item        NewUploadSessionCreationRequest `json:"item"`
+		DeferCommit bool                            `json:"deferCommit"`
+	}{sessionCreationRequestInside, false}
+
+	sessionCreationReq, err := o.client.NewRequest("POST", apiURL, sessionCreationRequest)
+	if err != nil {
+		return false, err
+	}
+
+	var sessionCreationResp *NewUploadSessionCreationResponse
+	err = o.client.Do(ctx, sessionCreationReq, false, &sessionCreationResp)
+	if err != nil {
+		return false, fmt.Errorf("session creation failed %w", err)
+	}
+
+	fileSessionUploadUrl := sessionCreationResp.UploadURL
+
+	sizePerSplit := int64(3200 * 1024)
+	buffer := make([]byte, 3200*1024)
+	splitCount := fileSize / sizePerSplit
+	if fileSize%sizePerSplit != 0 {
+		splitCount += 1
+	}
+	bfReader := bufio.NewReader(file)
+	httpClient := http.Client{
+		Timeout: time.Minute * 10,
+		Transport: &http.Transport{
+			Proxy:           http.ProxyFromEnvironment,
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+	}
+	for splitNow := int64(0); splitNow < splitCount; splitNow++ {
+		length, err := bfReader.Read(buffer)
+		if err != nil {
+			return false, err
+		}
+		if int64(length) < sizePerSplit {
+			bufferLast := buffer[:length]
+			buffer = bufferLast
+		}
+		sessionFileUploadReq, err := o.NewSessionFileUploadRequest(fileSessionUploadUrl, splitNow*sizePerSplit, fileSize, bytes.NewReader(buffer))
+		if err != nil {
+			return false, err
+		}
+		res, err := httpClient.Do(sessionFileUploadReq)
+		if err != nil {
+			return false, err
+		}
+		if res.StatusCode != 201 && res.StatusCode != 202 && res.StatusCode != 200 {
+			data, _ := io.ReadAll(res.Body)
+			res.Body.Close()
+			return false, errors.New(string(data))
+		}
+	}
+	return true, nil
+}