fix: 快照重试后更新列表状态 (#4086)

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

.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/

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 展示
 

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/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/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

@@ -99,9 +99,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 +115,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/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/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,67 @@ 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 {
+	switch {
+	case count == 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 {
+		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

@@ -342,7 +342,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 +355,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

@@ -393,7 +393,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 +406,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/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
@@ -138,6 +140,8 @@ func snapPanelData(snap snapHelper, localDir, targetDir string) {
 	}
 
 	_ = 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,6 +150,7 @@ 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) {
@@ -175,7 +180,7 @@ func snapCompress(snap snapHelper, rootDir string) {
 	_ = snapshotRepo.UpdateStatus(snap.Status.ID, map[string]interface{}{"compress": constant.StatusDone, "size": size})
 }
 
-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)
@@ -183,24 +188,22 @@ func snapUpload(snap snapHelper, account string, file string) {
 	}()
 
 	_ = 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})

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(src)
+	_, 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 ", "")

backend/app/service/upgrade.go

@@ -133,24 +133,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 +181,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 {
@@ -261,8 +261,8 @@ func loadArch() (string, error) {
 		if std == "armv7l\n" {
 			return "armv7", nil
 		}
-		return "", fmt.Errorf("unsupport such arch: arm-%s", std)
+		return "", fmt.Errorf("unsupported such arch: arm-%s", std)
 	default:
-		return "", fmt.Errorf("unsupport such arch: %s", runtime.GOARCH)
+		return "", fmt.Errorf("unsupported such arch: %s", runtime.GOARCH)
 	}
 }

backend/app/service/website.go

@@ -820,30 +820,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 +1508,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 +1536,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 +1614,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 +2064,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 +2208,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_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,7 +12,7 @@ const (
 	Rebuilding  = "Rebuilding"
 	Syncing     = "Syncing"
 	SyncSuccess = "SyncSuccess"
-	SyncErr     = "SyncErr"
+	Paused      = "Paused"
 
 	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"

backend/i18n/lang/zh-Hant.yaml

@@ -59,6 +59,8 @@ ErrVersionTooLow: '當前 1Panel 版本過低，無法更新應用商店，請
 ErrAppNameExist: '應用名稱已存在'
 AppStoreIsSyncing: '應用程式商店正在同步中，請稍後再試'
 ErrGetCompose: "docker-compose.yml 檔案取得失敗！{{ .detail }}"
+ErrAppWarn: "狀態異常，請查看日誌"
+ErrAppParamKey: "參數 {{ .name }} 欄位異常"
 
 #file
 ErrFileCanNotRead: "此文件不支持預覽"

backend/i18n/lang/zh.yaml

@@ -59,6 +59,8 @@ ErrVersionTooLow: '当前 1Panel 版本过低，无法更新应用商店，请
 ErrAppNameExist: '应用名称已存在'
 AppStoreIsSyncing: '应用商店正在同步中，请稍后再试'
 ErrGetCompose: "docker-compose.yml 文件获取失败！{{ .detail }}"
+ErrAppWarn: "状态异常，请查看日志"
+ErrAppParamKey: "参数 {{ .name }} 字段异常"
 
 #file
 ErrFileCanNotRead: "此文件不支持预览"

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

@@ -17,13 +17,13 @@ import (
 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,12 @@ func Init() {
 		migrations.AddTableDatabasePostgresql,
 		migrations.AddPostgresqlSuperUser,
 		migrations.UpdateCronjobWithWebsite,
+		migrations.UpdateOneDriveToken,
+		migrations.UpdateCronjobSpec,
+		migrations.UpdateBackupRecordPath,
+		migrations.UpdateSnapshotRecords,
+
+		migrations.UpdateWebDavConf,
 	})
 	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_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"
 )
@@ -188,3 +198,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_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

@@ -15,9 +15,7 @@ import (
 	"strconv"
 	"strings"
 
-	"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 +25,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 +103,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 +194,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 +299,89 @@ 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)
+	}
+	fmt.Println(response)
+	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)
+	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
+}

backend/utils/cloud_storage/client/oss.go

@@ -13,11 +13,11 @@ type ossClient struct {
 }
 
 func NewOssClient(vars map[string]interface{}) (*ossClient, error) {
-	endpoint := loadParamFromVars("endpoint", true, vars)
-	accessKey := loadParamFromVars("accessKey", true, vars)
-	secretKey := loadParamFromVars("secretKey", true, vars)
-	bucketStr := loadParamFromVars("bucket", true, vars)
-	scType := loadParamFromVars("scType", true, vars)
+	endpoint := loadParamFromVars("endpoint", vars)
+	accessKey := loadParamFromVars("accessKey", vars)
+	secretKey := loadParamFromVars("secretKey", vars)
+	bucketStr := loadParamFromVars("bucket", vars)
+	scType := loadParamFromVars("scType", vars)
 	if len(scType) == 0 {
 		scType = "Standard"
 	}

backend/utils/cloud_storage/client/s3.go

@@ -18,12 +18,12 @@ type s3Client struct {
 }
 
 func NewS3Client(vars map[string]interface{}) (*s3Client, error) {
-	accessKey := loadParamFromVars("accessKey", true, vars)
-	secretKey := loadParamFromVars("secretKey", true, vars)
-	endpoint := loadParamFromVars("endpoint", true, vars)
-	region := loadParamFromVars("region", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
-	scType := loadParamFromVars("scType", true, vars)
+	accessKey := loadParamFromVars("accessKey", vars)
+	secretKey := loadParamFromVars("secretKey", vars)
+	endpoint := loadParamFromVars("endpoint", vars)
+	region := loadParamFromVars("region", vars)
+	bucket := loadParamFromVars("bucket", vars)
+	scType := loadParamFromVars("scType", vars)
 	if len(scType) == 0 {
 		scType = "Standard"
 	}
@@ -97,6 +97,10 @@ func (s s3Client) Delete(path string) (bool, error) {
 }
 
 func (s s3Client) Upload(src, target string) (bool, error) {
+	fileInfo, err := os.Stat(src)
+	if err != nil {
+		return false, err
+	}
 	file, err := os.Open(src)
 	if err != nil {
 		return false, err
@@ -104,6 +108,9 @@ func (s s3Client) Upload(src, target string) (bool, error) {
 	defer file.Close()
 
 	uploader := s3manager.NewUploader(&s.Sess)
+	if fileInfo.Size() > s3manager.MaxUploadParts*s3manager.DefaultUploadPartSize {
+		uploader.PartSize = fileInfo.Size() / (s3manager.MaxUploadParts - 1)
+	}
 	if _, err := uploader.Upload(&s3manager.UploadInput{
 		Bucket:       aws.String(s.bucket),
 		Key:          aws.String(target),

backend/utils/cloud_storage/client/sftp.go

@@ -1,13 +1,14 @@
 package client
 
 import (
-	"bufio"
 	"fmt"
+	"io"
 	"net"
 	"os"
 	"path"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/pkg/sftp"
 	"golang.org/x/crypto/ssh"
 )
@@ -19,11 +20,14 @@ type sftpClient struct {
 }
 
 func NewSftpClient(vars map[string]interface{}) (*sftpClient, error) {
-	address := loadParamFromVars("address", true, vars)
-	port := loadParamFromVars("port", false, vars)
-	password := loadParamFromVars("password", true, vars)
-	username := loadParamFromVars("username", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
+	address := loadParamFromVars("address", vars)
+	port := loadParamFromVars("port", vars)
+	if len(port) == 0 {
+		global.LOG.Errorf("load param port from vars failed, err: not exist!")
+	}
+	password := loadParamFromVars("password", vars)
+	username := loadParamFromVars("username", vars)
+	bucket := loadParamFromVars("bucket", vars)
 
 	auth := []ssh.AuthMethod{ssh.Password(password)}
 	clientConfig := &ssh.ClientConfig{
@@ -34,6 +38,9 @@ func NewSftpClient(vars map[string]interface{}) (*sftpClient, error) {
 			return nil
 		},
 	}
+	if _, err := ssh.Dial("tcp", fmt.Sprintf("%s:%s", address, port), clientConfig); err != nil {
+		return nil, err
+	}
 
 	return &sftpClient{bucket: bucket, connInfo: fmt.Sprintf("%s:%s", address, port), config: clientConfig}, nil
 }
@@ -56,7 +63,7 @@ func (s sftpClient) Upload(src, target string) (bool, error) {
 	}
 	defer srcFile.Close()
 
-	targetFilePath := s.bucket + "/" + target
+	targetFilePath := path.Join(s.bucket, target)
 	targetDir, _ := path.Split(targetFilePath)
 	if _, err = client.Stat(targetDir); err != nil {
 		if os.IsNotExist(err) {
@@ -67,22 +74,14 @@ func (s sftpClient) Upload(src, target string) (bool, error) {
 			return false, err
 		}
 	}
-	dstFile, err := client.Create(targetFilePath)
+	dstFile, err := client.Create(path.Join(s.bucket, target))
 	if err != nil {
 		return false, err
 	}
 	defer dstFile.Close()
 
-	reader := bufio.NewReaderSize(srcFile, 128*1024*1024)
-	for {
-		chunk, err := reader.Peek(8 * 1024 * 1024)
-		if len(chunk) != 0 {
-			_, _ = dstFile.Write(chunk)
-			_, _ = reader.Discard(len(chunk))
-		}
-		if err != nil {
-			break
-		}
+	if _, err := io.Copy(dstFile, srcFile); err != nil {
+		return false, err
 	}
 	return true, nil
 }
@@ -103,6 +102,7 @@ func (s sftpClient) Download(src, target string) (bool, error) {
 	}
 	defer client.Close()
 	defer sshClient.Close()
+
 	srcFile, err := client.Open(s.bucket + "/" + src)
 	if err != nil {
 		return false, err
@@ -115,13 +115,13 @@ func (s sftpClient) Download(src, target string) (bool, error) {
 	}
 	defer dstFile.Close()
 
-	if _, err = srcFile.WriteTo(dstFile); err != nil {
+	if _, err = io.Copy(dstFile, srcFile); err != nil {
 		return false, err
 	}
 	return true, err
 }
 
-func (s sftpClient) Exist(path string) (bool, error) {
+func (s sftpClient) Exist(filePath string) (bool, error) {
 	sshClient, err := ssh.Dial("tcp", s.connInfo, s.config)
 	if err != nil {
 		return false, err
@@ -133,7 +133,7 @@ func (s sftpClient) Exist(path string) (bool, error) {
 	defer client.Close()
 	defer sshClient.Close()
 
-	srcFile, err := client.Open(s.bucket + "/" + path)
+	srcFile, err := client.Open(path.Join(s.bucket, filePath))
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false, nil
@@ -145,7 +145,7 @@ func (s sftpClient) Exist(path string) (bool, error) {
 	return true, err
 }
 
-func (s sftpClient) Size(path string) (int64, error) {
+func (s sftpClient) Size(filePath string) (int64, error) {
 	sshClient, err := ssh.Dial("tcp", s.connInfo, s.config)
 	if err != nil {
 		return 0, err
@@ -157,7 +157,7 @@ func (s sftpClient) Size(path string) (int64, error) {
 	defer client.Close()
 	defer sshClient.Close()
 
-	files, err := client.Stat(s.bucket + "/" + path)
+	files, err := client.Stat(path.Join(s.bucket, filePath))
 	if err != nil {
 		return 0, err
 	}
@@ -176,8 +176,7 @@ func (s sftpClient) Delete(filePath string) (bool, error) {
 	defer client.Close()
 	defer sshClient.Close()
 
-	targetFilePath := s.bucket + "/" + filePath
-	if err := client.Remove(targetFilePath); err != nil {
+	if err := client.Remove(path.Join(s.bucket, filePath)); err != nil {
 		return false, err
 	}
 	return true, nil
@@ -195,7 +194,7 @@ func (s sftpClient) ListObjects(prefix string) ([]string, error) {
 	defer client.Close()
 	defer sshClient.Close()
 
-	files, err := client.ReadDir(s.bucket + "/" + prefix)
+	files, err := client.ReadDir(path.Join(s.bucket, prefix))
 	if err != nil {
 		return nil, err
 	}

backend/utils/cloud_storage/client/webdav.go

@@ -1,9 +1,13 @@
 package client
 
 import (
+	"crypto/tls"
 	"fmt"
 	"io"
+	"net/http"
 	"os"
+	"path"
+	"strings"
 
 	"github.com/studio-b12/gowebdav"
 )
@@ -14,17 +18,25 @@ type webDAVClient struct {
 }
 
 func NewWebDAVClient(vars map[string]interface{}) (*webDAVClient, error) {
-	address := loadParamFromVars("address", true, vars)
-	port := loadParamFromVars("port", true, vars)
-	password := loadParamFromVars("password", true, vars)
-	username := loadParamFromVars("username", true, vars)
-	bucket := loadParamFromVars("bucket", true, vars)
+	address := loadParamFromVars("address", vars)
+	port := loadParamFromVars("port", vars)
+	password := loadParamFromVars("password", vars)
+	username := loadParamFromVars("username", vars)
+	bucket := loadParamFromVars("bucket", vars)
 
 	url := fmt.Sprintf("%s:%s", address, port)
 	if len(port) == 0 {
 		url = address
 	}
 	client := gowebdav.NewClient(url, username, password)
+	tlsConfig := &tls.Config{}
+	if strings.HasPrefix(address, "https") {
+		tlsConfig.InsecureSkipVerify = true
+	}
+	var transport http.RoundTripper = &http.Transport{
+		TLSClientConfig: tlsConfig,
+	}
+	client.SetTransport(transport)
 	if err := client.Connect(); err != nil {
 		return nil, err
 	}
@@ -32,23 +44,14 @@ func NewWebDAVClient(vars map[string]interface{}) (*webDAVClient, error) {
 }
 
 func (s webDAVClient) Upload(src, target string) (bool, error) {
-	targetFilePath := s.Bucket + "/" + target
-	fileInfo, err := os.Stat(src)
+	targetFilePath := path.Join(s.Bucket, target)
+	srcFile, err := os.Open(src)
 	if err != nil {
 		return false, err
 	}
-	// 50M
-	if fileInfo.Size() > 52428800 {
-		bytes, _ := os.ReadFile(src)
-		if err := s.client.Write(targetFilePath, bytes, 0644); err != nil {
-			return false, err
-		}
-		return true, nil
-	}
-	file, _ := os.Open(src)
-	defer file.Close()
+	defer srcFile.Close()
 
-	if err := s.client.WriteStream(targetFilePath, file, 0644); err != nil {
+	if err := s.client.WriteStream(targetFilePath, srcFile, 0644); err != nil {
 		return false, err
 	}
 	return true, nil
@@ -60,7 +63,7 @@ func (s webDAVClient) ListBuckets() ([]interface{}, error) {
 }
 
 func (s webDAVClient) Download(src, target string) (bool, error) {
-	srcPath := s.Bucket + "/" + src
+	srcPath := path.Join(s.Bucket, src)
 	info, err := s.client.Stat(srcPath)
 	if err != nil {
 		return false, err
@@ -76,45 +79,37 @@ func (s webDAVClient) Download(src, target string) (bool, error) {
 		return false, err
 	}
 	defer file.Close()
-	// 50M
-	if info.Size() > 52428800 {
-		reader, _ := s.client.ReadStream(srcPath)
-		if _, err := io.Copy(file, reader); err != nil {
-			return false, err
-		}
-	}
-
-	bytes, _ := s.client.Read(srcPath)
-	if err := os.WriteFile(target, bytes, 0644); err != nil {
+	reader, _ := s.client.ReadStream(srcPath)
+	if _, err := io.Copy(file, reader); err != nil {
 		return false, err
 	}
 	return true, err
 }
 
-func (s webDAVClient) Exist(path string) (bool, error) {
-	if _, err := s.client.Stat(s.Bucket + "/" + path); err != nil {
+func (s webDAVClient) Exist(pathItem string) (bool, error) {
+	if _, err := s.client.Stat(path.Join(s.Bucket, pathItem)); err != nil {
 		return false, err
 	}
 	return true, nil
 }
 
-func (s webDAVClient) Size(path string) (int64, error) {
-	file, err := s.client.Stat(s.Bucket + "/" + path)
+func (s webDAVClient) Size(pathItem string) (int64, error) {
+	file, err := s.client.Stat(path.Join(s.Bucket, pathItem))
 	if err != nil {
 		return 0, err
 	}
 	return file.Size(), nil
 }
 
-func (s webDAVClient) Delete(filePath string) (bool, error) {
-	if err := s.client.Remove(s.Bucket + "/" + filePath); err != nil {
+func (s webDAVClient) Delete(pathItem string) (bool, error) {
+	if err := s.client.Remove(path.Join(s.Bucket, pathItem)); err != nil {
 		return false, err
 	}
 	return true, nil
 }
 
 func (s webDAVClient) ListObjects(prefix string) ([]string, error) {
-	files, err := s.client.ReadDir(s.Bucket + "/" + prefix)
+	files, err := s.client.ReadDir(path.Join(s.Bucket, prefix))
 	if err != nil {
 		return nil, err
 	}

backend/utils/cloud_storage/cloud_storage_client.go

@@ -18,6 +18,8 @@ type CloudStorageClient interface {
 
 func NewCloudStorageClient(backupType string, vars map[string]interface{}) (CloudStorageClient, error) {
 	switch backupType {
+	case constant.Local:
+		return client.NewLocalClient(vars)
 	case constant.S3:
 		return client.NewS3Client(vars)
 	case constant.OSS:

backend/utils/cmd/cmd.go

@@ -2,9 +2,8 @@ package cmd
 
 import (
 	"bytes"
-	"context"
 	"fmt"
-	"io"
+	"os"
 	"os/exec"
 	"strings"
 	"time"
@@ -14,20 +13,7 @@ import (
 )
 
 func Exec(cmdStr string) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
-	defer cancel()
-	cmd := exec.Command("bash", "-c", cmdStr)
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-	if ctx.Err() == context.DeadlineExceeded {
-		return "", buserr.New(constant.ErrCmdTimeout)
-	}
-	if err != nil {
-		return handleErr(stdout, stderr, err)
-	}
-	return stdout.String(), nil
+	return ExecWithTimeOut(cmdStr, 20*time.Second)
 }
 
 func handleErr(stdout, stderr bytes.Buffer, err error) (string, error) {
@@ -46,19 +32,28 @@ func handleErr(stdout, stderr bytes.Buffer, err error) (string, error) {
 }
 
 func ExecWithTimeOut(cmdStr string, timeout time.Duration) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
 	cmd := exec.Command("bash", "-c", cmdStr)
 	var stdout, stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
-	err := cmd.Run()
-	if ctx.Err() == context.DeadlineExceeded {
+	if err := cmd.Start(); err != nil {
+		return "", err
+	}
+	done := make(chan error, 1)
+	go func() {
+		done <- cmd.Wait()
+	}()
+	after := time.After(timeout)
+	select {
+	case <-after:
+		_ = cmd.Process.Kill()
 		return "", buserr.New(constant.ErrCmdTimeout)
+	case err := <-done:
+		if err != nil {
+			return handleErr(stdout, stderr, err)
+		}
 	}
-	if err != nil {
-		return handleErr(stdout, stderr, err)
-	}
+
 	return stdout.String(), nil
 }
 
@@ -74,24 +69,35 @@ func ExecContainerScript(containerName, cmdStr string, timeout time.Duration) er
 	return nil
 }
 
-func ExecCronjobWithTimeOut(cmdStr string, workdir string, timeout time.Duration) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
+func ExecCronjobWithTimeOut(cmdStr, workdir, outPath string, timeout time.Duration) error {
+	file, err := os.OpenFile(outPath, os.O_WRONLY|os.O_CREATE, 0666)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
 	cmd := exec.Command("bash", "-c", cmdStr)
 	cmd.Dir = workdir
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	output := new(bytes.Buffer)
-	cmd.Stdout = io.MultiWriter(output, cmd.Stdout)
-	cmd.Stderr = io.MultiWriter(output, cmd.Stderr)
-
-	err := cmd.Run()
-	if ctx.Err() == context.DeadlineExceeded {
-		return "", buserr.New(constant.ErrCmdTimeout)
+	cmd.Stdout = file
+	cmd.Stderr = file
+	if err := cmd.Start(); err != nil {
+		return err
 	}
-
-	return output.String(), err
+	done := make(chan error, 1)
+	go func() {
+		done <- cmd.Wait()
+	}()
+	after := time.After(timeout)
+	select {
+	case <-after:
+		_ = cmd.Process.Kill()
+		return buserr.New(constant.ErrCmdTimeout)
+	case err := <-done:
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func Execf(cmdStr string, a ...interface{}) (string, error) {
@@ -119,20 +125,29 @@ func ExecWithCheck(name string, a ...string) (string, error) {
 }
 
 func ExecScript(scriptPath, workDir string) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer cancel()
 	cmd := exec.Command("bash", scriptPath)
-	cmd.Dir = workDir
 	var stdout, stderr bytes.Buffer
+	cmd.Dir = workDir
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
-	err := cmd.Run()
-	if ctx.Err() == context.DeadlineExceeded {
+	if err := cmd.Start(); err != nil {
+		return "", err
+	}
+	done := make(chan error, 1)
+	go func() {
+		done <- cmd.Wait()
+	}()
+	after := time.After(10 * time.Minute)
+	select {
+	case <-after:
+		_ = cmd.Process.Kill()
 		return "", buserr.New(constant.ErrCmdTimeout)
+	case err := <-done:
+		if err != nil {
+			return handleErr(stdout, stderr, err)
+		}
 	}
-	if err != nil {
-		return handleErr(stdout, stderr, err)
-	}
+
 	return stdout.String(), nil
 }
 

backend/utils/common/common.go

@@ -3,7 +3,6 @@ package common
 import (
 	"crypto/rand"
 	"fmt"
-	"golang.org/x/net/idna"
 	"io"
 	mathRand "math/rand"
 	"net"
@@ -15,6 +14,8 @@ import (
 	"time"
 	"unicode"
 
+	"golang.org/x/net/idna"
+
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 )
 
@@ -143,15 +144,6 @@ func ScanPortWithProto(port int, proto string) bool {
 	return ScanPort(port)
 }
 
-func ExistWithStrArray(str string, arr []string) bool {
-	for _, a := range arr {
-		if strings.Contains(a, str) {
-			return true
-		}
-	}
-	return false
-}
-
 func IsNum(s string) bool {
 	_, err := strconv.ParseFloat(s, 64)
 	return err == nil

backend/utils/docker/compose.go

@@ -2,15 +2,19 @@ package docker
 
 import (
 	"context"
-	"github.com/compose-spec/compose-go/loader"
-	"github.com/compose-spec/compose-go/types"
-	"github.com/docker/compose/v2/pkg/api"
-	"github.com/joho/godotenv"
-	"gopkg.in/yaml.v3"
 	"path"
 	"regexp"
 	"strings"
 	"time"
+
+	"github.com/compose-spec/compose-go/v2/loader"
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
+	"github.com/docker/cli/cli/flags"
+	"github.com/docker/compose/v2/pkg/api"
+	"github.com/docker/compose/v2/pkg/compose"
+	"github.com/docker/docker/client"
+	"github.com/joho/godotenv"
 )
 
 type ComposeService struct {
@@ -18,8 +22,7 @@ type ComposeService struct {
 	project *types.Project
 }
 
-func (s *ComposeService) SetProject(project *types.Project) {
-	s.project = project
+func UpComposeProject(project *types.Project) error {
 	for i, s := range project.Services {
 		s.CustomLabels = map[string]string{
 			api.ProjectLabel:     project.Name,
@@ -31,47 +34,35 @@ func (s *ComposeService) SetProject(project *types.Project) {
 		}
 		project.Services[i] = s
 	}
-}
 
-func (s *ComposeService) ComposeUp() error {
-	return s.Up(context.Background(), s.project, api.UpOptions{
+	apiClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		return err
+	}
+	var ops []command.CLIOption
+	ops = append(ops, command.WithAPIClient(apiClient), command.WithDefaultContextStoreConfig())
+	cli, err := command.NewDockerCli(ops...)
+	if err != nil {
+		return err
+	}
+	cliOp := flags.NewClientOptions()
+	if err = cli.Initialize(cliOp); err != nil {
+		return err
+	}
+	service := compose.NewComposeService(cli)
+	composeService := ComposeService{Service: service}
+
+	return composeService.Up(context.Background(), project, api.UpOptions{
 		Create: api.CreateOptions{
 			Timeout: getComposeTimeout(),
 		},
 		Start: api.StartOptions{
 			WaitTimeout: *getComposeTimeout(),
+			Wait:        true,
 		},
 	})
 }
 
-func (s *ComposeService) ComposeDown() error {
-	return s.Down(context.Background(), s.project.Name, api.DownOptions{})
-}
-
-func (s *ComposeService) ComposeStart() error {
-	return s.Start(context.Background(), s.project.Name, api.StartOptions{})
-}
-
-func (s *ComposeService) ComposeRestart() error {
-	return s.Restart(context.Background(), s.project.Name, api.RestartOptions{})
-}
-
-func (s *ComposeService) ComposeStop() error {
-	return s.Stop(context.Background(), s.project.Name, api.StopOptions{})
-}
-
-func (s *ComposeService) ComposeCreate() error {
-	return s.Create(context.Background(), s.project, api.CreateOptions{})
-}
-
-func (s *ComposeService) ComposeBuild() error {
-	return s.Build(context.Background(), s.project, api.BuildOptions{})
-}
-
-func (s *ComposeService) ComposePull() error {
-	return s.Pull(context.Background(), s.project, api.PullOptions{})
-}
-
 func GetComposeProject(projectName, workDir string, yml []byte, env []byte, skipNormalization bool) (*types.Project, error) {
 	var configFiles []types.ConfigFile
 	configFiles = append(configFiles, types.ConfigFile{
@@ -116,15 +107,32 @@ type Service struct {
 	Image string `yaml:"image"`
 }
 
-func GetDockerComposeImages(data []byte) ([]string, error) {
-	var dc ComposeProject
-	err := yaml.Unmarshal(data, &dc)
+func GetDockerComposeImages(projectName string, env, yml []byte) ([]string, error) {
+	var (
+		configFiles []types.ConfigFile
+		images      []string
+	)
+	configFiles = append(configFiles, types.ConfigFile{
+		Filename: "docker-compose.yml",
+		Content:  yml},
+	)
+	envMap, err := godotenv.UnmarshalBytes(env)
 	if err != nil {
 		return nil, err
 	}
+	details := types.ConfigDetails{
+		ConfigFiles: configFiles,
+		Environment: envMap,
+	}
 
-	var images []string
-	for _, service := range dc.Services {
+	project, err := loader.LoadWithContext(context.Background(), details, func(options *loader.Options) {
+		options.SetProjectName(projectName, true)
+		options.ResolvePaths = true
+	})
+	if err != nil {
+		return nil, err
+	}
+	for _, service := range project.AllServices() {
 		images = append(images, service.Image)
 	}
 	return images, nil

backend/utils/docker/docker.go

@@ -3,6 +3,8 @@ package docker
 import (
 	"context"
 
+	"github.com/docker/docker/api/types/container"
+
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/global"
 
@@ -44,24 +46,17 @@ func NewDockerClient() (*client.Client, error) {
 	return cli, nil
 }
 
-func (c Client) ListAllContainers() ([]types.Container, error) {
-	var options types.ContainerListOptions
-	containers, err := c.cli.ContainerList(context.Background(), options)
-	if err != nil {
-		return nil, err
-	}
-	return containers, nil
-}
-
 func (c Client) ListContainersByName(names []string) ([]types.Container, error) {
 	var (
-		options types.ContainerListOptions
-		res     []types.Container
+		options  container.ListOptions
+		namesMap = make(map[string]bool)
+		res      []types.Container
 	)
 	options.All = true
 	if len(names) > 0 {
 		var array []filters.KeyValuePair
 		for _, n := range names {
+			namesMap["/"+n] = true
 			array = append(array, filters.Arg("name", n))
 		}
 		options.Filters = filters.NewArgs(array...)
@@ -70,9 +65,9 @@ func (c Client) ListContainersByName(names []string) ([]types.Container, error)
 	if err != nil {
 		return nil, err
 	}
-	for _, container := range containers {
-		if container.Names[0] == "/"+names[0] {
-			res = append(res, container)
+	for _, con := range containers {
+		if _, ok := namesMap[con.Names[0]]; ok {
+			res = append(res, con)
 		}
 	}
 	return res, nil

backend/utils/encrypt/encrypt.go

@@ -4,10 +4,8 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
-	"crypto/md5"
 	"crypto/rand"
 	"encoding/base64"
-	"encoding/hex"
 	"fmt"
 	"io"
 
@@ -61,12 +59,6 @@ func StringDecrypt(text string) (string, error) {
 	return "", err
 }
 
-func Md5(str string) string {
-	h := md5.New()
-	h.Write([]byte(str))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
 func padding(plaintext []byte, blockSize int) []byte {
 	padding := blockSize - len(plaintext)%blockSize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)

backend/utils/files/file_op.go

@@ -7,11 +7,6 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
-	http2 "github.com/1Panel-dev/1Panel/backend/utils/http"
-	cZip "github.com/klauspost/compress/zip"
-	"golang.org/x/text/encoding/simplifiedchinese"
-	"golang.org/x/text/transform"
 	"io"
 	"io/fs"
 	"net/http"
@@ -23,6 +18,12 @@ import (
 	"sync"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	http2 "github.com/1Panel-dev/1Panel/backend/utils/http"
+	cZip "github.com/klauspost/compress/zip"
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/mholt/archiver/v4"
 	"github.com/pkg/errors"
@@ -85,10 +86,6 @@ func (f FileOp) DeleteFile(dst string) error {
 	return f.Fs.Remove(dst)
 }
 
-func (f FileOp) Delete(dst string) error {
-	return os.RemoveAll(dst)
-}
-
 func (f FileOp) CleanDir(dst string) error {
 	return cmd.ExecCmd(fmt.Sprintf("rm -rf %s/*", dst))
 }
@@ -129,14 +126,6 @@ func (f FileOp) SaveFile(dst string, content string, mode fs.FileMode) error {
 	return nil
 }
 
-func (f FileOp) Chmod(dst string, mode fs.FileMode) error {
-	return f.Fs.Chmod(dst, mode)
-}
-
-func (f FileOp) Chown(dst string, uid int, gid int) error {
-	return f.Fs.Chown(dst, uid, gid)
-}
-
 func (f FileOp) ChownR(dst string, uid string, gid string, sub bool) error {
 	cmdStr := fmt.Sprintf(`chown %s:%s "%s"`, uid, gid, dst)
 	if sub {
@@ -319,7 +308,7 @@ func (f FileOp) Cut(oldPaths []string, dst, name string, cover bool) error {
 }
 
 func (f FileOp) Mv(oldPath, dstPath string) error {
-	cmdStr := fmt.Sprintf("mv %s  %s", oldPath, dstPath)
+	cmdStr := fmt.Sprintf(`mv "%s" "%s"`, oldPath, dstPath)
 	if err := cmd.ExecCmd(cmdStr); err != nil {
 		return err
 	}
@@ -563,40 +552,6 @@ func (f FileOp) Decompress(srcFile string, dst string, cType CompressType) error
 	return nil
 }
 
-func (f FileOp) Backup(srcFile string) (string, error) {
-	backupPath := srcFile + "_bak"
-	info, _ := f.Fs.Stat(backupPath)
-	if info != nil {
-		if info.IsDir() {
-			_ = f.DeleteDir(backupPath)
-		} else {
-			_ = f.DeleteFile(backupPath)
-		}
-	}
-	if err := f.Rename(srcFile, backupPath); err != nil {
-		return backupPath, err
-	}
-
-	return backupPath, nil
-}
-
-func (f FileOp) CopyAndBackup(src string) (string, error) {
-	backupPath := src + "_bak"
-	info, _ := f.Fs.Stat(backupPath)
-	if info != nil {
-		if info.IsDir() {
-			_ = f.DeleteDir(backupPath)
-		} else {
-			_ = f.DeleteFile(backupPath)
-		}
-	}
-	_ = f.CreateDir(backupPath, 0755)
-	if err := f.Copy(src, backupPath); err != nil {
-		return backupPath, err
-	}
-	return backupPath, nil
-}
-
 func ZipFile(files []archiver.File, dst afero.File) error {
 	zw := zip.NewWriter(dst)
 	defer zw.Close()

backend/utils/files/utils.go

@@ -3,6 +3,7 @@ package files
 import (
 	"bufio"
 	"github.com/spf13/afero"
+	"io"
 	"net/http"
 	"os"
 	"os/user"
@@ -87,16 +88,20 @@ func ReadFileByLine(filename string, page, pageSize int) ([]string, bool, error)
 	}
 	defer file.Close()
 
-	scanner := bufio.NewScanner(file)
+	reader := bufio.NewReaderSize(file, 8192)
 
 	var lines []string
 	currentLine := 0
 	startLine := (page - 1) * pageSize
 	endLine := startLine + pageSize
 
-	for scanner.Scan() {
+	for {
+		line, _, err := reader.ReadLine()
+		if err == io.EOF {
+			break
+		}
 		if currentLine >= startLine && currentLine < endLine {
-			lines = append(lines, scanner.Text())
+			lines = append(lines, string(line))
 		}
 		currentLine++
 		if currentLine >= endLine {
@@ -104,10 +109,6 @@ func ReadFileByLine(filename string, page, pageSize int) ([]string, bool, error)
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
-		return nil, false, err
-	}
-
 	isEndOfFile := currentLine < endLine
 
 	return lines, isEndOfFile, nil

backend/utils/firewall/client/firewalld.go

@@ -106,6 +106,7 @@ func (f *Firewall) ListPort() ([]FireInfo, error) {
 			}
 			itemRule := f.loadInfo(rule)
 			if len(itemRule.Port) != 0 && itemRule.Family == "ipv4" {
+				itemRule.Family = ""
 				datas = append(datas, itemRule)
 			}
 		}

backend/utils/firewall/client/ufw.go

@@ -141,7 +141,7 @@ func (f *Ufw) Port(port FireInfo, operation string) error {
 	case "drop":
 		port.Strategy = "deny"
 	default:
-		return fmt.Errorf("unsupport strategy %s", port.Strategy)
+		return fmt.Errorf("unsupported strategy %s", port.Strategy)
 	}
 	if cmd.CheckIllegal(port.Protocol, port.Port) {
 		return buserr.New(constant.ErrCmdIllegal)
@@ -168,7 +168,7 @@ func (f *Ufw) RichRules(rule FireInfo, operation string) error {
 	case "drop":
 		rule.Strategy = "deny"
 	default:
-		return fmt.Errorf("unsupport strategy %s", rule.Strategy)
+		return fmt.Errorf("unsupported strategy %s", rule.Strategy)
 	}
 
 	if cmd.CheckIllegal(operation, rule.Protocol, rule.Address, rule.Port) {

backend/utils/ini_conf/ini.go

@@ -17,20 +17,3 @@ func GetIniValue(filePath, Group, Key string) (string, error) {
 	}
 	return startKey.Value(), nil
 }
-
-func SetIniValue(filePath, Group, Key, value string) error {
-	cfg, err := ini.Load(filePath)
-	if err != nil {
-		return err
-	}
-	service, err := cfg.GetSection(Group)
-	if err != nil {
-		return err
-	}
-	targetKey := service.Key(Key)
-	if err != nil {
-		return err
-	}
-	targetKey.SetValue(value)
-	return cfg.SaveTo(filePath)
-}

backend/utils/mysql/client.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/mysql/client"
 )
 
@@ -50,6 +51,7 @@ func NewMysqlClient(conn client.DBInfo) (MysqlClient, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(conn.Timeout)*time.Second)
 	defer cancel()
 	if err := db.PingContext(ctx); err != nil {
+		global.LOG.Errorf("test mysql conn failed, err: %v", err)
 		return nil, err
 	}
 	if ctx.Err() == context.DeadlineExceeded {