feat: 修改伪静态配置存储目录

#### What this PR does / why we need it?

#### Summary of your change

#### Please indicate you've done the following:

- [ ] Made sure tests are passing and test coverage is added if needed.
- [ ] Made sure commit message follow the rule of [Conventional Commits specification](https://www.conventionalcommits.org/).
- [ ] Considered the docs impact and opened a new docs issue or PR with docs changes if needed.

Makefile

@@ -11,15 +11,19 @@ SERVER_PATH=$(BASE_PAH)/backend
 MAIN= $(BASE_PAH)/cmd/server/main.go
 APP_NAME=1panel
 
-build_web:
+build_frontend:
 	cd $(WEB_PATH) && npm install && npm run build:dev
 
-build_bin:
+build_backend_on_linux:
 	cd $(SERVER_PATH) \
     && CGO_ENABLED=1 GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w --extldflags "-static -fpic"' -tags 'osusergo,netgo' -o $(BUILD_PATH)/$(APP_NAME) $(MAIN)
 
-build_linux_on_mac:
+build_backend_on_darwin:
 	cd $(SERVER_PATH) \
     && CGO_ENABLED=1 GOOS=linux GOARCH=amd64 CC=x86_64-linux-musl-gcc CXX=x86_64-linux-musl-g++ $(GOBUILD) -trimpath -ldflags '-s -w --extldflags "-static -fpic"'  -o $(BUILD_PATH)/$(APP_NAME) $(MAIN)
 
-build_all: build_web  build_bin
+build_backend_on_archlinux:
+	cd $(SERVER_PATH) \
+    && CGO_ENABLED=1 GOOS=$(GOOS) GOARCH=$(GOARCH) $(GOBUILD) -trimpath -ldflags '-s -w --extldflags "-fpic"' -tags osusergo -o $(BUILD_PATH)/$(APP_NAME) $(MAIN)
+
+build_all: build_frontend  build_backend_on_linux

backend/app/api/v1/app.go

@@ -38,8 +38,9 @@ func (b *BaseApi) SearchApp(c *gin.Context) {
 // @Router /apps/sync [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFuntions":[],"formatZH":"应用商店同步","formatEN":"App store synchronization"}
 func (b *BaseApi) SyncApp(c *gin.Context) {
+	appService.SyncAppListFromLocal()
 	global.LOG.Infof("sync app list start ...")
-	if err := appService.SyncAppList(); err != nil {
+	if err := appService.SyncAppListFromRemote(); err != nil {
 		global.LOG.Errorf("sync app list error [%s]", err.Error())
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -71,14 +72,15 @@ func (b *BaseApi) GetApp(c *gin.Context) {
 }
 
 // @Tags App
-// @Summary Search app detail by id
-// @Description 通过 id 获取应用详情
+// @Summary Search app detail by appid
+// @Description 通过 appid 获取应用详情
 // @Accept json
 // @Param appId path integer true "app id"
 // @Param version path string true "app 版本"
+// @Param version path string true "app 类型"
 // @Success 200 {object} response.AppDetailDTO
 // @Security ApiKeyAuth
-// @Router /apps/detail/:appId/:version [get]
+// @Router /apps/detail/:appId/:version/:type [get]
 func (b *BaseApi) GetAppDetail(c *gin.Context) {
 	appId, err := helper.GetIntParamByKey(c, "appId")
 	if err != nil {
@@ -86,7 +88,30 @@ func (b *BaseApi) GetAppDetail(c *gin.Context) {
 		return
 	}
 	version := c.Param("version")
-	appDetailDTO, err := appService.GetAppDetail(appId, version)
+	appType := c.Param("type")
+	appDetailDTO, err := appService.GetAppDetail(appId, version, appType)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, appDetailDTO)
+}
+
+// @Tags App
+// @Summary Get app detail by id
+// @Description 通过 id 获取应用详情
+// @Accept json
+// @Param appId path integer true "id"
+// @Success 200 {object} response.AppDetailDTO
+// @Security ApiKeyAuth
+// @Router /apps/details/:id [get]
+func (b *BaseApi) GetAppDetailByID(c *gin.Context) {
+	appDetailID, err := helper.GetIntParamByKey(c, "id")
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
+		return
+	}
+	appDetailDTO, err := appService.GetAppDetailByID(appDetailID)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return

backend/app/api/v1/app_install.go

@@ -93,24 +93,24 @@ func (b *BaseApi) LoadPort(c *gin.Context) {
 
 // @Tags App
 // @Summary Search app password by key
-// @Description 获取应用密码
+// @Description 获取应用连接信息
 // @Accept json
 // @Param key path string true "request"
-// @Success 200 {string} password
+// @Success 200 {string} response.DatabaseConn
 // @Security ApiKeyAuth
-// @Router /apps/installed/loadpassword/:key [get]
-func (b *BaseApi) LoadPassword(c *gin.Context) {
+// @Router /apps/installed/conninfo/:key [get]
+func (b *BaseApi) LoadConnInfo(c *gin.Context) {
 	key, ok := c.Params.Get("key")
 	if !ok {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, errors.New("error key in path"))
 		return
 	}
-	password, err := appInstallService.LoadPassword(key)
+	conn, err := appInstallService.LoadConnInfo(key)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	helper.SuccessWithData(c, password)
+	helper.SuccessWithData(c, conn)
 }
 
 // @Tags App

backend/app/api/v1/backup.go

@@ -104,9 +104,9 @@ func (b *BaseApi) ListBuckets(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Router /settings/backup/del [post]
-// @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"ids","isList":true,"db":"backup_accounts","output_colume":"type","output_value":"types"}],"formatZH":"删除备份账号 [types]","formatEN":"delete backup account [types]"}
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":true,"db":"backup_accounts","output_colume":"type","output_value":"types"}],"formatZH":"删除备份账号 [types]","formatEN":"delete backup account [types]"}
 func (b *BaseApi) DeleteBackup(c *gin.Context) {
-	var req dto.BatchDeleteReq
+	var req dto.OperateByID
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -116,7 +116,7 @@ func (b *BaseApi) DeleteBackup(c *gin.Context) {
 		return
 	}
 
-	if err := backupService.BatchDelete(req.Ids); err != nil {
+	if err := backupService.Delete(req.ID); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}

backend/app/api/v1/cronjob.go

@@ -92,17 +92,41 @@ func (b *BaseApi) SearchJobRecords(c *gin.Context) {
 	})
 }
 
+// @Tags Cronjob
+// @Summary Clean job records
+// @Description 清空计划任务记录
+// @Accept json
+// @Param request body dto.CronjobClean true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /cronjobs/records/clean [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"cronjobs","output_colume":"name","output_value":"name"}],"formatZH":"清空计划任务记录 [name]","formatEN":"clean cronjob [name] records"}
+func (b *BaseApi) CleanRecord(c *gin.Context) {
+	var req dto.CronjobClean
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+
+	if err := cronjobService.CleanRecord(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, nil)
+}
+
 // @Tags Cronjob
 // @Summary Delete cronjob
 // @Description 删除计划任务
 // @Accept json
-// @Param request body dto.BatchDeleteReq true "request"
+// @Param request body dto.CronjobBatchDelete true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Router /cronjobs/del [post]
 // @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"ids","isList":true,"db":"cronjobs","output_colume":"name","output_value":"names"}],"formatZH":"删除计划任务 [names]","formatEN":"delete cronjob [names]"}
 func (b *BaseApi) DeleteCronjob(c *gin.Context) {
-	var req dto.BatchDeleteReq
+	var req dto.CronjobBatchDelete
 	if err := c.ShouldBindJSON(&req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
@@ -112,7 +136,7 @@ func (b *BaseApi) DeleteCronjob(c *gin.Context) {
 		return
 	}
 
-	if err := cronjobService.Delete(req.Ids); err != nil {
+	if err := cronjobService.Delete(req); err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}

backend/app/api/v1/docker.go

@@ -1,7 +1,6 @@
 package v1
 
 import (
-	"io/ioutil"
 	"os"
 
 	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
@@ -35,7 +34,7 @@ func (b *BaseApi) LoadDaemonJsonFile(c *gin.Context) {
 		helper.SuccessWithData(c, "daemon.json is not find in path")
 		return
 	}
-	content, err := ioutil.ReadFile(constant.DaemonJsonPath)
+	content, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return

backend/app/api/v1/entry.go

@@ -9,40 +9,43 @@ type ApiGroup struct {
 var ApiGroupApp = new(ApiGroup)
 
 var (
-	authService      = service.ServiceGroupApp.AuthService
-	dashboardService = service.ServiceGroupApp.DashboardService
+	authService      = service.NewIAuthService()
+	dashboardService = service.NewIDashboardService()
 
 	appService        = service.NewIAppService()
-	appInstallService = service.ServiceGroupApp.AppInstallService
+	appInstallService = service.NewIAppInstalledService()
 
-	containerService       = service.ServiceGroupApp.ContainerService
-	composeTemplateService = service.ServiceGroupApp.ComposeTemplateService
-	imageRepoService       = service.ServiceGroupApp.ImageRepoService
-	imageService           = service.ServiceGroupApp.ImageService
-	dockerService          = service.ServiceGroupApp.DockerService
+	containerService       = service.NewIContainerService()
+	composeTemplateService = service.NewIComposeTemplateService()
+	imageRepoService       = service.NewIImageRepoService()
+	imageService           = service.NewIImageService()
+	dockerService          = service.NewIDockerService()
 
-	mysqlService = service.ServiceGroupApp.MysqlService
-	redisService = service.ServiceGroupApp.RedisService
+	mysqlService = service.NewIMysqlService()
+	redisService = service.NewIRedisService()
 
-	cronjobService = service.ServiceGroupApp.CronjobService
+	cronjobService = service.NewICronjobService()
 
-	hostService  = service.ServiceGroupApp.HostService
-	groupService = service.ServiceGroupApp.GroupService
-	fileService  = service.ServiceGroupApp.FileService
+	hostService  = service.NewIHostService()
+	groupService = service.NewIGroupService()
+	fileService  = service.NewIFileService()
+	firewallService = service.NewIFirewallService()
 
-	settingService = service.ServiceGroupApp.SettingService
-	backupService  = service.ServiceGroupApp.BackupService
+	settingService = service.NewISettingService()
+	backupService  = service.NewIBackupService()
 
-	commandService = service.ServiceGroupApp.CommandService
+	commandService = service.NewICommandService()
 
-	websiteService            = service.ServiceGroupApp.WebsiteService
-	websiteDnsAccountService  = service.ServiceGroupApp.WebsiteDnsAccountService
-	websiteSSLService         = service.ServiceGroupApp.WebsiteSSLService
-	websiteAcmeAccountService = service.ServiceGroupApp.WebsiteAcmeAccountService
+	websiteService            = service.NewIWebsiteService()
+	websiteDnsAccountService  = service.NewIWebsiteDnsAccountService()
+	websiteSSLService         = service.NewIWebsiteSSLService()
+	websiteAcmeAccountService = service.NewIWebsiteAcmeAccountService()
 
-	nginxService = service.ServiceGroupApp.NginxService
+	nginxService = service.NewINginxService()
 
-	logService      = service.ServiceGroupApp.LogService
-	snapshotService = service.ServiceGroupApp.SnapshotService
-	upgradeService  = service.ServiceGroupApp.UpgradeService
+	logService      = service.NewILogService()
+	snapshotService = service.NewISnapshotService()
+	upgradeService  = service.NewIUpgradeService()
+
+	runtimeService = service.NewRuntimeService()
 )

backend/app/api/v1/file.go

@@ -3,7 +3,7 @@ package v1
 import (
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 	"path"
@@ -510,7 +510,7 @@ func (b *BaseApi) LoadFromFile(c *gin.Context) {
 		return
 	}
 
-	content, err := ioutil.ReadFile(req.Path)
+	content, err := os.ReadFile(req.Path)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -533,7 +533,7 @@ func mergeChunks(fileName string, fileDir string, dstDir string, chunkCount int)
 
 	for i := 0; i < chunkCount; i++ {
 		chunkPath := filepath.Join(fileDir, fmt.Sprintf("%s.%d", fileName, i))
-		chunkData, err := ioutil.ReadFile(chunkPath)
+		chunkData, err := os.ReadFile(chunkPath)
 		if err != nil {
 			return err
 		}
@@ -599,14 +599,14 @@ func (b *BaseApi) UploadChunkFiles(c *gin.Context) {
 	}
 	defer emptyFile.Close()
 
-	chunkData, err := ioutil.ReadAll(uploadFile)
+	chunkData, err := io.ReadAll(uploadFile)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrFileUpload, err)
 		return
 	}
 
 	chunkPath := filepath.Join(fileDir, fmt.Sprintf("%s.%d", filename, chunkIndex))
-	err = ioutil.WriteFile(chunkPath, chunkData, 0644)
+	err = os.WriteFile(chunkPath, chunkData, 0644)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrFileUpload, err)
 		return

backend/app/api/v1/firewall.go

@@ -0,0 +1,207 @@
+package v1
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags Firewall
+// @Summary Load firewall base info
+// @Description 获取防火墙基础信息
+// @Success 200 {object} dto.FirewallBaseInfo
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/base [get]
+func (b *BaseApi) LoadFirewallBaseInfo(c *gin.Context) {
+	data, err := firewallService.LoadBaseInfo()
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, data)
+}
+
+// @Tags Firewall
+// @Summary Page firewall rules
+// @Description 获取防火墙规则列表分页
+// @Accept json
+// @Param request body dto.SearchWithPage true "request"
+// @Success 200 {object} dto.PageResult
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/search [post]
+func (b *BaseApi) SearchFirewallRule(c *gin.Context) {
+	var req dto.RuleSearch
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+
+	total, list, err := firewallService.SearchWithPage(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Items: list,
+		Total: total,
+	})
+}
+
+// @Tags Firewall
+// @Summary Page firewall status
+// @Description 修改防火墙状态
+// @Accept json
+// @Param request body dto.FirewallOperation true "request"
+// @Success 200 {object} dto.PageResult
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/operate [post]
+// @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"[operation] 防火墙","formatEN":"[operation] firewall"}
+func (b *BaseApi) OperateFirewall(c *gin.Context) {
+	var req dto.FirewallOperation
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+
+	if err := firewallService.OperateFirewall(req.Operation); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Firewall
+// @Summary Create group
+// @Description 创建防火墙端口规则
+// @Accept json
+// @Param request body dto.PortRuleOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/port [post]
+// @x-panel-log {"bodyKeys":["port","strategy"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"添加端口规则 [strategy] [port]","formatEN":"create port rules [strategy][port]"}
+func (b *BaseApi) OperatePortRule(c *gin.Context) {
+	var req dto.PortRuleOperate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := firewallService.OperatePortRule(req, true); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Firewall
+// @Summary Create group
+// @Description 创建防火墙 IP 规则
+// @Accept json
+// @Param request body dto.AddrRuleOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/ip [post]
+// @x-panel-log {"bodyKeys":["strategy","address"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"添加 ip 规则 [strategy] [address]","formatEN":"create address rules [strategy][address]"}
+func (b *BaseApi) OperateIPRule(c *gin.Context) {
+	var req dto.AddrRuleOperate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := firewallService.OperateAddressRule(req, true); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Firewall
+// @Summary Create group
+// @Description 批量删除防火墙规则
+// @Accept json
+// @Param request body dto.BatchRuleOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/ip [post]
+func (b *BaseApi) BatchOperateRule(c *gin.Context) {
+	var req dto.BatchRuleOperate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := firewallService.BacthOperateRule(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Firewall
+// @Summary Create group
+// @Description 更新端口防火墙规则
+// @Accept json
+// @Param request body dto.PortRuleUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/update/port [post]
+func (b *BaseApi) UpdatePortRule(c *gin.Context) {
+	var req dto.PortRuleUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := firewallService.UpdatePortRule(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Firewall
+// @Summary Create group
+// @Description 更新 ip 防火墙规则
+// @Accept json
+// @Param request body dto.AddrRuleUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /hosts/firewall/update/ip [post]
+func (b *BaseApi) UpdateAddrRule(c *gin.Context) {
+	var req dto.AddrRuleUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := global.VALID.Struct(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := firewallService.UpdateAddrRule(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}

backend/app/api/v1/group.go

@@ -15,7 +15,7 @@ import (
 // @Param request body dto.GroupCreate true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /hosts/group [post]
+// @Router /groups [post]
 // @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"创建组 [name][type]","formatEN":"create group [name][type]"}
 func (b *BaseApi) CreateGroup(c *gin.Context) {
 	var req dto.GroupCreate
@@ -41,7 +41,7 @@ func (b *BaseApi) CreateGroup(c *gin.Context) {
 // @Param request body dto.OperateByID true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /hosts/group/del [post]
+// @Router /groups/del [post]
 // @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"groups","output_colume":"name","output_value":"name"},{"input_colume":"id","input_value":"id","isList":false,"db":"groups","output_colume":"type","output_value":"type"}],"formatZH":"删除组 [type][name]","formatEN":"delete group [type][name]"}
 func (b *BaseApi) DeleteGroup(c *gin.Context) {
 	var req dto.OperateByID
@@ -68,7 +68,7 @@ func (b *BaseApi) DeleteGroup(c *gin.Context) {
 // @Param request body dto.GroupUpdate true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /hosts/group/update [post]
+// @Router /groups/update [post]
 // @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"更新组 [name][type]","formatEN":"update group [name][type]"}
 func (b *BaseApi) UpdateGroup(c *gin.Context) {
 	var req dto.GroupUpdate
@@ -94,7 +94,7 @@ func (b *BaseApi) UpdateGroup(c *gin.Context) {
 // @Param request body dto.GroupSearch true "request"
 // @Success 200 {anrry} dto.GroupInfo
 // @Security ApiKeyAuth
-// @Router /hosts/group/search [post]
+// @Router /groups/search [post]
 func (b *BaseApi) ListGroup(c *gin.Context) {
 	var req dto.GroupSearch
 	if err := c.ShouldBindJSON(&req); err != nil {

backend/app/api/v1/helper/helper.go

@@ -83,6 +83,15 @@ func SuccessWithData(ctx *gin.Context, data interface{}) {
 	ctx.Abort()
 }
 
+func SuccessWithOutData(ctx *gin.Context) {
+	res := dto.Response{
+		Code:    constant.CodeSuccess,
+		Message: "success",
+	}
+	ctx.JSON(http.StatusOK, res)
+	ctx.Abort()
+}
+
 func SuccessWithMsg(ctx *gin.Context, msg string) {
 	res := dto.Response{
 		Code:    constant.CodeSuccess,

backend/app/api/v1/host.go

@@ -8,7 +8,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/copier"
-	"github.com/1Panel-dev/1Panel/backend/utils/ssh"
 	"github.com/gin-gonic/gin"
 )
 
@@ -74,33 +73,9 @@ func (b *BaseApi) TestByInfo(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	if req.AuthMode == "password" && len(req.Password) != 0 {
-		password, err := base64.StdEncoding.DecodeString(req.Password)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.Password = string(password)
-	}
-	if req.AuthMode == "key" && len(req.PrivateKey) != 0 {
-		privateKey, err := base64.StdEncoding.DecodeString(req.PrivateKey)
-		if err != nil {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
-			return
-		}
-		req.PrivateKey = string(privateKey)
-	}
 
-	var connInfo ssh.ConnInfo
-	_ = copier.Copy(&connInfo, &req)
-	connInfo.PrivateKey = []byte(req.PrivateKey)
-	client, err := connInfo.NewClient()
-	if err != nil {
-		helper.SuccessWithData(c, false)
-		return
-	}
-	defer client.Close()
-	helper.SuccessWithData(c, true)
+	connStatus := hostService.TestByInfo(req)
+	helper.SuccessWithData(c, connStatus)
 }
 
 // @Tags Host
@@ -270,11 +245,13 @@ func (b *BaseApi) UpdateHost(c *gin.Context) {
 	upMap["port"] = req.Port
 	upMap["user"] = req.User
 	upMap["auth_mode"] = req.AuthMode
+	upMap["remember_password"] = req.RememberPassword
 	if len(req.Password) != 0 {
 		upMap["password"] = req.Password
 	}
 	if len(req.PrivateKey) != 0 {
 		upMap["private_key"] = req.PrivateKey
+		upMap["pass_phrase"] = req.PassPhrase
 	}
 	upMap["description"] = req.Description
 	if err := hostService.Update(req.ID, upMap); err != nil {
@@ -291,7 +268,7 @@ func (b *BaseApi) UpdateHost(c *gin.Context) {
 // @Param request body dto.ChangeHostGroup true "request"
 // @Success 200
 // @Security ApiKeyAuth
-// @Router /hosts/update [post]
+// @Router /hosts/update/group [post]
 // @x-panel-log {"bodyKeys":["id","group"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"hosts","output_colume":"addr","output_value":"addr"}],"formatZH":"切换主机[addr]分组 => [group]","formatEN":"change host [addr] group => [group]"}
 func (b *BaseApi) UpdateHostGroup(c *gin.Context) {
 	var req dto.ChangeHostGroup

backend/app/api/v1/runtime.go

@@ -0,0 +1,123 @@
+package v1
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags Runtime
+// @Summary List runtimes
+// @Description 获取运行环境列表
+// @Accept json
+// @Param request body request.RuntimeSearch true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes/search [post]
+func (b *BaseApi) SearchRuntimes(c *gin.Context) {
+	var req request.RuntimeSearch
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	total, items, err := runtimeService.Page(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, dto.PageResult{
+		Total: total,
+		Items: items,
+	})
+}
+
+// @Tags Runtime
+// @Summary Create runtime
+// @Description 创建运行环境
+// @Accept json
+// @Param request body request.RuntimeCreate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes [post]
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"创建运行环境 [name]","formatEN":"Create runtime [name]"}
+func (b *BaseApi) CreateRuntime(c *gin.Context) {
+	var req request.RuntimeCreate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := runtimeService.Create(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags Website
+// @Summary Delete runtime
+// @Description 删除运行环境
+// @Accept json
+// @Param request body request.RuntimeDelete true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes/del [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"删除网站 [name]","formatEN":"Delete website [name]"}
+func (b *BaseApi) DeleteRuntime(c *gin.Context) {
+	var req request.RuntimeDelete
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	err := runtimeService.Delete(req.ID)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags Runtime
+// @Summary Update runtime
+// @Description 更新运行环境
+// @Accept json
+// @Param request body request.RuntimeUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes/update [post]
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFuntions":[],"formatZH":"更新运行环境 [name]","formatEN":"Update runtime [name]"}
+func (b *BaseApi) UpdateRuntime(c *gin.Context) {
+	var req request.RuntimeUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := runtimeService.Update(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags Runtime
+// @Summary Get runtime
+// @Description 获取运行环境
+// @Accept json
+// @Param id path string true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /runtimes/:id [get]
+func (b *BaseApi) GetRuntime(c *gin.Context) {
+	id, err := helper.GetIntParamByKey(c, "id")
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
+		return
+	}
+	res, err := runtimeService.Get(id)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, res)
+}

backend/app/api/v1/terminal.go

@@ -1,6 +1,8 @@
 package v1
 
 import (
+	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -42,6 +44,9 @@ func (b *BaseApi) WsSsh(c *gin.Context) {
 	var connInfo ssh.ConnInfo
 	_ = copier.Copy(&connInfo, &host)
 	connInfo.PrivateKey = []byte(host.PrivateKey)
+	if len(host.PassPhrase) != 0 {
+		connInfo.PassPhrase = []byte(host.PassPhrase)
+	}
 
 	wsConn, err := upGrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {
@@ -196,7 +201,15 @@ func wshandleError(ws *websocket.Conn, err error) bool {
 		global.LOG.Errorf("handler ws faled:, err: %v", err)
 		dt := time.Now().Add(time.Second)
 		if ctlerr := ws.WriteControl(websocket.CloseMessage, []byte(err.Error()), dt); ctlerr != nil {
-			_ = ws.WriteMessage(websocket.TextMessage, []byte(err.Error()))
+			wsData, err := json.Marshal(terminal.WsMsg{
+				Type: terminal.WsMsgCmd,
+				Data: base64.StdEncoding.EncodeToString([]byte(err.Error())),
+			})
+			if err != nil {
+				_ = ws.WriteMessage(websocket.TextMessage, []byte("{\"type\":\"cmd\",\"data\":\"failed to encoding to json\"}"))
+			} else {
+				_ = ws.WriteMessage(websocket.TextMessage, wsData)
+			}
 		}
 		return true
 	}

backend/app/api/v1/website.go

@@ -78,14 +78,12 @@ func (b *BaseApi) CreateWebsite(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	tx, ctx := helper.GetTxAndContext()
-	err := websiteService.CreateWebsite(ctx, req)
+
+	err := websiteService.CreateWebsite(req)
 	if err != nil {
-		tx.Rollback()
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	tx.Commit()
 	helper.SuccessWithData(c, nil)
 }
 
@@ -127,14 +125,12 @@ func (b *BaseApi) DeleteWebsite(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
 		return
 	}
-	tx, ctx := helper.GetTxAndContext()
-	err := websiteService.DeleteWebsite(ctx, req)
+
+	err := websiteService.DeleteWebsite(req)
 	if err != nil {
-		tx.Rollback()
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
-	tx.Commit()
 	helper.SuccessWithData(c, nil)
 }
 
@@ -189,14 +185,16 @@ func (b *BaseApi) GetWebsite(c *gin.Context) {
 // @Param id path integer true "request"
 // @Success 200 {object} response.FileInfo
 // @Security ApiKeyAuth
-// @Router /websites/:id/nginx [get]
+// @Router /websites/:id/config/:type [get]
 func (b *BaseApi) GetWebsiteNginx(c *gin.Context) {
 	id, err := helper.GetParamID(c)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
 		return
 	}
-	fileInfo, err := websiteService.GetWebsiteNginxConfig(id)
+	configType := c.Param("type")
+
+	fileInfo, err := websiteService.GetWebsiteNginxConfig(id, configType)
 	if err != nil {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
@@ -496,3 +494,157 @@ func (b *BaseApi) ChangeDefaultServer(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, nil)
 }
+
+// @Tags Website
+// @Summary Load websit php conf
+// @Description 获取网站 php 配置
+// @Accept json
+// @Param id path integer true "request"
+// @Success 200 {object} response.PHPConfig
+// @Security ApiKeyAuth
+// @Router /websites/php/config/:id [get]
+func (b *BaseApi) GetWebsitePHPConfig(c *gin.Context) {
+	id, err := helper.GetParamID(c)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInternalServer, nil)
+		return
+	}
+	data, err := websiteService.GetPHPConfig(id)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, data)
+}
+
+// @Tags Website PHP
+// @Summary Update website php conf
+// @Description 更新 网站 PHP 配置
+// @Accept json
+// @Param request body request.WebsitePHPConfigUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/php/config [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"websites","output_colume":"primary_domain","output_value":"domain"}],"formatZH":"[domain] PHP 配置修改","formatEN":"[domain] PHP conf update"}
+func (b *BaseApi) UpdateWebsitePHPConfig(c *gin.Context) {
+	var req request.WebsitePHPConfigUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := websiteService.UpdatePHPConfig(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Website PHP
+// @Summary Update php conf
+// @Description 更新 php 配置
+// @Accept json
+// @Param request body request.WebsitePHPFileUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/php/update [post]
+// @x-panel-log {"bodyKeys":["websiteId"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"websiteId","isList":false,"db":"websites","output_colume":"primary_domain","output_value":"domain"}],"formatZH":"php 配置修改 [domain]","formatEN":"Nginx conf update [domain]"}
+func (b *BaseApi) UpdatePHPFile(c *gin.Context) {
+	var req request.WebsitePHPFileUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := websiteService.UpdatePHPConfigFile(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Website
+// @Summary Get rewrite conf
+// @Description 获取伪静态配置
+// @Accept json
+// @Param request body request.NginxRewriteReq true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/rewrite [post]
+func (b *BaseApi) GetRewriteConfig(c *gin.Context) {
+	var req request.NginxRewriteReq
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	res, err := websiteService.GetRewriteConfig(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, res)
+}
+
+// @Tags Website
+// @Summary Update rewrite conf
+// @Description 更新伪静态配置
+// @Accept json
+// @Param request body request.NginxRewriteUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/rewrite/update [post]
+// @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"websiteID","isList":false,"db":"websites","output_colume":"primary_domain","output_value":"domain"}],"formatZH":"伪静态配置修改 [domain]","formatEN":"Nginx conf rewrite update [domain]"}
+func (b *BaseApi) UpdateRewriteConfig(c *gin.Context) {
+	var req request.NginxRewriteUpdate
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := websiteService.UpdateRewriteConfig(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags Website
+// @Summary Update Site Dir
+// @Description 更新网站目录
+// @Accept json
+// @Param request body request.WebsiteUpdateDir true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/dir/update [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"websites","output_colume":"primary_domain","output_value":"domain"}],"formatZH":"更新网站 [domain] 目录","formatEN":"Update  domain [domain] dir"}
+func (b *BaseApi) UpdateSiteDir(c *gin.Context) {
+	var req request.WebsiteUpdateDir
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := websiteService.UpdateSiteDir(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags Website
+// @Summary Update Site Dir permission
+// @Description 更新网站目录权限
+// @Accept json
+// @Param request body request.WebsiteUpdateDirPermission true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Router /websites/dir/permission [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFuntions":[{"input_colume":"id","input_value":"id","isList":false,"db":"websites","output_colume":"primary_domain","output_value":"domain"}],"formatZH":"更新网站 [domain] 目录权限","formatEN":"Update  domain [domain] dir permission"}
+func (b *BaseApi) UpdateSiteDirPermission(c *gin.Context) {
+	var req request.WebsiteUpdateDirPermission
+	if err := c.ShouldBindJSON(&req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, err)
+		return
+	}
+	if err := websiteService.UpdateSitePermission(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}

backend/app/dto/app.go

@@ -78,6 +78,7 @@ type AppFormFields struct {
 	Disabled bool           `json:"disabled"`
 	Edit     bool           `json:"edit"`
 	Rule     string         `json:"rule"`
+	Multiple bool           `json:"multiple"`
 	Values   []AppFormValue `json:"values"`
 }
 

backend/app/dto/backup.go

@@ -59,7 +59,7 @@ type BackupRecords struct {
 }
 
 type DownloadRecord struct {
-	Source   string `json:"source" validate:"required,oneof=OSS S3 SFTP MINIO LOCAL"`
+	Source   string `json:"source" validate:"required,oneof=OSS S3 SFTP MINIO LOCAL COS KODO"`
 	FileDir  string `json:"fileDir" validate:"required"`
 	FileName string `json:"fileName" validate:"required"`
 }

backend/app/dto/cronjob.go

@@ -52,6 +52,16 @@ type CronjobDownload struct {
 	BackupAccountID uint `json:"backupAccountID" validate:"required"`
 }
 
+type CronjobClean struct {
+	CleanData bool `json:"cleanData"`
+	CronjobID uint `json:"cronjobID" validate:"required"`
+}
+
+type CronjobBatchDelete struct {
+	CleanData bool   `json:"cleanData"`
+	IDs       []uint `json:"ids"`
+}
+
 type CronjobInfo struct {
 	ID       uint   `json:"id"`
 	Name     string `json:"name"`

backend/app/dto/docker.go

@@ -5,11 +5,13 @@ type DaemonJsonUpdateByFile struct {
 }
 
 type DaemonJsonConf struct {
+	IsSwarm      bool     `json:"isSwarm"`
 	Status       string   `json:"status"`
 	Version      string   `json:"version"`
 	Mirrors      []string `json:"registryMirrors"`
 	Registries   []string `json:"insecureRegistries"`
 	LiveRestore  bool     `json:"liveRestore"`
+	IPTables     bool     `json:"iptables"`
 	CgroupDriver string   `json:"cgroupDriver"`
 }
 

backend/app/dto/firewall.go

@@ -0,0 +1,47 @@
+package dto
+
+type FirewallBaseInfo struct {
+	Name       string `json:"name"`
+	Status     string `json:"status"`
+	Version    string `json:"version"`
+	PingStatus string `json:"pingStatus"`
+}
+
+type RuleSearch struct {
+	PageInfo
+	Info string `json:"info"`
+	Type string `json:"type" validate:"required"`
+}
+
+type FirewallOperation struct {
+	Operation string `json:"operation" validate:"required,oneof=start stop disablePing enablePing"`
+}
+
+type PortRuleOperate struct {
+	Operation string `json:"operation" validate:"required,oneof=add remove"`
+	Address   string `json:"address"`
+	Port      string `json:"port" validate:"required"`
+	Protocol  string `json:"protocol" validate:"required,oneof=tcp udp tcp/udp"`
+	Strategy  string `json:"strategy" validate:"required,oneof=accept drop"`
+}
+
+type AddrRuleOperate struct {
+	Operation string `json:"operation" validate:"required,oneof=add remove"`
+	Address   string `json:"address"  validate:"required"`
+	Strategy  string `json:"strategy" validate:"required,oneof=accept drop"`
+}
+
+type PortRuleUpdate struct {
+	OldRule PortRuleOperate `json:"oldRule"`
+	NewRule PortRuleOperate `json:"newRule"`
+}
+
+type AddrRuleUpdate struct {
+	OldRule AddrRuleOperate `json:"oldRule"`
+	NewRule AddrRuleOperate `json:"newRule"`
+}
+
+type BatchRuleOperate struct {
+	Type  string            `json:"type" validate:"required"`
+	Rules []PortRuleOperate `json:"rules"`
+}

backend/app/dto/host.go

@@ -5,15 +5,17 @@ import (
 )
 
 type HostOperate struct {
-	ID         uint   `json:"id"`
-	GroupID    uint   `json:"groupID"`
-	Name       string `json:"name"`
-	Addr       string `json:"addr" validate:"required"`
-	Port       uint   `json:"port" validate:"required,number,max=65535,min=1"`
-	User       string `json:"user" validate:"required"`
-	AuthMode   string `json:"authMode" validate:"oneof=password key"`
-	PrivateKey string `json:"privateKey"`
-	Password   string `json:"password"`
+	ID               uint   `json:"id"`
+	GroupID          uint   `json:"groupID"`
+	Name             string `json:"name"`
+	Addr             string `json:"addr" validate:"required"`
+	Port             uint   `json:"port" validate:"required,number,max=65535,min=1"`
+	User             string `json:"user" validate:"required"`
+	AuthMode         string `json:"authMode" validate:"oneof=password key"`
+	Password         string `json:"password"`
+	PrivateKey       string `json:"privateKey"`
+	PassPhrase       string `json:"passPhrase"`
+	RememberPassword bool   `json:"rememberPassword"`
 
 	Description string `json:"description"`
 }
@@ -23,8 +25,9 @@ type HostConnTest struct {
 	Port       uint   `json:"port" validate:"required,number,max=65535,min=1"`
 	User       string `json:"user" validate:"required"`
 	AuthMode   string `json:"authMode" validate:"oneof=password key"`
-	PrivateKey string `json:"privateKey"`
 	Password   string `json:"password"`
+	PrivateKey string `json:"privateKey"`
+	PassPhrase string `json:"passPhrase"`
 }
 
 type SearchHostWithPage struct {
@@ -43,15 +46,19 @@ type ChangeHostGroup struct {
 }
 
 type HostInfo struct {
-	ID          uint      `json:"id"`
-	CreatedAt   time.Time `json:"createdAt"`
-	GroupID     uint      `json:"groupID"`
-	GroupBelong string    `json:"groupBelong"`
-	Name        string    `json:"name"`
-	Addr        string    `json:"addr"`
-	Port        uint      `json:"port"`
-	User        string    `json:"user"`
-	AuthMode    string    `json:"authMode"`
+	ID               uint      `json:"id"`
+	CreatedAt        time.Time `json:"createdAt"`
+	GroupID          uint      `json:"groupID"`
+	GroupBelong      string    `json:"groupBelong"`
+	Name             string    `json:"name"`
+	Addr             string    `json:"addr"`
+	Port             uint      `json:"port"`
+	User             string    `json:"user"`
+	AuthMode         string    `json:"authMode"`
+	Password         string    `json:"password"`
+	PrivateKey       string    `json:"privateKey"`
+	PassPhrase       string    `json:"passPhrase"`
+	RememberPassword bool      `json:"rememberPassword"`
 
 	Description string `json:"description"`
 }

backend/app/dto/request/nginx.go

@@ -19,3 +19,14 @@ type NginxConfigUpdate struct {
 	WebsiteID uint         `json:"websiteId" validate:"required"`
 	Params    interface{}  `json:"params"`
 }
+
+type NginxRewriteReq struct {
+	WebsiteID uint   `json:"websiteId" validate:"required"`
+	Name      string `json:"name" validate:"required"`
+}
+
+type NginxRewriteUpdate struct {
+	WebsiteID uint   `json:"websiteId" validate:"required"`
+	Name      string `json:"name" validate:"required"`
+	Content   string `json:"content" validate:"required"`
+}

backend/app/dto/request/runtime.go

@@ -0,0 +1,32 @@
+package request
+
+import "github.com/1Panel-dev/1Panel/backend/app/dto"
+
+type RuntimeSearch struct {
+	dto.PageInfo
+	Type   string `json:"type"`
+	Name   string `json:"name"`
+	Status string `json:"status"`
+}
+
+type RuntimeCreate struct {
+	AppDetailID uint                   `json:"appDetailId"`
+	Name        string                 `json:"name"`
+	Params      map[string]interface{} `json:"params"`
+	Resource    string                 `json:"resource"`
+	Image       string                 `json:"image"`
+	Type        string                 `json:"type"`
+	Version     string                 `json:"version"`
+}
+
+type RuntimeDelete struct {
+	ID uint `json:"id"`
+}
+
+type RuntimeUpdate struct {
+	Name    string                 `json:"name"`
+	ID      uint                   `json:"id"`
+	Params  map[string]interface{} `json:"params"`
+	Image   string                 `json:"image"`
+	Version string                 `json:"version"`
+}

backend/app/dto/request/website.go

@@ -23,6 +23,14 @@ type WebsiteCreate struct {
 	AppInstall   NewAppInstall `json:"appInstall"`
 	AppID        uint          `json:"appID"`
 	AppInstallID uint          `json:"appInstallID"`
+
+	RuntimeID uint `json:"runtimeID"`
+	RuntimeConfig
+}
+
+type RuntimeConfig struct {
+	ProxyType string `json:"proxyType"`
+	Port      int    `json:"port"`
 }
 
 type NewAppInstall struct {
@@ -126,3 +134,25 @@ type WebsiteLogReq struct {
 type WebsiteDefaultUpdate struct {
 	ID uint `json:"id" validate:"required"`
 }
+
+type WebsitePHPConfigUpdate struct {
+	ID     uint              `json:"id" validate:"required"`
+	Params map[string]string `json:"params" validate:"required"`
+}
+
+type WebsitePHPFileUpdate struct {
+	ID      uint   `json:"id" validate:"required"`
+	Type    string `json:"type" validate:"required"`
+	Content string `json:"content" validate:"required"`
+}
+
+type WebsiteUpdateDir struct {
+	ID      uint   `json:"id" validate:"required"`
+	SiteDir string `json:"siteDir" validate:"required"`
+}
+
+type WebsiteUpdateDirPermission struct {
+	ID    uint   `json:"id" validate:"required"`
+	User  string `json:"user" validate:"required"`
+	Group string `json:"group" validate:"required"`
+}

backend/app/dto/response/app.go

@@ -1,8 +1,9 @@
 package response
 
 import (
-	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"time"
+
+	"github.com/1Panel-dev/1Panel/backend/app/model"
 )
 
 type AppRes struct {
@@ -43,6 +44,7 @@ type AppDetailDTO struct {
 	model.AppDetail
 	Enable bool        `json:"enable"`
 	Params interface{} `json:"params"`
+	Image  string      `json:"image"`
 }
 
 type AppInstalledDTO struct {
@@ -54,6 +56,12 @@ type AppInstalledDTO struct {
 	CanUpdate bool   `json:"canUpdate"`
 }
 
+type DatabaseConn struct {
+	Password    string `json:"password"`
+	ServiceName string `json:"serviceName"`
+	Port        int64  `json:"port"`
+}
+
 type AppService struct {
 	Label  string      `json:"label"`
 	Value  string      `json:"value"`
@@ -70,4 +78,6 @@ type AppParam struct {
 	Type      string      `json:"type"`
 	Values    interface{} `json:"values"`
 	ShowValue string      `json:"showValue"`
+	Required  bool        `json:"required"`
+	Multiple  bool        `json:"multiple"`
 }

backend/app/dto/response/runtime.go

@@ -0,0 +1,9 @@
+package response
+
+import "github.com/1Panel-dev/1Panel/backend/app/model"
+
+type RuntimeRes struct {
+	model.Runtime
+	AppParams []AppParam `json:"appParams"`
+	AppID     uint       `json:"appId"`
+}

backend/app/dto/response/website.go

@@ -10,6 +10,7 @@ type WebsiteDTO struct {
 	AccessLogPath string `json:"accessLogPath"`
 	SitePath      string `json:"sitePath"`
 	AppName       string `json:"appName"`
+	RuntimeName   string `json:"runtimeName"`
 }
 
 type WebsitePreInstallCheck struct {
@@ -42,3 +43,11 @@ type WebsiteLog struct {
 	Enable  bool   `json:"enable"`
 	Content string `json:"content"`
 }
+
+type PHPConfig struct {
+	Params map[string]string `json:"params"`
+}
+
+type NginxRewriteRes struct {
+	Content string `json:"content"`
+}

backend/app/dto/setting.go

@@ -49,7 +49,7 @@ type PortUpdate struct {
 }
 
 type SnapshotCreate struct {
-	From        string `json:"from" validate:"required,oneof=OSS S3 SFTP MINIO"`
+	From        string `json:"from" validate:"required,oneof=OSS S3 SFTP MINIO COS KODO"`
 	Description string `json:"description"`
 }
 type SnapshotRecover struct {

backend/app/model/app.go

@@ -16,6 +16,7 @@ type App struct {
 	Github             string      `json:"github" gorm:"type:varchar(64);not null"`
 	Document           string      `json:"document" gorm:"type:varchar(64);not null"`
 	Recommend          int         `json:"recommend" gorm:"type:Integer;not null"`
+	Resource           string      `json:"resource" gorm:"type:varchar;not null;default:remote"`
 	Details            []AppDetail `json:"-" gorm:"-:migration"`
 	TagsKey            []string    `json:"-" gorm:"-"`
 	AppTags            []AppTag    `json:"-" gorm:"-:migration"`

backend/app/model/app_install.go

@@ -2,6 +2,7 @@ package model
 
 import (
 	"path"
+	"strings"
 
 	"github.com/1Panel-dev/1Panel/backend/constant"
 )
@@ -26,9 +27,21 @@ type AppInstall struct {
 }
 
 func (i *AppInstall) GetPath() string {
-	return path.Join(constant.AppInstallDir, i.App.Key, i.Name)
+	return path.Join(i.getAppPath(), i.Name)
 }
 
 func (i *AppInstall) GetComposePath() string {
-	return path.Join(constant.AppInstallDir, i.App.Key, i.Name, "docker-compose.yml")
+	return path.Join(i.getAppPath(), i.Name, "docker-compose.yml")
+}
+
+func (i *AppInstall) GetEnvPath() string {
+	return path.Join(i.getAppPath(), i.Name, ".env")
+}
+
+func (i *AppInstall) getAppPath() string {
+	if i.App.Resource == constant.AppResourceLocal {
+		return path.Join(constant.LocalAppInstallDir, strings.TrimPrefix(i.App.Key, constant.AppResourceLocal))
+	} else {
+		return path.Join(constant.AppInstallDir, i.App.Key)
+	}
 }

backend/app/model/host.go

@@ -2,14 +2,17 @@ package model
 
 type Host struct {
 	BaseModel
-	GroupID    uint   `gorm:"type:decimal;not null" json:"group_id"`
-	Name       string `gorm:"type:varchar(64);not null" json:"name"`
-	Addr       string `gorm:"type:varchar(16);not null" json:"addr"`
-	Port       int    `gorm:"type:decimal;not null" json:"port"`
-	User       string `gorm:"type:varchar(64);not null" json:"user"`
-	AuthMode   string `gorm:"type:varchar(16);not null" json:"authMode"`
-	Password   string `gorm:"type:varchar(64)" json:"password"`
-	PrivateKey string `gorm:"type:varchar(256)" json:"privateKey"`
+
+	GroupID          uint   `gorm:"type:decimal;not null" json:"group_id"`
+	Name             string `gorm:"type:varchar(64);not null" json:"name"`
+	Addr             string `gorm:"type:varchar(16);not null" json:"addr"`
+	Port             int    `gorm:"type:decimal;not null" json:"port"`
+	User             string `gorm:"type:varchar(64);not null" json:"user"`
+	AuthMode         string `gorm:"type:varchar(16);not null" json:"authMode"`
+	Password         string `gorm:"type:varchar(64)" json:"password"`
+	PrivateKey       string `gorm:"type:varchar(256)" json:"privateKey"`
+	PassPhrase       string `gorm:"type:varchar(256)" json:"passPhrase"`
+	RememberPassword bool   `json:"rememberPassword"`
 
 	Description string `gorm:"type:varchar(256)" json:"description"`
 }

backend/app/model/runtime.go

@@ -0,0 +1,17 @@
+package model
+
+type Runtime struct {
+	BaseModel
+	Name          string `gorm:"type:varchar;not null" json:"name"`
+	AppDetailID   uint   `gorm:"type:integer" json:"appDetailId"`
+	Image         string `gorm:"type:varchar" json:"image"`
+	WorkDir       string `gorm:"type:varchar" json:"workDir"`
+	DockerCompose string `gorm:"type:varchar" json:"dockerCompose"`
+	Env           string `gorm:"type:varchar" json:"env"`
+	Params        string `gorm:"type:varchar" json:"params"`
+	Version       string `gorm:"type:varchar;not null" json:"version"`
+	Type          string `gorm:"type:varchar;not null" json:"type"`
+	Status        string `gorm:"type:varchar;not null" json:"status"`
+	Resource      string `gorm:"type:varchar;not null" json:"resource"`
+	Message       string `gorm:"type:longtext;" json:"message"`
+}

backend/app/model/website.go

@@ -4,23 +4,33 @@ import "time"
 
 type Website struct {
 	BaseModel
-	Protocol       string          `gorm:"type:varchar(64);not null" json:"protocol"`
-	PrimaryDomain  string          `gorm:"type:varchar(128);not null" json:"primaryDomain"`
-	Type           string          `gorm:"type:varchar(64);not null" json:"type"`
-	Alias          string          `gorm:"type:varchar(128);not null" json:"alias"`
-	Remark         string          `gorm:"type:longtext;" json:"remark"`
-	Status         string          `gorm:"type:varchar(64);not null" json:"status"`
-	HttpConfig     string          `gorm:"type:varchar(64);not null" json:"httpConfig"`
-	ExpireDate     time.Time       `json:"expireDate"`
-	AppInstallID   uint            `gorm:"type:integer" json:"appInstallId"`
-	WebsiteGroupID uint            `gorm:"type:integer" json:"webSiteGroupId"`
-	WebsiteSSLID   uint            `gorm:"type:integer" json:"webSiteSSLId"`
-	Proxy          string          `gorm:"type:varchar(128);not null" json:"proxy"`
-	ErrorLog       bool            `json:"errorLog"`
-	AccessLog      bool            `json:"accessLog"`
-	DefaultServer  bool            `json:"defaultServer"`
-	Domains        []WebsiteDomain `json:"domains" gorm:"-:migration"`
-	WebsiteSSL     WebsiteSSL      `json:"webSiteSSL" gorm:"-:migration"`
+	Protocol      string    `gorm:"type:varchar;not null" json:"protocol"`
+	PrimaryDomain string    `gorm:"type:varchar;not null" json:"primaryDomain"`
+	Type          string    `gorm:"type:varchar;not null" json:"type"`
+	Alias         string    `gorm:"type:varchar;not null" json:"alias"`
+	Remark        string    `gorm:"type:longtext;" json:"remark"`
+	Status        string    `gorm:"type:varchar;not null" json:"status"`
+	HttpConfig    string    `gorm:"type:varchar;not null" json:"httpConfig"`
+	ExpireDate    time.Time `json:"expireDate"`
+
+	Proxy         string `gorm:"type:varchar;" json:"proxy"`
+	ProxyType     string `gorm:"type:varchar;" json:"proxyType"`
+	SiteDir       string `gorm:"type:varchar;" json:"siteDir"`
+	ErrorLog      bool   `json:"errorLog"`
+	AccessLog     bool   `json:"accessLog"`
+	DefaultServer bool   `json:"defaultServer"`
+	Rewrite       string `gorm:"type:varchar" json:"rewrite"`
+
+	WebsiteGroupID uint `gorm:"type:integer" json:"webSiteGroupId"`
+	WebsiteSSLID   uint `gorm:"type:integer" json:"webSiteSSLId"`
+	RuntimeID      uint `gorm:"type:integer" json:"runtimeID"`
+	AppInstallID   uint `gorm:"type:integer" json:"appInstallId"`
+
+	User  string `gorm:"type:varchar;" json:"user"`
+	Group string `gorm:"type:varchar;" json:"group"`
+
+	Domains    []WebsiteDomain `json:"domains" gorm:"-:migration"`
+	WebsiteSSL WebsiteSSL      `json:"webSiteSSL" gorm:"-:migration"`
 }
 
 func (w Website) TableName() string {

backend/app/repo/app.go

@@ -11,6 +11,25 @@ import (
 type AppRepo struct {
 }
 
+type IAppRepo interface {
+	WithKey(key string) DBOption
+	WithType(typeStr string) DBOption
+	OrderByRecommend() DBOption
+	GetRecommend() DBOption
+	WithResource(resource string) DBOption
+	Page(page, size int, opts ...DBOption) (int64, []model.App, error)
+	GetFirst(opts ...DBOption) (model.App, error)
+	GetBy(opts ...DBOption) ([]model.App, error)
+	BatchCreate(ctx context.Context, apps []model.App) error
+	GetByKey(ctx context.Context, key string) (model.App, error)
+	Create(ctx context.Context, app *model.App) error
+	Save(ctx context.Context, app *model.App) error
+}
+
+func NewIAppRepo() IAppRepo {
+	return &AppRepo{}
+}
+
 func (a AppRepo) WithKey(key string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("key = ?", key)
@@ -35,12 +54,18 @@ func (a AppRepo) GetRecommend() DBOption {
 	}
 }
 
+func (a AppRepo) WithResource(resource string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("resource = ?", resource)
+	}
+}
+
 func (a AppRepo) Page(page, size int, opts ...DBOption) (int64, []model.App, error) {
 	var apps []model.App
 	db := getDb(opts...).Model(&model.App{})
 	count := int64(0)
 	db = db.Count(&count)
-	err := db.Limit(size).Offset(size * (page - 1)).Preload("AppTags").Find(&apps).Error
+	err := db.Debug().Limit(size).Offset(size * (page - 1)).Preload("AppTags").Find(&apps).Error
 	return count, apps, err
 }
 

backend/app/repo/app_detail.go

@@ -9,6 +9,21 @@ import (
 type AppDetailRepo struct {
 }
 
+type IAppDetailRepo interface {
+	WithVersion(version string) DBOption
+	WithAppId(id uint) DBOption
+	GetFirst(opts ...DBOption) (model.AppDetail, error)
+	Update(ctx context.Context, detail model.AppDetail) error
+	BatchCreate(ctx context.Context, details []model.AppDetail) error
+	DeleteByAppIds(ctx context.Context, appIds []uint) error
+	GetBy(opts ...DBOption) ([]model.AppDetail, error)
+	BatchUpdateBy(maps map[string]interface{}, opts ...DBOption) error
+}
+
+func NewIAppDetailRepo() IAppDetailRepo {
+	return &AppDetailRepo{}
+}
+
 func (a AppDetailRepo) WithVersion(version string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("version = ?", version)

backend/app/repo/app_install.go

@@ -3,6 +3,7 @@ package repo
 import (
 	"context"
 	"encoding/json"
+	"gorm.io/gorm/clause"
 
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/global"
@@ -11,6 +12,31 @@ import (
 
 type AppInstallRepo struct{}
 
+type IAppInstallRepo interface {
+	WithDetailIdsIn(detailIds []uint) DBOption
+	WithDetailIdNotIn(detailIds []uint) DBOption
+	WithAppId(appId uint) DBOption
+	WithAppIdsIn(appIds []uint) DBOption
+	WithStatus(status string) DBOption
+	WithServiceName(serviceName string) DBOption
+	WithPort(port int) DBOption
+	WithIdNotInWebsite() DBOption
+	ListBy(opts ...DBOption) ([]model.AppInstall, error)
+	GetFirst(opts ...DBOption) (model.AppInstall, error)
+	Create(ctx context.Context, install *model.AppInstall) error
+	Save(ctx context.Context, install *model.AppInstall) error
+	DeleteBy(opts ...DBOption) error
+	Delete(ctx context.Context, install model.AppInstall) error
+	Page(page, size int, opts ...DBOption) (int64, []model.AppInstall, error)
+	BatchUpdateBy(maps map[string]interface{}, opts ...DBOption) error
+	LoadBaseInfo(key string, name string) (*RootInfo, error)
+	GetFirstByCtx(ctx context.Context, opts ...DBOption) (model.AppInstall, error)
+}
+
+func NewIAppInstallRepo() IAppInstallRepo {
+	return &AppInstallRepo{}
+}
+
 func (a *AppInstallRepo) WithDetailIdsIn(detailIds []uint) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("app_detail_id in (?)", detailIds)
@@ -73,13 +99,20 @@ func (a *AppInstallRepo) GetFirst(opts ...DBOption) (model.AppInstall, error) {
 	return install, err
 }
 
-func (a *AppInstallRepo) Create(ctx context.Context, install *model.AppInstall) error {
-	db := getTx(ctx).Model(&model.AppInstall{})
-	return db.Create(&install).Error
+func (a *AppInstallRepo) GetFirstByCtx(ctx context.Context, opts ...DBOption) (model.AppInstall, error) {
+	var install model.AppInstall
+	db := getTx(ctx, opts...).Model(&model.AppInstall{})
+	err := db.Preload("App").First(&install).Error
+	return install, err
 }
 
-func (a *AppInstallRepo) Save(install *model.AppInstall) error {
-	return getDb().Save(&install).Error
+func (a *AppInstallRepo) Create(ctx context.Context, install *model.AppInstall) error {
+	db := getTx(ctx).Model(&model.AppInstall{})
+	return db.Omit(clause.Associations).Create(&install).Error
+}
+
+func (a *AppInstallRepo) Save(ctx context.Context, install *model.AppInstall) error {
+	return getTx(ctx).Omit(clause.Associations).Save(&install).Error
 }
 
 func (a *AppInstallRepo) DeleteBy(opts ...DBOption) error {
@@ -112,9 +145,11 @@ type RootInfo struct {
 	ID            uint   `json:"id"`
 	Name          string `json:"name"`
 	Port          int64  `json:"port"`
+	HttpsPort     int64  `json:"httpsPort"`
 	Password      string `json:"password"`
 	UserPassword  string `json:"userPassword"`
 	ContainerName string `json:"containerName"`
+	ServiceName   string `json:"serviceName"`
 	Param         string `json:"param"`
 	Env           string `json:"env"`
 	Key           string `json:"key"`
@@ -152,7 +187,9 @@ func (a *AppInstallRepo) LoadBaseInfo(key string, name string) (*RootInfo, error
 		info.UserPassword = userPassword
 	}
 	info.Port = int64(appInstall.HttpPort)
+	info.HttpsPort = int64(appInstall.HttpsPort)
 	info.ID = appInstall.ID
+	info.ServiceName = appInstall.ServiceName
 	info.ContainerName = appInstall.ContainerName
 	info.Name = appInstall.Name
 	info.Env = appInstall.Env

backend/app/repo/app_install_resource.go

@@ -11,6 +11,20 @@ import (
 type AppInstallResourceRpo struct {
 }
 
+type IAppInstallResourceRpo interface {
+	WithAppInstallId(appInstallId uint) DBOption
+	WithLinkId(linkId uint) DBOption
+	WithResourceId(resourceId uint) DBOption
+	GetBy(opts ...DBOption) ([]model.AppInstallResource, error)
+	GetFirst(opts ...DBOption) (model.AppInstallResource, error)
+	Create(ctx context.Context, resource *model.AppInstallResource) error
+	DeleteBy(ctx context.Context, opts ...DBOption) error
+}
+
+func NewIAppInstallResourceRpo() IAppInstallResourceRpo {
+	return &AppInstallResourceRpo{}
+}
+
 func (a AppInstallResourceRpo) WithAppInstallId(appInstallId uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("app_install_id = ?", appInstallId)

backend/app/repo/app_tag.go

@@ -8,6 +8,18 @@ import (
 type AppTagRepo struct {
 }
 
+type IAppTagRepo interface {
+	BatchCreate(ctx context.Context, tags []*model.AppTag) error
+	DeleteByAppIds(ctx context.Context, appIds []uint) error
+	DeleteAll(ctx context.Context) error
+	GetByAppId(appId uint) ([]model.AppTag, error)
+	GetByTagIds(tagIds []uint) ([]model.AppTag, error)
+}
+
+func NewIAppTagRepo() IAppTagRepo {
+	return &AppTagRepo{}
+}
+
 func (a AppTagRepo) BatchCreate(ctx context.Context, tags []*model.AppTag) error {
 	return getTx(ctx).Create(&tags).Error
 }

backend/app/repo/backup.go

@@ -20,6 +20,8 @@ type IBackupRepo interface {
 	Delete(opts ...DBOption) error
 	DeleteRecord(ctx context.Context, opts ...DBOption) error
 	WithByDetailName(detailName string) DBOption
+	WithByFileName(fileName string) DBOption
+	WithByType(backupType string) DBOption
 }
 
 func NewIBackupRepo() IBackupRepo {

backend/app/repo/command.go

@@ -15,6 +15,7 @@ type ICommandRepo interface {
 	Create(command *model.Command) error
 	Update(id uint, vars map[string]interface{}) error
 	Delete(opts ...DBOption) error
+	Get(opts ...DBOption) (model.Command, error)
 }
 
 func NewICommandRepo() ICommandRepo {

backend/app/repo/common.go

@@ -21,10 +21,15 @@ type ICommonRepo interface {
 	WithIdsIn(ids []uint) DBOption
 	WithByDate(startTime, endTime time.Time) DBOption
 	WithByStartDate(startTime time.Time) DBOption
+	WithByStatus(status string) DBOption
 }
 
 type CommonRepo struct{}
 
+func NewCommonRepo() ICommonRepo {
+	return &CommonRepo{}
+}
+
 func (c *CommonRepo) WithByID(id uint) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("id = ?", id)

backend/app/repo/compose_template.go

@@ -17,6 +17,7 @@ type IComposeTemplateRepo interface {
 
 	CreateRecord(compose *model.Compose) error
 	DeleteRecord(opts ...DBOption) error
+	ListRecord() ([]model.Compose, error)
 }
 
 func NewIComposeTemplateRepo() IComposeTemplateRepo {

backend/app/repo/cronjob.go

@@ -20,12 +20,15 @@ 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
+	WithByRecordDropID(id int) DBOption
 	Save(id uint, cronjob model.Cronjob) error
 	Update(id uint, vars map[string]interface{}) error
 	Delete(opts ...DBOption) error
 	DeleteRecord(opts ...DBOption) error
 	StartRecords(cronjobID uint, fromLocal bool, targetPath string) model.JobRecords
 	EndRecords(record model.JobRecords, status, message, records string)
+	PageRecords(page, size int, opts ...DBOption) (int64, []model.JobRecords, error)
 }
 
 func NewICronjobRepo() ICronjobRepo {
@@ -112,6 +115,18 @@ func (c *CronjobRepo) WithByJobID(id int) DBOption {
 	}
 }
 
+func (c *CronjobRepo) WithByBackupID(id uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("target_dir_id = ?", id)
+	}
+}
+
+func (c *CronjobRepo) WithByRecordDropID(id int) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("id < ?", id)
+	}
+}
+
 func (u *CronjobRepo) StartRecords(cronjobID uint, fromLocal bool, targetPath string) model.JobRecords {
 	var record model.JobRecords
 	record.StartTime = time.Now()

backend/app/repo/entry.go

@@ -1,29 +0,0 @@
-package repo
-
-type RepoGroup struct {
-	CommonRepo
-	AppRepo
-	AppTagRepo
-	TagRepo
-	AppDetailRepo
-	AppInstallRepo
-	AppInstallResourceRpo
-	ImageRepoRepo
-	ComposeTemplateRepo
-	MysqlRepo
-	CronjobRepo
-	HostRepo
-	CommandRepo
-	GroupRepo
-	SettingRepo
-	BackupRepo
-	WebsiteRepo
-	WebsiteDomainRepo
-	WebsiteDnsAccountRepo
-	WebsiteSSLRepo
-	WebsiteAcmeAccountRepo
-	LogRepo
-	SnapshotRepo
-}
-
-var RepoGroupApp = new(RepoGroup)

backend/app/repo/host.go

@@ -25,7 +25,7 @@ func NewIHostRepo() IHostRepo {
 	return &HostRepo{}
 }
 
-func (u *HostRepo) Get(opts ...DBOption) (model.Host, error) {
+func (h *HostRepo) Get(opts ...DBOption) (model.Host, error) {
 	var host model.Host
 	db := global.DB
 	for _, opt := range opts {
@@ -35,7 +35,7 @@ func (u *HostRepo) Get(opts ...DBOption) (model.Host, error) {
 	return host, err
 }
 
-func (u *HostRepo) GetList(opts ...DBOption) ([]model.Host, error) {
+func (h *HostRepo) GetList(opts ...DBOption) ([]model.Host, error) {
 	var hosts []model.Host
 	db := global.DB.Model(&model.Host{})
 	for _, opt := range opts {
@@ -45,7 +45,7 @@ func (u *HostRepo) GetList(opts ...DBOption) ([]model.Host, error) {
 	return hosts, err
 }
 
-func (u *HostRepo) Page(page, size int, opts ...DBOption) (int64, []model.Host, error) {
+func (h *HostRepo) Page(page, size int, opts ...DBOption) (int64, []model.Host, error) {
 	var users []model.Host
 	db := global.DB.Model(&model.Host{})
 	for _, opt := range opts {
@@ -57,7 +57,7 @@ func (u *HostRepo) Page(page, size int, opts ...DBOption) (int64, []model.Host,
 	return count, users, err
 }
 
-func (c *HostRepo) WithByInfo(info string) DBOption {
+func (h *HostRepo) WithByInfo(info string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(info) == 0 {
 			return g
@@ -67,22 +67,22 @@ func (c *HostRepo) WithByInfo(info string) DBOption {
 	}
 }
 
-func (u *HostRepo) WithByPort(port uint) DBOption {
+func (h *HostRepo) WithByPort(port uint) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("port = ?", port)
 	}
 }
-func (u *HostRepo) WithByUser(user string) DBOption {
+func (h *HostRepo) WithByUser(user string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("user = ?", user)
 	}
 }
-func (u *HostRepo) WithByAddr(addr string) DBOption {
+func (h *HostRepo) WithByAddr(addr string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("addr = ?", addr)
 	}
 }
-func (u *HostRepo) WithByGroup(group string) DBOption {
+func (h *HostRepo) WithByGroup(group string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(group) == 0 {
 			return g
@@ -91,15 +91,15 @@ func (u *HostRepo) WithByGroup(group string) DBOption {
 	}
 }
 
-func (u *HostRepo) Create(host *model.Host) error {
+func (h *HostRepo) Create(host *model.Host) error {
 	return global.DB.Create(host).Error
 }
 
-func (u *HostRepo) Update(id uint, vars map[string]interface{}) error {
+func (h *HostRepo) Update(id uint, vars map[string]interface{}) error {
 	return global.DB.Model(&model.Host{}).Where("id = ?", id).Updates(vars).Error
 }
 
-func (u *HostRepo) Delete(opts ...DBOption) error {
+func (h *HostRepo) Delete(opts ...DBOption) error {
 	db := global.DB
 	for _, opt := range opts {
 		db = opt(db)

backend/app/repo/runtime.go

@@ -0,0 +1,80 @@
+package repo
+
+import (
+	"context"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"gorm.io/gorm"
+)
+
+type RuntimeRepo struct {
+}
+
+type IRuntimeRepo interface {
+	WithName(name string) DBOption
+	WithImage(image string) DBOption
+	WithNotId(id uint) DBOption
+	WithStatus(status string) DBOption
+	Page(page, size int, opts ...DBOption) (int64, []model.Runtime, error)
+	Create(ctx context.Context, runtime *model.Runtime) error
+	Save(runtime *model.Runtime) error
+	DeleteBy(opts ...DBOption) error
+	GetFirst(opts ...DBOption) (*model.Runtime, error)
+}
+
+func NewIRunTimeRepo() IRuntimeRepo {
+	return &RuntimeRepo{}
+}
+
+func (r *RuntimeRepo) WithName(name string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("name = ?", name)
+	}
+}
+
+func (r *RuntimeRepo) WithStatus(status string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("status = ?", status)
+	}
+}
+
+func (r *RuntimeRepo) WithImage(image string) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("image = ?", image)
+	}
+}
+
+func (r *RuntimeRepo) WithNotId(id uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("id != ?", id)
+	}
+}
+
+func (r *RuntimeRepo) Page(page, size int, opts ...DBOption) (int64, []model.Runtime, error) {
+	var runtimes []model.Runtime
+	db := getDb(opts...).Model(&model.Runtime{})
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&runtimes).Error
+	return count, runtimes, err
+}
+
+func (r *RuntimeRepo) Create(ctx context.Context, runtime *model.Runtime) error {
+	db := getTx(ctx).Model(&model.Runtime{})
+	return db.Create(&runtime).Error
+}
+
+func (r *RuntimeRepo) Save(runtime *model.Runtime) error {
+	return getDb().Save(&runtime).Error
+}
+
+func (r *RuntimeRepo) DeleteBy(opts ...DBOption) error {
+	return getDb(opts...).Delete(&model.Runtime{}).Error
+}
+
+func (r *RuntimeRepo) GetFirst(opts ...DBOption) (*model.Runtime, error) {
+	var runtime model.Runtime
+	if err := getDb(opts...).First(&runtime).Error; err != nil {
+		return nil, err
+	}
+	return &runtime, nil
+}

backend/app/repo/tag.go

@@ -8,6 +8,19 @@ import (
 type TagRepo struct {
 }
 
+type ITagRepo interface {
+	BatchCreate(ctx context.Context, tags []*model.Tag) error
+	DeleteAll(ctx context.Context) error
+	All() ([]model.Tag, error)
+	GetByIds(ids []uint) ([]model.Tag, error)
+	GetByKeys(keys []string) ([]model.Tag, error)
+	GetByAppId(appId uint) ([]model.Tag, error)
+}
+
+func NewITagRepo() ITagRepo {
+	return &TagRepo{}
+}
+
 func (t TagRepo) BatchCreate(ctx context.Context, tags []*model.Tag) error {
 	return getTx(ctx).Create(&tags).Error
 }

backend/app/repo/website.go

@@ -17,6 +17,7 @@ type IWebsiteRepo interface {
 	WithGroupID(groupId uint) DBOption
 	WithDefaultServer() DBOption
 	WithDomainLike(domain string) DBOption
+	WithRuntimeID(runtimeID uint) DBOption
 	Page(page, size int, opts ...DBOption) (int64, []model.Website, error)
 	List(opts ...DBOption) ([]model.Website, error)
 	GetFirst(opts ...DBOption) (model.Website, error)
@@ -40,6 +41,12 @@ func (w *WebsiteRepo) WithAppInstallId(appInstallId uint) DBOption {
 	}
 }
 
+func (w *WebsiteRepo) WithRuntimeID(runtimeID uint) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("runtime_id = ?", runtimeID)
+	}
+}
+
 func (w *WebsiteRepo) WithDomain(domain string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("primary_domain = ?", domain)

backend/app/repo/website_dns_account.go

@@ -7,6 +7,19 @@ import (
 type WebsiteDnsAccountRepo struct {
 }
 
+type IWebsiteDnsAccountRepo interface {
+	Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDnsAccount, error)
+	GetFirst(opts ...DBOption) (*model.WebsiteDnsAccount, error)
+	List(opts ...DBOption) ([]model.WebsiteDnsAccount, error)
+	Create(account model.WebsiteDnsAccount) error
+	Save(account model.WebsiteDnsAccount) error
+	DeleteBy(opts ...DBOption) error
+}
+
+func NewIWebsiteDnsAccountRepo() IWebsiteDnsAccountRepo {
+	return &WebsiteDnsAccountRepo{}
+}
+
 func (w WebsiteDnsAccountRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDnsAccount, error) {
 	var accounts []model.WebsiteDnsAccount
 	db := getDb(opts...).Model(&model.WebsiteDnsAccount{})

backend/app/repo/website_domain.go

@@ -10,6 +10,23 @@ import (
 type WebsiteDomainRepo struct {
 }
 
+type IWebsiteDomainRepo interface {
+	WithWebsiteId(websiteId uint) DBOption
+	WithPort(port int) DBOption
+	WithDomain(domain string) DBOption
+	Page(page, size int, opts ...DBOption) (int64, []model.WebsiteDomain, error)
+	GetFirst(opts ...DBOption) (model.WebsiteDomain, error)
+	GetBy(opts ...DBOption) ([]model.WebsiteDomain, error)
+	BatchCreate(ctx context.Context, domains []model.WebsiteDomain) error
+	Create(ctx context.Context, app *model.WebsiteDomain) error
+	Save(ctx context.Context, app *model.WebsiteDomain) error
+	DeleteBy(ctx context.Context, opts ...DBOption) error
+}
+
+func NewIWebsiteDomainRepo() IWebsiteDomainRepo {
+	return &WebsiteDomainRepo{}
+}
+
 func (w WebsiteDomainRepo) WithWebsiteId(websiteId uint) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("website_id = ?", websiteId)

backend/app/service/app.go

@@ -5,14 +5,15 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/buserr"
-	"github.com/1Panel-dev/1Panel/backend/utils/docker"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 	"path"
 	"strings"
 
+	"github.com/1Panel-dev/1Panel/backend/buserr"
+	"github.com/1Panel-dev/1Panel/backend/utils/docker"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
 	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
@@ -32,10 +33,12 @@ type IAppService interface {
 	PageApp(req request.AppSearch) (interface{}, error)
 	GetAppTags() ([]response.TagDTO, error)
 	GetApp(key string) (*response.AppDTO, error)
-	GetAppDetail(appId uint, version string) (response.AppDetailDTO, error)
+	GetAppDetail(appId uint, version, appType string) (response.AppDetailDTO, error)
 	Install(ctx context.Context, req request.AppInstallCreate) (*model.AppInstall, error)
-	SyncAppList() error
+	SyncAppListFromRemote() error
 	GetAppUpdate() (*response.AppUpdateRes, error)
+	GetAppDetailByID(id uint) (*response.AppDetailDTO, error)
+	SyncAppListFromLocal()
 }
 
 func NewIAppService() IAppService {
@@ -138,7 +141,7 @@ func (a AppService) GetApp(key string) (*response.AppDTO, error) {
 	return &appDTO, nil
 }
 
-func (a AppService) GetAppDetail(appId uint, version string) (response.AppDetailDTO, error) {
+func (a AppService) GetAppDetail(appId uint, version, appType string) (response.AppDetailDTO, error) {
 	var (
 		appDetailDTO response.AppDetailDTO
 		opts         []repo.DBOption
@@ -148,14 +151,55 @@ func (a AppService) GetAppDetail(appId uint, version string) (response.AppDetail
 	if err != nil {
 		return appDetailDTO, err
 	}
-	paramMap := make(map[string]interface{})
-	if err := json.Unmarshal([]byte(detail.Params), &paramMap); err != nil {
-		return appDetailDTO, err
-	}
 	appDetailDTO.AppDetail = detail
-	appDetailDTO.Params = paramMap
 	appDetailDTO.Enable = true
 
+	if appType == "runtime" {
+		app, err := appRepo.GetFirst(commonRepo.WithByID(appId))
+		if err != nil {
+			return appDetailDTO, err
+		}
+		fileOp := files.NewFileOp()
+		buildPath := path.Join(constant.AppResourceDir, app.Key, "versions", detail.Version, "build")
+		paramsPath := path.Join(buildPath, "config.json")
+		if !fileOp.Stat(paramsPath) {
+			return appDetailDTO, buserr.New(constant.ErrFileNotExist)
+		}
+		param, err := fileOp.GetContent(paramsPath)
+		if err != nil {
+			return appDetailDTO, err
+		}
+		paramMap := make(map[string]interface{})
+		if err := json.Unmarshal(param, &paramMap); err != nil {
+			return appDetailDTO, err
+		}
+		appDetailDTO.Params = paramMap
+		composePath := path.Join(buildPath, "docker-compose.yml")
+		if !fileOp.Stat(composePath) {
+			return appDetailDTO, buserr.New(constant.ErrFileNotExist)
+		}
+		compose, err := fileOp.GetContent(composePath)
+		if err != nil {
+			return appDetailDTO, err
+		}
+		composeMap := make(map[string]interface{})
+		if err := yaml.Unmarshal(compose, &composeMap); err != nil {
+			return appDetailDTO, err
+		}
+		if service, ok := composeMap["services"]; ok {
+			servicesMap := service.(map[string]interface{})
+			for k := range servicesMap {
+				appDetailDTO.Image = k
+			}
+		}
+	} else {
+		paramMap := make(map[string]interface{})
+		if err := json.Unmarshal([]byte(detail.Params), &paramMap); err != nil {
+			return appDetailDTO, err
+		}
+		appDetailDTO.Params = paramMap
+	}
+
 	app, err := appRepo.GetFirst(commonRepo.WithByID(detail.AppId))
 	if err != nil {
 		return appDetailDTO, err
@@ -165,57 +209,75 @@ func (a AppService) GetAppDetail(appId uint, version string) (response.AppDetail
 	}
 	return appDetailDTO, nil
 }
+func (a AppService) GetAppDetailByID(id uint) (*response.AppDetailDTO, error) {
+	res := &response.AppDetailDTO{}
+	appDetail, err := appDetailRepo.GetFirst(commonRepo.WithByID(id))
+	if err != nil {
+		return nil, err
+	}
+	res.AppDetail = appDetail
+	paramMap := make(map[string]interface{})
+	if err := json.Unmarshal([]byte(appDetail.Params), &paramMap); err != nil {
+		return nil, err
+	}
+	res.Params = paramMap
+	return res, nil
+}
 
-func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (*model.AppInstall, error) {
-	if err := docker.CreateDefaultDockerNetwork(); err != nil {
-		return nil, buserr.WithDetail(constant.Err1PanelNetworkFailed, err.Error(), nil)
+func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (appInstall *model.AppInstall, err error) {
+	if err = docker.CreateDefaultDockerNetwork(); err != nil {
+		err = buserr.WithDetail(constant.Err1PanelNetworkFailed, err.Error(), nil)
+		return
 	}
 	if list, _ := appInstallRepo.ListBy(commonRepo.WithByName(req.Name)); len(list) > 0 {
-		return nil, buserr.New(constant.ErrNameIsExist)
+		err = buserr.New(constant.ErrNameIsExist)
+		return
 	}
-	httpPort, err := checkPort("PANEL_APP_PORT_HTTP", req.Params)
+	var (
+		httpPort  int
+		httpsPort int
+		appDetail model.AppDetail
+		app       model.App
+	)
+	httpPort, err = checkPort("PANEL_APP_PORT_HTTP", req.Params)
+	if err != nil {
+		return
+	}
+	httpsPort, err = checkPort("PANEL_APP_PORT_HTTPS", req.Params)
+	if err != nil {
+		return
+	}
+	appDetail, err = appDetailRepo.GetFirst(commonRepo.WithByID(req.AppDetailId))
+	if err != nil {
+		return
+	}
+	app, err = appRepo.GetFirst(commonRepo.WithByID(appDetail.AppId))
 	if err != nil {
 		return nil, err
 	}
-	httpsPort, err := checkPort("PANEL_APP_PORT_HTTPS", req.Params)
-	if err != nil {
-		return nil, err
-	}
-	appDetail, err := appDetailRepo.GetFirst(commonRepo.WithByID(req.AppDetailId))
-	if err != nil {
-		return nil, err
-	}
-	app, err := appRepo.GetFirst(commonRepo.WithByID(appDetail.AppId))
-	if err != nil {
-		return nil, err
-	}
-	if err := checkRequiredAndLimit(app); err != nil {
-		return nil, err
+	if err = checkRequiredAndLimit(app); err != nil {
+		return
 	}
 
-	paramByte, err := json.Marshal(req.Params)
-	if err != nil {
-		return nil, err
-	}
-	appInstall := model.AppInstall{
+	appInstall = &model.AppInstall{
 		Name:        req.Name,
 		AppId:       appDetail.AppId,
 		AppDetailId: appDetail.ID,
 		Version:     appDetail.Version,
 		Status:      constant.Installing,
-		Env:         string(paramByte),
 		HttpPort:    httpPort,
 		HttpsPort:   httpsPort,
 		App:         app,
 	}
 	composeMap := make(map[string]interface{})
-	if err := yaml.Unmarshal([]byte(appDetail.DockerCompose), &composeMap); err != nil {
-		return nil, err
+	if err = yaml.Unmarshal([]byte(appDetail.DockerCompose), &composeMap); err != nil {
+		return
 	}
 
 	value, ok := composeMap["services"]
 	if !ok {
-		return nil, buserr.New("")
+		err = buserr.New("")
+		return
 	}
 	servicesMap := value.(map[string]interface{})
 	changeKeys := make(map[string]string, len(servicesMap))
@@ -236,30 +298,59 @@ func (a AppService) Install(ctx context.Context, req request.AppInstallCreate) (
 		servicesMap[v] = servicesMap[k]
 		delete(servicesMap, k)
 	}
-	composeByte, err := yaml.Marshal(composeMap)
+
+	var (
+		composeByte []byte
+		paramByte   []byte
+	)
+
+	composeByte, err = yaml.Marshal(composeMap)
 	if err != nil {
-		return nil, err
+		return
 	}
 	appInstall.DockerCompose = string(composeByte)
 
-	if err := copyAppData(app.Key, appDetail.Version, req.Name, req.Params); err != nil {
-		return nil, err
-	}
+	defer func() {
+		if err != nil {
+			hErr := handleAppInstallErr(ctx, appInstall)
+			if hErr != nil {
+				global.LOG.Errorf("delete app dir error %s", hErr.Error())
+			}
+		}
+	}()
 
+	if err = copyAppData(app.Key, appDetail.Version, req.Name, req.Params, app.Resource == constant.AppResourceLocal); err != nil {
+		return
+	}
 	fileOp := files.NewFileOp()
-	if err := fileOp.WriteFile(appInstall.GetComposePath(), strings.NewReader(string(composeByte)), 0775); err != nil {
-		return nil, err
+	if err = fileOp.WriteFile(appInstall.GetComposePath(), strings.NewReader(string(composeByte)), 0775); err != nil {
+		return
 	}
+	paramByte, err = json.Marshal(req.Params)
+	if err != nil {
+		return
+	}
+	appInstall.Env = string(paramByte)
 
-	if err := appInstallRepo.Create(ctx, &appInstall); err != nil {
-		return nil, err
+	if err = appInstallRepo.Create(ctx, appInstall); err != nil {
+		return
 	}
-	if err := createLink(ctx, app, &appInstall, req.Params); err != nil {
-		return nil, err
+	if err = createLink(ctx, app, appInstall, req.Params); err != nil {
+		return
 	}
-	go upApp(appInstall.GetComposePath(), appInstall)
+	if err = upAppPre(app, appInstall); err != nil {
+		return
+	}
+	go upApp(appInstall)
 	go updateToolApp(appInstall)
-	return &appInstall, nil
+	ports := []int{appInstall.HttpPort}
+	if appInstall.HttpsPort > 0 {
+		ports = append(ports, appInstall.HttpsPort)
+	}
+	go func() {
+		_ = OperateFirewallPort(nil, ports)
+	}()
+	return
 }
 
 func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
@@ -272,12 +363,11 @@ func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
 	}
 	versionUrl := fmt.Sprintf("%s/%s/%s/appstore/apps.json", global.CONF.System.RepoUrl, global.CONF.System.Mode, setting.SystemVersion)
 	versionRes, err := http.Get(versionUrl)
-	global.LOG.Infof("get current version from [%s]", versionUrl)
 	if err != nil {
 		return nil, err
 	}
 	defer versionRes.Body.Close()
-	body, err := ioutil.ReadAll(versionRes.Body)
+	body, err := io.ReadAll(versionRes.Body)
 	if err != nil {
 		return nil, err
 	}
@@ -294,7 +384,155 @@ func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
 	return res, nil
 }
 
-func (a AppService) SyncAppList() error {
+func (a AppService) SyncAppListFromLocal() {
+	fileOp := files.NewFileOp()
+	appDir := constant.LocalAppResourceDir
+	listFile := path.Join(appDir, "list.json")
+	if !fileOp.Stat(listFile) {
+		return
+	}
+	global.LOG.Infof("start sync local apps...")
+	content, err := fileOp.GetContent(listFile)
+	if err != nil {
+		global.LOG.Errorf("get list.json content failed %s", err.Error())
+		return
+	}
+	list := &dto.AppList{}
+	if err := json.Unmarshal(content, list); err != nil {
+		global.LOG.Errorf("unmarshal list.json failed %s", err.Error())
+		return
+	}
+	oldApps, _ := appRepo.GetBy(appRepo.WithResource(constant.AppResourceLocal))
+	appsMap := getApps(oldApps, list.Items, true)
+	for _, l := range list.Items {
+		localKey := "local" + l.Key
+		app := appsMap[localKey]
+		icon, err := os.ReadFile(path.Join(appDir, l.Key, "metadata", "logo.png"))
+		if err != nil {
+			global.LOG.Errorf("get [%s] icon error: %s", l.Name, err.Error())
+			continue
+		}
+		iconStr := base64.StdEncoding.EncodeToString(icon)
+		app.Icon = iconStr
+		app.TagsKey = append(l.Tags, "Local")
+		app.Recommend = 9999
+		versions := l.Versions
+		detailsMap := getAppDetails(app.Details, versions)
+
+		for _, v := range versions {
+			detail := detailsMap[v]
+			detailPath := path.Join(appDir, l.Key, "versions", v)
+			if _, err := os.Stat(detailPath); err != nil {
+				global.LOG.Errorf("get [%s] folder error: %s", detailPath, err.Error())
+				continue
+			}
+			readmeStr, err := os.ReadFile(path.Join(detailPath, "README.md"))
+			if err != nil {
+				global.LOG.Errorf("get [%s] README error: %s", detailPath, err.Error())
+			}
+			detail.Readme = string(readmeStr)
+			dockerComposeStr, err := os.ReadFile(path.Join(detailPath, "docker-compose.yml"))
+			if err != nil {
+				global.LOG.Errorf("get [%s] docker-compose.yml error: %s", detailPath, err.Error())
+				continue
+			}
+			detail.DockerCompose = string(dockerComposeStr)
+			paramStr, err := os.ReadFile(path.Join(detailPath, "config.json"))
+			if err != nil {
+				global.LOG.Errorf("get [%s] form.json error: %s", detailPath, err.Error())
+			}
+			detail.Params = string(paramStr)
+			detailsMap[v] = detail
+		}
+		var newDetails []model.AppDetail
+		for _, v := range detailsMap {
+			newDetails = append(newDetails, v)
+		}
+		app.Details = newDetails
+		appsMap[localKey] = app
+	}
+	var (
+		addAppArray []model.App
+		updateArray []model.App
+		appIds      []uint
+	)
+	for _, v := range appsMap {
+		if v.ID == 0 {
+			addAppArray = append(addAppArray, v)
+		} else {
+			updateArray = append(updateArray, v)
+			appIds = append(appIds, v.ID)
+		}
+	}
+	tx, ctx := getTxAndContext()
+	if len(addAppArray) > 0 {
+		if err := appRepo.BatchCreate(ctx, addAppArray); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	for _, update := range updateArray {
+		if err := appRepo.Save(ctx, &update); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	if err := appTagRepo.DeleteByAppIds(ctx, appIds); err != nil {
+		tx.Rollback()
+		return
+	}
+	apps := append(addAppArray, updateArray...)
+	var (
+		addDetails    []model.AppDetail
+		updateDetails []model.AppDetail
+		appTags       []*model.AppTag
+	)
+	tags, _ := tagRepo.All()
+	tagMap := make(map[string]uint, len(tags))
+	for _, app := range tags {
+		tagMap[app.Key] = app.ID
+	}
+	for _, a := range apps {
+		for _, t := range a.TagsKey {
+			tagId, ok := tagMap[t]
+			if ok {
+				appTags = append(appTags, &model.AppTag{
+					AppId: a.ID,
+					TagId: tagId,
+				})
+			}
+		}
+		for _, d := range a.Details {
+			d.AppId = a.ID
+			if d.ID == 0 {
+				addDetails = append(addDetails, d)
+			} else {
+				updateDetails = append(updateDetails, d)
+			}
+		}
+	}
+	if len(addDetails) > 0 {
+		if err := appDetailRepo.BatchCreate(ctx, addDetails); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	for _, u := range updateDetails {
+		if err := appDetailRepo.Update(ctx, u); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	if len(appTags) > 0 {
+		if err := appTagRepo.BatchCreate(ctx, appTags); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	tx.Commit()
+	global.LOG.Infof("sync local apps success")
+}
+func (a AppService) SyncAppListFromRemote() error {
 	updateRes, err := a.GetAppUpdate()
 	if err != nil {
 		return err
@@ -327,11 +565,11 @@ func (a AppService) SyncAppList() error {
 			Name: t.Name,
 		})
 	}
-	oldApps, err := appRepo.GetBy()
+	oldApps, err := appRepo.GetBy(appRepo.WithResource(constant.AppResourceRemote))
 	if err != nil {
 		return err
 	}
-	appsMap := getApps(oldApps, list.Items)
+	appsMap := getApps(oldApps, list.Items, false)
 	for _, l := range list.Items {
 		app := appsMap[l.Key]
 		icon, err := os.ReadFile(path.Join(appDir, l.Key, "metadata", "logo.png"))
@@ -387,8 +625,9 @@ func (a AppService) SyncAppList() error {
 	var (
 		addAppArray []model.App
 		updateArray []model.App
+		tagMap      = make(map[string]uint, len(tags))
 	)
-	tagMap := make(map[string]uint, len(tags))
+
 	for _, v := range appsMap {
 		if v.ID == 0 {
 			addAppArray = append(addAppArray, v)

backend/app/service/app_install.go

@@ -1,9 +1,9 @@
 package service
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"math"
 	"os"
 	"path"
@@ -38,7 +38,7 @@ type IAppInstallService interface {
 	Page(req request.AppInstalledSearch) (int64, []response.AppInstalledDTO, error)
 	CheckExist(key string) (*response.AppInstalledCheck, error)
 	LoadPort(key string) (int64, error)
-	LoadPassword(key string) (string, error)
+	LoadConnInfo(key string) (response.DatabaseConn, error)
 	SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstalledDTO, error)
 	Operate(req request.AppInstalledOperate) error
 	Update(req request.AppInstalledUpdate) error
@@ -133,12 +133,16 @@ func (a *AppInstallService) LoadPort(key string) (int64, error) {
 	return app.Port, nil
 }
 
-func (a *AppInstallService) LoadPassword(key string) (string, error) {
+func (a *AppInstallService) LoadConnInfo(key string) (response.DatabaseConn, error) {
+	var data response.DatabaseConn
 	app, err := appInstallRepo.LoadBaseInfo(key, "")
 	if err != nil {
-		return "", nil
+		return data, nil
 	}
-	return app.Password, nil
+	data.Password = app.Password
+	data.ServiceName = app.ServiceName
+	data.Port = app.Port
+	return data, nil
 }
 
 func (a *AppInstallService) SearchForWebsite(req request.AppInstalledSearch) ([]response.AppInstalledDTO, error) {
@@ -175,7 +179,7 @@ func (a *AppInstallService) SearchForWebsite(req request.AppInstalledSearch) ([]
 }
 
 func (a *AppInstallService) Operate(req request.AppInstalledOperate) error {
-	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(req.InstallId))
+	install, err := appInstallRepo.GetFirstByCtx(context.Background(), commonRepo.WithByID(req.InstallId))
 	if err != nil {
 		return err
 	}
@@ -202,17 +206,14 @@ func (a *AppInstallService) Operate(req request.AppInstalledOperate) error {
 		}
 		return syncById(install.ID)
 	case constant.Delete:
-		tx, ctx := getTxAndContext()
-		if err := deleteAppInstall(ctx, install, req.DeleteBackup, req.ForceDelete, req.DeleteDB); err != nil && !req.ForceDelete {
-			tx.Rollback()
+		if err := deleteAppInstall(install, req.DeleteBackup, req.ForceDelete, req.DeleteDB); err != nil && !req.ForceDelete {
 			return err
 		}
-		tx.Commit()
 		return nil
 	case constant.Sync:
 		return syncById(install.ID)
 	case constant.Upgrade:
-		return updateInstall(install.ID, req.DetailId)
+		return upgradeInstall(install.ID, req.DetailId)
 	default:
 		return errors.New("operate not support")
 	}
@@ -224,27 +225,35 @@ func (a *AppInstallService) Update(req request.AppInstalledUpdate) error {
 		return err
 	}
 	changePort := false
+	var (
+		oldPorts []int
+		newPorts []int
+	)
 	port, ok := req.Params["PANEL_APP_PORT_HTTP"]
 	if ok {
 		portN := int(math.Ceil(port.(float64)))
 		if portN != installed.HttpPort {
+			oldPorts = append(oldPorts, installed.HttpPort)
 			changePort = true
 			httpPort, err := checkPort("PANEL_APP_PORT_HTTP", req.Params)
 			if err != nil {
 				return err
 			}
 			installed.HttpPort = httpPort
+			newPorts = append(newPorts, httpPort)
 		}
 	}
 	ports, ok := req.Params["PANEL_APP_PORT_HTTPS"]
 	if ok {
 		portN := int(math.Ceil(ports.(float64)))
 		if portN != installed.HttpsPort {
+			oldPorts = append(oldPorts, installed.HttpsPort)
 			httpsPort, err := checkPort("PANEL_APP_PORT_HTTPS", req.Params)
 			if err != nil {
 				return err
 			}
 			installed.HttpsPort = httpsPort
+			newPorts = append(newPorts, httpsPort)
 		}
 	}
 
@@ -262,7 +271,7 @@ func (a *AppInstallService) Update(req request.AppInstalledUpdate) error {
 	if err := env.Write(oldEnvMaps, envPath); err != nil {
 		return err
 	}
-	_ = appInstallRepo.Save(&installed)
+	_ = appInstallRepo.Save(context.Background(), &installed)
 
 	if err := rebuildApp(installed); err != nil {
 		return err
@@ -289,6 +298,11 @@ func (a *AppInstallService) Update(req request.AppInstalledUpdate) error {
 			return buserr.WithErr(constant.ErrUpdateBuWebsite, err)
 		}
 	}
+	if changePort {
+		go func() {
+			_ = OperateFirewallPort(oldPorts, newPorts)
+		}()
+	}
 	return nil
 }
 
@@ -302,7 +316,7 @@ func (a *AppInstallService) SyncAll(systemInit bool) error {
 			if systemInit {
 				i.Status = constant.Error
 				i.Message = "System restart causes application exception"
-				_ = appInstallRepo.Save(&i)
+				_ = appInstallRepo.Save(context.Background(), &i)
 			}
 			continue
 		}
@@ -387,6 +401,10 @@ func (a *AppInstallService) ChangeAppPort(req request.PortUpdate) error {
 		}
 	}
 
+	if err := OperateFirewallPort([]int{int(appInstall.Port)}, []int{int(req.Port)}); err != nil {
+		global.LOG.Errorf("allow firewall failed, err: %v", err)
+	}
+
 	return nil
 }
 
@@ -400,14 +418,12 @@ func (a *AppInstallService) DeleteCheck(installId uint) ([]dto.AppResource, erro
 	if err != nil {
 		return nil, err
 	}
-	if app.Type == "website" {
-		websites, _ := websiteRepo.GetBy(websiteRepo.WithAppInstallId(appInstall.ID))
-		for _, website := range websites {
-			res = append(res, dto.AppResource{
-				Type: "website",
-				Name: website.PrimaryDomain,
-			})
-		}
+	websites, _ := websiteRepo.GetBy(websiteRepo.WithAppInstallId(appInstall.ID))
+	for _, website := range websites {
+		res = append(res, dto.AppResource{
+			Type: "website",
+			Name: website.PrimaryDomain,
+		})
 	}
 	if app.Key == constant.AppOpenresty {
 		websites, _ := websiteRepo.GetBy()
@@ -567,15 +583,15 @@ func syncById(installId uint) error {
 	if containerCount == 0 {
 		appInstall.Status = constant.Error
 		appInstall.Message = "container is not found"
-		return appInstallRepo.Save(&appInstall)
+		return appInstallRepo.Save(context.Background(), &appInstall)
 	}
 	if errCount == 0 && existedCount == 0 {
 		appInstall.Status = constant.Running
-		return appInstallRepo.Save(&appInstall)
+		return appInstallRepo.Save(context.Background(), &appInstall)
 	}
 	if existedCount == normalCount {
 		appInstall.Status = constant.Stopped
-		return appInstallRepo.Save(&appInstall)
+		return appInstallRepo.Save(context.Background(), &appInstall)
 	}
 	if errCount == normalCount {
 		appInstall.Status = constant.Error
@@ -600,7 +616,7 @@ func syncById(installId uint) error {
 		errMsg.Write([]byte("\n"))
 	}
 	appInstall.Message = errMsg.String()
-	return appInstallRepo.Save(&appInstall)
+	return appInstallRepo.Save(context.Background(), &appInstall)
 }
 
 func updateInstallInfoInDB(appKey, appName, param string, isRestart bool, value interface{}) error {
@@ -612,7 +628,7 @@ func updateInstallInfoInDB(appKey, appName, param string, isRestart bool, value
 		return nil
 	}
 	envPath := fmt.Sprintf("%s/%s/%s/.env", constant.AppInstallDir, appKey, appInstall.Name)
-	lineBytes, err := ioutil.ReadFile(envPath)
+	lineBytes, err := os.ReadFile(envPath)
 	if err != nil {
 		return err
 	}

backend/app/service/app_utils.go

@@ -4,8 +4,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/compose-spec/compose-go/types"
+	"github.com/subosito/gotenv"
 	"math"
 	"os"
+	"os/exec"
 	"path"
 	"reflect"
 	"strconv"
@@ -23,6 +27,7 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/global"
 	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/1Panel-dev/1Panel/backend/utils/compose"
+	composeV2 "github.com/1Panel-dev/1Panel/backend/utils/docker"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
 	"github.com/pkg/errors"
 )
@@ -125,7 +130,23 @@ func createLink(ctx context.Context, app model.App, appInstall *model.AppInstall
 	return nil
 }
 
-func deleteAppInstall(ctx context.Context, install model.AppInstall, deleteBackup bool, forceDelete bool, deleteDB bool) error {
+func handleAppInstallErr(ctx context.Context, install *model.AppInstall) error {
+	op := files.NewFileOp()
+	appDir := install.GetPath()
+	dir, _ := os.Stat(appDir)
+	if dir != nil {
+		_, _ = compose.Down(install.GetComposePath())
+		if err := op.DeleteDir(appDir); err != nil {
+			return err
+		}
+	}
+	if err := deleteLink(ctx, install, true, true); err != nil {
+		return err
+	}
+	return nil
+}
+
+func deleteAppInstall(install model.AppInstall, deleteBackup bool, forceDelete bool, deleteDB bool) error {
 	op := files.NewFileOp()
 	appDir := install.GetPath()
 	dir, _ := os.Stat(appDir)
@@ -134,36 +155,34 @@ func deleteAppInstall(ctx context.Context, install model.AppInstall, deleteBacku
 		if err != nil && !forceDelete {
 			return handleErr(install, err, out)
 		}
-		if err := op.DeleteDir(appDir); err != nil && !forceDelete {
-			return err
-		}
 	}
+	tx, ctx := helper.GetTxAndContext()
+	defer tx.Rollback()
 	if err := appInstallRepo.Delete(ctx, install); err != nil {
 		return err
 	}
 	if err := deleteLink(ctx, &install, deleteDB, forceDelete); err != nil && !forceDelete {
 		return err
 	}
+	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType("app"), commonRepo.WithByName(install.App.Key), backupRepo.WithByDetailName(install.Name))
+	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType(install.App.Key))
+	if install.App.Key == constant.AppMysql {
+		_ = mysqlRepo.DeleteAll(ctx)
+	}
 	uploadDir := fmt.Sprintf("%s/1panel/uploads/app/%s/%s", global.CONF.System.BaseDir, install.App.Key, install.Name)
 	if _, err := os.Stat(uploadDir); err == nil {
 		_ = os.RemoveAll(uploadDir)
 	}
 	if deleteBackup {
-		localDir, err := loadLocalDir()
-		if err != nil && !forceDelete {
-			return err
-		}
+		localDir, _ := loadLocalDir()
 		backupDir := fmt.Sprintf("%s/app/%s/%s", localDir, install.App.Key, install.Name)
 		if _, err := os.Stat(backupDir); err == nil {
 			_ = os.RemoveAll(backupDir)
 		}
 		global.LOG.Infof("delete app %s-%s backups successful", install.App.Key, install.Name)
 	}
-	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType("app"), commonRepo.WithByName(install.App.Key), backupRepo.WithByDetailName(install.Name))
-	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType(install.App.Key))
-	if install.App.Key == constant.AppMysql {
-		_ = mysqlRepo.DeleteAll(ctx)
-	}
+	_ = op.DeleteDir(appDir)
+	tx.Commit()
 	return nil
 }
 
@@ -190,7 +209,7 @@ func deleteLink(ctx context.Context, install *model.AppInstall, deleteDB bool, f
 	return appInstallResourceRepo.DeleteBy(ctx, appInstallResourceRepo.WithAppInstallId(install.ID))
 }
 
-func updateInstall(installId uint, detailId uint) error {
+func upgradeInstall(installId uint, detailId uint) error {
 	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(installId))
 	if err != nil {
 		return err
@@ -205,7 +224,21 @@ func updateInstall(installId uint, detailId uint) error {
 	if err := NewIBackupService().AppBackup(dto.CommonBackup{Name: install.App.Key, DetailName: install.Name}); err != nil {
 		return err
 	}
-	if _, err = compose.Down(install.GetComposePath()); err != nil {
+
+	detailDir := path.Join(constant.ResourceDir, "apps", install.App.Key, "versions", detail.Version)
+	cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("cp -rf %s/* %s", detailDir, install.GetPath()))
+	stdout, err := cmd.CombinedOutput()
+	if err != nil {
+		if stdout != nil {
+			return errors.New(string(stdout))
+		}
+		return err
+	}
+
+	if out, err := compose.Down(install.GetComposePath()); err != nil {
+		if out != "" {
+			return errors.New(out)
+		}
 		return err
 	}
 	install.DockerCompose = detail.DockerCompose
@@ -216,32 +249,51 @@ func updateInstall(installId uint, detailId uint) error {
 	if err := fileOp.WriteFile(install.GetComposePath(), strings.NewReader(install.DockerCompose), 0775); err != nil {
 		return err
 	}
-	if _, err = compose.Up(install.GetComposePath()); err != nil {
+	if out, err := compose.Up(install.GetComposePath()); err != nil {
+		if out != "" {
+			return errors.New(out)
+		}
 		return err
 	}
-	return appInstallRepo.Save(&install)
+	return appInstallRepo.Save(context.Background(), &install)
 }
 
 func getContainerNames(install model.AppInstall) ([]string, error) {
-	composeMap := install.DockerCompose
-	envMap := make(map[string]interface{})
-	_ = json.Unmarshal([]byte(install.Env), &envMap)
-	newEnvMap := make(map[string]string, len(envMap))
-	handleMap(envMap, newEnvMap)
-	project, err := compose.GetComposeProject([]byte(composeMap), newEnvMap)
+	envStr, err := coverEnvJsonToStr(install.Env)
 	if err != nil {
 		return nil, err
 	}
-	containerNames := []string{install.ContainerName}
+	project, err := composeV2.GetComposeProject(install.Name, install.GetPath(), []byte(install.DockerCompose), []byte(envStr), true)
+	if err != nil {
+		return nil, err
+	}
+	containerMap := make(map[string]struct{})
+	containerMap[install.ContainerName] = struct{}{}
 	for _, service := range project.AllServices() {
 		if service.ContainerName == "${CONTAINER_NAME}" || service.ContainerName == "" {
 			continue
 		}
-		containerNames = append(containerNames, service.ContainerName)
+		containerMap[service.ContainerName] = struct{}{}
+	}
+	var containerNames []string
+	for k := range containerMap {
+		containerNames = append(containerNames, k)
 	}
 	return containerNames, nil
 }
 
+func coverEnvJsonToStr(envJson string) (string, error) {
+	envMap := make(map[string]interface{})
+	_ = json.Unmarshal([]byte(envJson), &envMap)
+	newEnvMap := make(map[string]string, len(envMap))
+	handleMap(envMap, newEnvMap)
+	envStr, err := gotenv.Marshal(newEnvMap)
+	if err != nil {
+		return "", err
+	}
+	return envStr, nil
+}
+
 func checkLimit(app model.App) error {
 	if app.Limit > 0 {
 		installs, err := appInstallRepo.ListBy(appInstallRepo.WithAppId(app.ID))
@@ -256,11 +308,9 @@ func checkLimit(app model.App) error {
 }
 
 func checkRequiredAndLimit(app model.App) error {
-
 	if err := checkLimit(app); err != nil {
 		return err
 	}
-
 	if app.Required != "" {
 		var requiredArray []string
 		if err := json.Unmarshal([]byte(app.Required), &requiredArray); err != nil {
@@ -289,7 +339,6 @@ func checkRequiredAndLimit(app model.App) error {
 			}
 		}
 	}
-
 	return nil
 }
 
@@ -306,10 +355,17 @@ func handleMap(params map[string]interface{}, envParams map[string]string) {
 	}
 }
 
-func copyAppData(key, version, installName string, params map[string]interface{}) (err error) {
+func copyAppData(key, version, installName string, params map[string]interface{}, isLocal bool) (err error) {
 	fileOp := files.NewFileOp()
-	resourceDir := path.Join(constant.AppResourceDir, key, "versions", version)
+	appResourceDir := constant.AppResourceDir
 	installAppDir := path.Join(constant.AppInstallDir, key)
+	appKey := key
+	if isLocal {
+		appResourceDir = constant.LocalAppResourceDir
+		appKey = strings.TrimPrefix(key, "local")
+		installAppDir = path.Join(constant.LocalAppInstallDir, appKey)
+	}
+	resourceDir := path.Join(appResourceDir, appKey, "versions", version)
 
 	if !fileOp.Stat(installAppDir) {
 		if err = fileOp.CreateDir(installAppDir, 0755); err != nil {
@@ -339,19 +395,64 @@ func copyAppData(key, version, installName string, params map[string]interface{}
 	return
 }
 
-func upApp(composeFilePath string, appInstall model.AppInstall) {
-	out, err := compose.Up(composeFilePath)
-	if err != nil {
-		if out != "" {
-			appInstall.Message = out
-		} else {
-			appInstall.Message = err.Error()
+// 处理文件夹权限等问题
+func upAppPre(app model.App, appInstall *model.AppInstall) error {
+	if app.Key == "nexus" {
+		dataPath := path.Join(appInstall.GetPath(), "data")
+		if err := files.NewFileOp().Chown(dataPath, 200, 0); err != nil {
+			return err
 		}
+	}
+	return nil
+}
+
+func getServiceFromInstall(appInstall *model.AppInstall) (service *composeV2.ComposeService, err error) {
+	var (
+		project *types.Project
+		envStr  string
+	)
+	envStr, err = coverEnvJsonToStr(appInstall.Env)
+	if err != nil {
+		return
+	}
+	project, err = composeV2.GetComposeProject(appInstall.Name, appInstall.GetPath(), []byte(appInstall.DockerCompose), []byte(envStr), true)
+	if err != nil {
+		return
+	}
+	service, err = composeV2.NewComposeService()
+	if err != nil {
+		return
+	}
+	service.SetProject(project)
+	return
+}
+
+func upApp(appInstall *model.AppInstall) {
+	upProject := func(appInstall *model.AppInstall) (err error) {
+		if err == nil {
+			var composeService *composeV2.ComposeService
+			composeService, err = getServiceFromInstall(appInstall)
+			if err != nil {
+				return err
+			}
+			err = composeService.ComposeUp()
+			if err != nil {
+				return err
+			}
+			return
+		} else {
+			return
+		}
+	}
+	if err := upProject(appInstall); err != nil {
 		appInstall.Status = constant.Error
-		_ = appInstallRepo.Save(&appInstall)
+		appInstall.Message = err.Error()
 	} else {
 		appInstall.Status = constant.Running
-		_ = appInstallRepo.Save(&appInstall)
+	}
+	exist, _ := appInstallRepo.GetFirst(commonRepo.WithByID(appInstall.ID))
+	if exist.ID > 0 {
+		_ = appInstallRepo.Save(context.Background(), appInstall)
 	}
 }
 
@@ -390,20 +491,29 @@ func getAppDetails(details []model.AppDetail, versions []string) map[string]mode
 	return appDetails
 }
 
-func getApps(oldApps []model.App, items []dto.AppDefine) map[string]model.App {
+func getApps(oldApps []model.App, items []dto.AppDefine, isLocal bool) map[string]model.App {
 	apps := make(map[string]model.App, len(oldApps))
 	for _, old := range oldApps {
 		old.Status = constant.AppTakeDown
 		apps[old.Key] = old
 	}
 	for _, item := range items {
-		app, ok := apps[item.Key]
+		key := item.Key
+		if isLocal {
+			key = "local" + key
+		}
+		app, ok := apps[key]
 		if !ok {
 			app = model.App{}
 		}
+		if isLocal {
+			app.Resource = constant.AppResourceLocal
+		} else {
+			app.Resource = constant.AppResourceRemote
+		}
 		app.Name = item.Name
 		app.Limit = item.Limit
-		app.Key = item.Key
+		app.Key = key
 		app.ShortDescZh = item.ShortDescZh
 		app.ShortDescEn = item.ShortDescEn
 		app.Website = item.Website
@@ -413,7 +523,7 @@ func getApps(oldApps []model.App, items []dto.AppDefine) map[string]model.App {
 		app.CrossVersionUpdate = item.CrossVersionUpdate
 		app.Required = item.GetRequired()
 		app.Status = constant.AppNormal
-		apps[item.Key] = app
+		apps[key] = app
 	}
 	return apps
 }
@@ -426,7 +536,7 @@ func handleErr(install model.AppInstall, err error, out string) error {
 		reErr = errors.New(out)
 		install.Status = constant.Error
 	}
-	_ = appInstallRepo.Save(&install)
+	_ = appInstallRepo.Save(context.Background(), &install)
 	return reErr
 }
 
@@ -501,7 +611,7 @@ func getAppInstallByKey(key string) (model.AppInstall, error) {
 	return appInstall, nil
 }
 
-func updateToolApp(installed model.AppInstall) {
+func updateToolApp(installed *model.AppInstall) {
 	tooKey, ok := dto.AppToolMap[installed.App.Key]
 	if !ok {
 		return
@@ -537,7 +647,7 @@ func updateToolApp(installed model.AppInstall) {
 		return
 	}
 	toolInstall.Env = string(contentByte)
-	if err := appInstallRepo.Save(&toolInstall); err != nil {
+	if err := appInstallRepo.Save(context.Background(), &toolInstall); err != nil {
 		global.LOG.Errorf("update tool app [%s] error : %s", toolInstall.Name, err.Error())
 		return
 	}

backend/app/service/auth.go

@@ -26,6 +26,7 @@ type IAuthService interface {
 	SafeEntrance(c *gin.Context, code string) error
 	Login(c *gin.Context, info dto.Login) (*dto.UserLoginInfo, error)
 	LogOut(c *gin.Context) error
+	MFALogin(c *gin.Context, info dto.MFALogin) (*dto.UserLoginInfo, error)
 }
 
 func NewIAuthService() IAuthService {

backend/app/service/backup.go

@@ -9,6 +9,7 @@ import (
 
 	"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/1Panel-dev/1Panel/backend/utils/cloud_storage"
@@ -26,7 +27,7 @@ type IBackupService interface {
 	Create(backupDto dto.BackupOperate) error
 	GetBuckets(backupDto dto.ForBuckets) ([]interface{}, error)
 	Update(ireq dto.BackupOperate) error
-	BatchDelete(ids []uint) error
+	Delete(id uint) error
 	BatchDeleteRecord(ids []uint) error
 	NewClient(backup *model.BackupAccount) (cloud_storage.CloudStorageClient, error)
 
@@ -53,36 +54,13 @@ func NewIBackupService() IBackupService {
 func (u *BackupService) List() ([]dto.BackupInfo, error) {
 	ops, err := backupRepo.List(commonRepo.WithOrderBy("created_at desc"))
 	var dtobas []dto.BackupInfo
-	ossExist, s3Exist, sftpExist, minioExist := false, false, false, false
-	for _, group := range ops {
-		switch group.Type {
-		case "OSS":
-			ossExist = true
-		case "S3":
-			s3Exist = true
-		case "SFTP":
-			sftpExist = true
-		case "MINIO":
-			minioExist = true
-		}
-		var item dto.BackupInfo
-		if err := copier.Copy(&item, &group); err != nil {
-			return nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
-		}
-		dtobas = append(dtobas, item)
-	}
-	if !ossExist {
-		dtobas = append(dtobas, dto.BackupInfo{Type: "OSS"})
-	}
-	if !s3Exist {
-		dtobas = append(dtobas, dto.BackupInfo{Type: "S3"})
-	}
-	if !sftpExist {
-		dtobas = append(dtobas, dto.BackupInfo{Type: "SFTP"})
-	}
-	if !minioExist {
-		dtobas = append(dtobas, dto.BackupInfo{Type: "MINIO"})
-	}
+	dtobas = append(dtobas, u.loadByType("LOCAL", ops))
+	dtobas = append(dtobas, u.loadByType("OSS", ops))
+	dtobas = append(dtobas, u.loadByType("S3", ops))
+	dtobas = append(dtobas, u.loadByType("SFTP", ops))
+	dtobas = append(dtobas, u.loadByType("MINIO", ops))
+	dtobas = append(dtobas, u.loadByType("COS", ops))
+	dtobas = append(dtobas, u.loadByType("KODO", ops))
 	return dtobas, err
 }
 
@@ -123,7 +101,7 @@ func (u *BackupService) DownloadRecord(info dto.DownloadRecord) (string, error)
 	case constant.Sftp:
 		varMap["username"] = backup.AccessKey
 		varMap["password"] = backup.Credential
-	case constant.OSS, constant.S3, constant.MinIo:
+	case constant.OSS, constant.S3, constant.MinIo, constant.Cos, constant.Kodo:
 		varMap["accessKey"] = backup.AccessKey
 		varMap["secretKey"] = backup.Credential
 	}
@@ -171,7 +149,7 @@ func (u *BackupService) GetBuckets(backupDto dto.ForBuckets) ([]interface{}, err
 	case constant.Sftp:
 		varMap["username"] = backupDto.AccessKey
 		varMap["password"] = backupDto.Credential
-	case constant.OSS, constant.S3, constant.MinIo:
+	case constant.OSS, constant.S3, constant.MinIo, constant.Cos, constant.Kodo:
 		varMap["accessKey"] = backupDto.AccessKey
 		varMap["secretKey"] = backupDto.Credential
 	}
@@ -182,8 +160,12 @@ func (u *BackupService) GetBuckets(backupDto dto.ForBuckets) ([]interface{}, err
 	return client.ListBuckets()
 }
 
-func (u *BackupService) BatchDelete(ids []uint) error {
-	return backupRepo.Delete(commonRepo.WithIdsIn(ids))
+func (u *BackupService) Delete(id uint) error {
+	cronjobs, _ := cronjobRepo.List(cronjobRepo.WithByBackupID(id))
+	if len(cronjobs) != 0 {
+		return buserr.New(constant.ErrBackupInUsed)
+	}
+	return backupRepo.Delete(commonRepo.WithByID(id))
 }
 
 func (u *BackupService) BatchDeleteRecord(ids []uint) error {
@@ -277,7 +259,7 @@ func (u *BackupService) NewClient(backup *model.BackupAccount) (cloud_storage.Cl
 	case constant.Sftp:
 		varMap["username"] = backup.AccessKey
 		varMap["password"] = backup.Credential
-	case constant.OSS, constant.S3, constant.MinIo:
+	case constant.OSS, constant.S3, constant.MinIo, constant.Cos, constant.Kodo:
 		varMap["accessKey"] = backup.AccessKey
 		varMap["secretKey"] = backup.Credential
 	}
@@ -290,6 +272,19 @@ func (u *BackupService) NewClient(backup *model.BackupAccount) (cloud_storage.Cl
 	return backClient, nil
 }
 
+func (u *BackupService) loadByType(accountType string, accounts []model.BackupAccount) dto.BackupInfo {
+	for _, account := range accounts {
+		if account.Type == accountType {
+			var item dto.BackupInfo
+			if err := copier.Copy(&item, &account); err != nil {
+				global.LOG.Errorf("copy backup account to dto backup info failed, err: %v", err)
+			}
+			return item
+		}
+	}
+	return dto.BackupInfo{Type: accountType}
+}
+
 func loadLocalDir() (string, error) {
 	backup, err := backupRepo.Get(commonRepo.WithByType("LOCAL"))
 	if err != nil {

backend/app/service/backup_app.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/fs"
@@ -32,6 +33,7 @@ func (u *BackupService) AppBackup(req dto.CommonBackup) error {
 		return err
 	}
 	timeNow := time.Now().Format("20060102150405")
+
 	backupDir := fmt.Sprintf("%s/app/%s/%s", localDir, req.Name, req.DetailName)
 
 	fileName := fmt.Sprintf("%s_%s.tar.gz", req.DetailName, timeNow)
@@ -97,7 +99,7 @@ func handleAppBackup(install *model.AppInstall, backupDir, fileName string) erro
 		return err
 	}
 
-	appPath := fmt.Sprintf("%s/%s/%s", constant.AppInstallDir, install.App.Key, install.Name)
+	appPath := fmt.Sprintf("%s/%s", install.GetPath(), install.Name)
 	if err := handleTar(appPath, tmpDir, "app.tar.gz", ""); err != nil {
 		return err
 	}
@@ -192,7 +194,7 @@ func handleAppRecover(install *model.AppInstall, recoverFile string, isRollback
 	}
 
 	oldInstall.Status = constant.Running
-	if err := appInstallRepo.Save(install); err != nil {
+	if err := appInstallRepo.Save(context.Background(), install); err != nil {
 		global.LOG.Errorf("save db app install failed, err: %v", err)
 		return err
 	}

backend/app/service/backup_redis.go

@@ -2,7 +2,6 @@ package service
 
 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path"
 	"strings"
@@ -176,11 +175,11 @@ func handleRedisRecover(redisInfo *repo.RootInfo, recoverFile string, isRollback
 		if appendonly == "yes" && redisInfo.Version == "6.0.16" {
 			itemName = "appendonly.aof"
 		}
-		input, err := ioutil.ReadFile(recoverFile)
+		input, err := os.ReadFile(recoverFile)
 		if err != nil {
 			return err
 		}
-		if err = ioutil.WriteFile(composeDir+"/data/"+itemName, input, 0640); err != nil {
+		if err = os.WriteFile(composeDir+"/data/"+itemName, input, 0640); err != nil {
 			return err
 		}
 	}

backend/app/service/container.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os/exec"
 	"sort"
 	"strconv"
@@ -47,6 +46,8 @@ type IContainerService interface {
 	CreateNetwork(req dto.NetworkCreat) error
 	DeleteVolume(req dto.BatchDelete) error
 	CreateVolume(req dto.VolumeCreat) error
+	TestCompose(req dto.ComposeCreate) (bool, error)
+	ComposeUpdate(req dto.ComposeUpdate) error
 }
 
 func NewIContainerService() IContainerService {
@@ -197,8 +198,10 @@ func (u *ContainerService) ContainerCreate(req dto.ContainerCreate) error {
 	global.LOG.Infof("new container info %s has been made, now start to create", req.Name)
 
 	ctx := context.Background()
-	if err := pullImages(ctx, client, req.Image); err != nil {
-		return err
+	if !checkImageExist(client, req.Image) {
+		if err := pullImages(ctx, client, req.Image); err != nil {
+			return err
+		}
 	}
 	container, err := client.ContainerCreate(ctx, config, hostConf, &network.NetworkingConfig{}, &v1.Platform{}, req.Name)
 	if err != nil {
@@ -225,9 +228,9 @@ func (u *ContainerService) ContainerOperation(req dto.ContainerOperation) error
 	case constant.ContainerOpStart:
 		err = client.ContainerStart(ctx, req.Name, types.ContainerStartOptions{})
 	case constant.ContainerOpStop:
-		err = client.ContainerStop(ctx, req.Name, nil)
+		err = client.ContainerStop(ctx, req.Name, container.StopOptions{})
 	case constant.ContainerOpRestart:
-		err = client.ContainerRestart(ctx, req.Name, nil)
+		err = client.ContainerRestart(ctx, req.Name, container.StopOptions{})
 	case constant.ContainerOpKill:
 		err = client.ContainerKill(ctx, req.Name, "SIGKILL")
 	case constant.ContainerOpPause:
@@ -265,7 +268,7 @@ func (u *ContainerService) ContainerStats(id string) (*dto.ContainterStats, erro
 	}
 	defer res.Body.Close()
 
-	body, err := ioutil.ReadAll(res.Body)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
 		return nil, err
 	}
@@ -331,13 +334,30 @@ func calculateNetwork(network map[string]types.NetworkStats) (float64, float64)
 	return rx, tx
 }
 
+func checkImageExist(client *client.Client, image string) bool {
+	images, err := client.ImageList(context.Background(), types.ImageListOptions{})
+	if err != nil {
+		fmt.Println(err)
+		return false
+	}
+
+	for _, img := range images {
+		for _, tag := range img.RepoTags {
+			if tag == image || tag == image+":latest" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func pullImages(ctx context.Context, client *client.Client, image string) error {
 	out, err := client.ImagePull(ctx, image, types.ImagePullOptions{})
 	if err != nil {
 		return err
 	}
 	defer out.Close()
-	_, err = io.Copy(ioutil.Discard, out)
+	_, err = io.Copy(io.Discard, out)
 	if err != nil {
 		return err
 	}

backend/app/service/container_volume.go

@@ -10,7 +10,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/utils/docker"
-	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/volume"
 )
@@ -37,14 +36,14 @@ func (u *ContainerService) PageVolume(req dto.SearchWithPage) (int64, interface{
 	}
 	var (
 		data    []dto.Volume
-		records []*types.Volume
+		records []*volume.Volume
 	)
 	sort.Slice(list.Volumes, func(i, j int) bool {
 		return list.Volumes[i].CreatedAt > list.Volumes[j].CreatedAt
 	})
 	total, start, end := len(list.Volumes), (req.Page-1)*req.PageSize, req.Page*req.PageSize
 	if start > total {
-		records = make([]*types.Volume, 0)
+		records = make([]*volume.Volume, 0)
 	} else {
 		if end >= total {
 			end = total
@@ -119,7 +118,7 @@ func (u *ContainerService) CreateVolume(req dto.VolumeCreat) error {
 			}
 		}
 	}
-	options := volume.VolumeCreateBody{
+	options := volume.CreateOptions{
 		Name:       req.Name,
 		Driver:     req.Driver,
 		DriverOpts: stringsToMap(req.Options),

backend/app/service/cornjob.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"fmt"
 	"os"
+	"path"
 	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -24,7 +25,10 @@ type ICronjobService interface {
 	HandleOnce(id uint) error
 	Update(id uint, req dto.CronjobUpdate) error
 	UpdateStatus(id uint, status string) error
-	Delete(ids []uint) error
+	Delete(req dto.CronjobBatchDelete) error
+	Download(down dto.CronjobDownload) (string, error)
+	StartJob(cronjob *model.Cronjob) (int, error)
+	CleanRecord(req dto.CronjobClean) error
 }
 
 func NewICronjobService() ICronjobService {
@@ -76,6 +80,44 @@ func (u *CronjobService) SearchRecords(search dto.SearchRecord) (int64, interfac
 	return total, dtoCronjobs, err
 }
 
+func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
+	cronjob, err := cronjobRepo.Get(commonRepo.WithByID(req.CronjobID))
+	if err != nil {
+		return err
+	}
+	if req.CleanData && cronjob.Type != "shell" && cronjob.Type != "curl" {
+		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 err != nil {
+				return err
+			}
+			client, err := NewIBackupService().NewClient(&backup)
+			if err != nil {
+				return err
+			}
+			u.HandleRmExpired(backup.Type, localDir, &cronjob, client)
+		} else {
+			u.HandleRmExpired(backup.Type, "", &cronjob, nil)
+		}
+	}
+	delRecords, err := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(req.CronjobID)))
+	if err != nil {
+		return err
+	}
+	for _, del := range delRecords {
+		_ = os.RemoveAll(del.Records)
+	}
+	if err := cronjobRepo.DeleteRecord(cronjobRepo.WithByJobID(int(req.CronjobID))); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (u *CronjobService) Download(down dto.CronjobDownload) (string, error) {
 	record, _ := cronjobRepo.GetRecord(commonRepo.WithByID(down.RecordID))
 	if record.ID == 0 {
@@ -89,24 +131,19 @@ func (u *CronjobService) Download(down dto.CronjobDownload) (string, error) {
 	if cronjob.ID == 0 {
 		return "", constant.ErrRecordNotFound
 	}
-	if backup.Type == "LOCAL" {
+	if backup.Type == "LOCAL" || record.FromLocal {
 		if _, err := os.Stat(record.File); err != nil && os.IsNotExist(err) {
 			return "", constant.ErrRecordNotFound
 		}
 		return record.File, nil
 	}
-	if record.FromLocal {
-		local, _ := loadLocalDir()
-		if _, err := os.Stat(local + "/" + record.File); err == nil {
-			return local + "/" + record.File, nil
-		}
-	}
 	client, err := NewIBackupService().NewClient(&backup)
 	if err != nil {
 		return "", err
 	}
 	tempPath := fmt.Sprintf("%s/download/%s", constant.DataDir, record.File)
-	isOK, _ := client.Download(record.File, tempPath)
+	_ = os.MkdirAll(path.Dir(tempPath), os.ModePerm)
+	isOK, err := client.Download(record.File, tempPath)
 	if !isOK || err != nil {
 		return "", constant.ErrRecordNotFound
 	}
@@ -157,21 +194,23 @@ func (u *CronjobService) StartJob(cronjob *model.Cronjob) (int, error) {
 	return entryID, nil
 }
 
-func (u *CronjobService) Delete(ids []uint) error {
-	if len(ids) == 1 {
-		if err := u.HandleDelete(ids[0]); err != nil {
+func (u *CronjobService) Delete(req dto.CronjobBatchDelete) error {
+	for _, id := range req.IDs {
+		cronjob, _ := cronjobRepo.Get(commonRepo.WithByID(id))
+		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 {
+			return err
+		}
+		if err := cronjobRepo.Delete(commonRepo.WithByID(id)); err != nil {
 			return err
 		}
-		return cronjobRepo.Delete(commonRepo.WithByID(ids[0]))
 	}
-	cronjobs, err := cronjobRepo.List(commonRepo.WithIdsIn(ids))
-	if err != nil {
-		return err
-	}
-	for i := range cronjobs {
-		_ = u.HandleDelete(ids[i])
-	}
-	return cronjobRepo.Delete(commonRepo.WithIdsIn(ids))
+
+	return nil
 }
 
 func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
@@ -194,6 +233,7 @@ func (u *CronjobService) Update(id uint, req dto.CronjobUpdate) error {
 	upMap := make(map[string]interface{})
 	upMap["entry_id"] = newEntryID
 	upMap["name"] = req.Name
+	upMap["spec"] = cronjob.Spec
 	upMap["script"] = req.Script
 	upMap["spec_type"] = req.SpecType
 	upMap["week"] = req.Week

backend/app/service/cronjob_helper.go

@@ -3,18 +3,18 @@ package service
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
 	"os"
+	"path"
 	"strings"
 	"time"
 
 	"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"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/pkg/errors"
-	"github.com/robfig/cron/v3"
 )
 
 func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
@@ -29,11 +29,12 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 			if len(cronjob.Script) == 0 {
 				return
 			}
-			stdout, errExec := cmd.Exec(cronjob.Script)
+			stdout, errExec := cmd.ExecWithTimeOut(cronjob.Script, 5*time.Minute)
 			if errExec != nil {
 				err = errExec
 			}
 			message = []byte(stdout)
+			u.HandleRmExpired("LOCAL", "", cronjob, nil)
 		case "website":
 			record.File, err = u.HandleBackup(cronjob, record.StartTime)
 		case "database":
@@ -47,11 +48,12 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 			if len(cronjob.URL) == 0 {
 				return
 			}
-			stdout, errCurl := cmd.Exec("curl " + cronjob.URL)
+			stdout, errCurl := cmd.ExecWithTimeOut("curl "+cronjob.URL, 5*time.Minute)
 			if err != nil {
 				err = errCurl
 			}
 			message = []byte(stdout)
+			u.HandleRmExpired("LOCAL", "", cronjob, nil)
 		}
 		if err != nil {
 			cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), string(message))
@@ -68,11 +70,6 @@ func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
 }
 
 func (u *CronjobService) HandleBackup(cronjob *model.Cronjob, startTime time.Time) (string, error) {
-	var (
-		backupDir string
-		fileName  string
-		record    model.BackupRecord
-	)
 	backup, err := backupRepo.Get(commonRepo.WithByID(uint(cronjob.TargetDirID)))
 	if err != nil {
 		return "", err
@@ -89,144 +86,60 @@ func (u *CronjobService) HandleBackup(cronjob *model.Cronjob, startTime time.Tim
 		if err != nil {
 			return "", err
 		}
-		fileName = fmt.Sprintf("db_%s_%s.sql.gz", cronjob.DBName, startTime.Format("20060102150405"))
-		backupDir = fmt.Sprintf("%s/database/mysql/%s/%s", localDir, app.Name, cronjob.DBName)
-		if err = handleMysqlBackup(app, backupDir, cronjob.DBName, fileName); err != nil {
-			return "", err
-		}
-		record.Type = "mysql"
-		record.Name = app.Name
-		record.DetailName = cronjob.DBName
+		paths, err := u.handleDatabase(*cronjob, app, backup, startTime)
+		return strings.Join(paths, ","), err
 	case "website":
-		fileName = fmt.Sprintf("website_%s_%s.tar.gz", cronjob.Website, startTime.Format("20060102150405"))
-		backupDir = fmt.Sprintf("%s/website/%s", localDir, cronjob.Website)
-		website, err := websiteRepo.GetFirst(websiteRepo.WithDomain(cronjob.Website))
-		if err != nil {
-			return "", err
-		}
-		if err := handleWebsiteBackup(&website, backupDir, fileName); err != nil {
-			return "", err
-		}
-		record.Type = "website"
-		record.Name = website.PrimaryDomain
+		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 = fmt.Sprintf("%s/%s/%s", localDir, cronjob.Type, cronjob.Name)
+		fileName := fmt.Sprintf("directory%s_%s.tar.gz", strings.ReplaceAll(cronjob.SourceDir, "/", "_"), startTime.Format("20060102150405"))
+		backupDir := fmt.Sprintf("%s/%s/%s", localDir, 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
 		}
-	}
-
-	itemFileDir := strings.ReplaceAll(backupDir, localDir+"/", "")
-	if len(record.Name) != 0 {
-		record.FileName = fileName
-		record.FileDir = backupDir
-		record.Source = "LOCAL"
-		record.BackupType = backup.Type
-		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 "", err
-		}
-	}
-
-	fullPath := fmt.Sprintf("%s/%s", backupDir, fileName)
-	if backup.Type != "LOCAL" {
-		fullPath = fmt.Sprintf("%s/%s", itemFileDir, fileName)
-	}
-	if backup.Type == "LOCAL" {
-		u.HandleRmExpired(backup.Type, backupDir, cronjob, nil)
-		return fullPath, nil
-	}
-
-	if !cronjob.KeepLocal {
-		defer func() {
-			_ = os.RemoveAll(fmt.Sprintf("%s/%s", backupDir, fileName))
-		}()
-	}
-	client, err := NewIBackupService().NewClient(&backup)
-	if err != nil {
-		return fullPath, err
-	}
-	if _, err = client.Upload(backupDir+"/"+fileName, itemFileDir+"/"+fileName); err != nil {
-		return fullPath, err
-	}
-	u.HandleRmExpired(backup.Type, itemFileDir, cronjob, client)
-	if cronjob.KeepLocal {
-		u.HandleRmExpired("LOCAL", backupDir, cronjob, client)
-	}
-	return fullPath, nil
-}
-
-func (u *CronjobService) HandleDelete(id uint) error {
-	cronjob, _ := cronjobRepo.Get(commonRepo.WithByID(id))
-	if cronjob.ID == 0 {
-		return errors.New("find cronjob in db failed")
-	}
-	commonDir := fmt.Sprintf("%s/%s/", cronjob.Type, cronjob.Name)
-	global.Cron.Remove(cron.EntryID(cronjob.EntryID))
-	global.LOG.Infof("stop cronjob entryID: %d", cronjob.EntryID)
-	_ = cronjobRepo.DeleteRecord(cronjobRepo.WithByJobID(int(id)))
-
-	dir := fmt.Sprintf("%s/task/%s/%s", constant.DataDir, cronjob.Type, cronjob.Name)
-	if _, err := os.Stat(dir); err == nil {
-		if err := os.RemoveAll(dir); err != nil {
-			global.LOG.Errorf("rm file %s/task/%s failed, err: %v", constant.DataDir, commonDir, err)
-		}
-	}
-	return nil
-}
-
-func (u *CronjobService) HandleRmExpired(backType, backupDir string, cronjob *model.Cronjob, backClient cloud_storage.CloudStorageClient) {
-	global.LOG.Infof("start to handle remove expired, retain copies: %d", cronjob.RetainCopies)
-	if backType != "LOCAL" {
-		currentObjs, err := backClient.ListObjects(backupDir + "/")
-		if err != nil {
-			global.LOG.Errorf("list bucket object %s failed, err: %v", backupDir, err)
-			return
-		}
-		for i := 0; i < len(currentObjs)-int(cronjob.RetainCopies); i++ {
-			_, _ = backClient.Delete(currentObjs[i].(string))
-		}
-		return
-	}
-	files, err := ioutil.ReadDir(backupDir)
-	if err != nil {
-		global.LOG.Errorf("read dir %s failed, err: %v", backupDir, err)
-		return
-	}
-	if len(files) == 0 {
-		return
-	}
-
-	prefix := ""
-	switch cronjob.Type {
-	case "database":
-		prefix = "db_"
-	case "website":
-		prefix = "website_"
-	case "directory":
-		prefix = "directory_"
-	}
-
-	dbCopies := uint64(0)
-	for i := len(files) - 1; i >= 0; i-- {
-		if strings.HasPrefix(files[i].Name(), prefix) {
-			dbCopies++
-			if dbCopies > cronjob.RetainCopies {
-				_ = os.Remove(backupDir + "/" + files[i].Name())
-				_ = backupRepo.DeleteRecord(context.Background(), backupRepo.WithByFileName(files[i].Name()))
+		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 _, err = client.Upload(backupDir+"/"+fileName, itemFileDir+"/"+fileName); err != nil {
+				return "", err
 			}
 		}
+		u.HandleRmExpired(backup.Type, localDir, cronjob, client)
+		if backup.Type == "LOCAL" || cronjob.KeepLocal {
+			return fmt.Sprintf("%s/%s/%s/%s", localDir, cronjob.Type, cronjob.Name, fileName), nil
+		}
+		return fmt.Sprintf("%s/%s/%s", cronjob.Type, cronjob.Name, fileName), nil
 	}
-	records, _ := cronjobRepo.ListRecord(cronjobRepo.WithByJobID(int(cronjob.ID)))
+}
+
+func (u *CronjobService) HandleRmExpired(backType, 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) {
 		for i := int(cronjob.RetainCopies); i < len(records); i++ {
-			_ = cronjobRepo.DeleteRecord(cronjobRepo.WithByJobID(int(records[i].ID)))
+			files := strings.Split(records[i].File, ",")
+			for _, file := range files {
+				if backType != "LOCAL" {
+					_, _ = backClient.Delete(strings.ReplaceAll(file, localDir+"/", ""))
+					_ = os.Remove(file)
+				} else {
+					_ = os.Remove(file)
+				}
+				_ = backupRepo.DeleteRecord(context.TODO(), backupRepo.WithByFileName(path.Base(file)))
+			}
+
+			_ = cronjobRepo.DeleteRecord(commonRepo.WithByID(uint(records[i].ID)))
+			_ = os.Remove(records[i].Records)
 		}
 	}
 }
@@ -257,7 +170,7 @@ func handleTar(sourceDir, targetDir, name, exclusionRules string) error {
 
 	commands := fmt.Sprintf("tar zcvf %s %s %s", targetDir+"/"+name, excludeRules, path)
 	global.LOG.Debug(commands)
-	stdout, err := cmd.Exec(commands)
+	stdout, err := cmd.ExecWithTimeOut(commands, 5*time.Minute)
 	if err != nil {
 		global.LOG.Errorf("do handle tar failed, stdout: %s, err: %v", stdout, err)
 		return errors.New(stdout)
@@ -274,10 +187,144 @@ func handleUnTar(sourceFile, targetDir string) error {
 
 	commands := fmt.Sprintf("tar zxvfC %s %s", sourceFile, targetDir)
 	global.LOG.Debug(commands)
-	stdout, err := cmd.Exec(commands)
+	stdout, err := cmd.ExecWithTimeOut(commands, 5*time.Minute)
 	if err != nil {
 		global.LOG.Errorf("do handle untar failed, stdout: %s, err: %v", stdout, err)
 		return errors.New(stdout)
 	}
 	return nil
 }
+
+func (u *CronjobService) handleDatabase(cronjob model.Cronjob, app *repo.RootInfo, backup model.BackupAccount, startTime time.Time) ([]string, error) {
+	var paths []string
+	localDir, err := loadLocalDir()
+	if err != nil {
+		return paths, err
+	}
+
+	var dblist []string
+	if cronjob.DBName == "all" {
+		mysqlService := NewIMysqlService()
+		dblist, err = mysqlService.ListDBName()
+		if err != nil {
+			return paths, err
+		}
+	} else {
+		dblist = append(dblist, cronjob.DBName)
+	}
+
+	var client cloud_storage.CloudStorageClient
+	if backup.Type != "LOCAL" {
+		client, err = NewIBackupService().NewClient(&backup)
+		if err != nil {
+			return paths, err
+		}
+	}
+
+	for _, dbName := range dblist {
+		var record model.BackupRecord
+
+		record.Type = "mysql"
+		record.Name = app.Name
+		record.Source = "LOCAL"
+		record.BackupType = backup.Type
+
+		backupDir := fmt.Sprintf("%s/database/mysql/%s/%s", localDir, app.Name, dbName)
+		record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbName, startTime.Format("20060102150405"))
+		if err = handleMysqlBackup(app, backupDir, dbName, record.FileName); err != nil {
+			return paths, err
+		}
+		record.DetailName = dbName
+		record.FileDir = backupDir
+		itemFileDir := strings.ReplaceAll(backupDir, localDir+"/", "")
+		if !cronjob.KeepLocal && backup.Type != "LOCAL" {
+			record.Source = backup.Type
+			record.FileDir = itemFileDir
+		}
+		paths = append(paths, fmt.Sprintf("%s/%s", record.FileDir, record.FileName))
+
+		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 _, err = client.Upload(backupDir+"/"+record.FileName, itemFileDir+"/"+record.FileName); err != nil {
+				return paths, err
+			}
+		}
+	}
+	u.HandleRmExpired(backup.Type, 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
+	}
+
+	var weblist []string
+	if cronjob.Website == "all" {
+		weblist, err = NewIWebsiteService().GetWebsiteOptions()
+		if err != nil {
+			return paths, err
+		}
+	} else {
+		weblist = append(weblist, cronjob.Website)
+	}
+
+	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 = cronjob.Website
+		record.Source = "LOCAL"
+		record.BackupType = backup.Type
+		website, err := websiteRepo.GetFirst(websiteRepo.WithDomain(websiteItem))
+		if err != nil {
+			return paths, err
+		}
+		backupDir := fmt.Sprintf("%s/website/%s", localDir, website.PrimaryDomain)
+		record.FileDir = backupDir
+		itemFileDir := strings.ReplaceAll(backupDir, localDir+"/", "")
+		if !cronjob.KeepLocal && backup.Type != "LOCAL" {
+			record.Source = backup.Type
+			record.FileDir = strings.ReplaceAll(backupDir, localDir+"/", "")
+		}
+		record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", website.PrimaryDomain, startTime.Format("20060102150405"))
+		paths = append(paths, fmt.Sprintf("%s/%s", record.FileDir, record.FileName))
+		if err := handleWebsiteBackup(&website, backupDir, record.FileName); err != nil {
+			return paths, err
+		}
+		record.Name = website.PrimaryDomain
+		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 _, err = client.Upload(backupDir+"/"+record.FileName, itemFileDir+"/"+record.FileName); err != nil {
+				return paths, err
+			}
+		}
+	}
+	u.HandleRmExpired(backup.Type, localDir, &cronjob, client)
+	return paths, nil
+}

backend/app/service/dashboard.go

@@ -2,9 +2,11 @@ package service
 
 import (
 	"encoding/json"
+	"strings"
 	"time"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/shirou/gopsutil/v3/cpu"
 	"github.com/shirou/gopsutil/v3/disk"
 	"github.com/shirou/gopsutil/v3/host"
@@ -141,29 +143,57 @@ func (u *DashboardService) LoadCurrentInfo(ioOption string, netOption string) *d
 	return &currentInfo
 }
 
+type diskInfo struct {
+	Type   string
+	Mount  string
+	Device string
+}
+
 func loadDiskInfo() []dto.DiskInfo {
 	var datas []dto.DiskInfo
-	parts, err := disk.Partitions(false)
+	stdout, err := cmd.Exec("df -hT -P|grep '/'|grep -v tmpfs|grep -v 'snap/core'|grep -v udev")
 	if err != nil {
 		return datas
 	}
+	lines := strings.Split(stdout, "\n")
+
+	var mounts []diskInfo
 	var excludes = []string{"/mnt/cdrom", "/boot", "/boot/efi", "/dev", "/dev/shm", "/run/lock", "/run", "/run/shm", "/run/user"}
-	for i := 0; i < len(parts); i++ {
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) < 7 {
+			continue
+		}
+		if fields[1] == "tmpfs" {
+			continue
+		}
+		if strings.Contains(fields[2], "M") || strings.Contains(fields[2], "K") {
+			continue
+		}
+		if strings.Contains(fields[6], "docker") {
+			continue
+		}
 		isExclude := false
 		for _, exclude := range excludes {
-			if parts[i].Mountpoint == exclude {
+			if exclude == fields[6] {
 				isExclude = true
-				break
 			}
 		}
 		if isExclude {
 			continue
 		}
-		state, _ := disk.Usage(parts[i].Mountpoint)
+		mounts = append(mounts, diskInfo{Type: fields[1], Device: fields[0], Mount: fields[6]})
+	}
+
+	for i := 0; i < len(mounts); i++ {
+		state, err := disk.Usage(mounts[i].Mount)
+		if err != nil {
+			continue
+		}
 		var itemData dto.DiskInfo
-		itemData.Path = parts[i].Mountpoint
-		itemData.Type = parts[i].Fstype
-		itemData.Device = parts[i].Device
+		itemData.Path = mounts[i].Mount
+		itemData.Type = mounts[i].Type
+		itemData.Device = mounts[i].Device
 		itemData.Total = state.Total
 		itemData.Free = state.Free
 		itemData.Used = state.Used

backend/app/service/database_mysql.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"regexp"
@@ -94,25 +93,28 @@ func (u *MysqlService) Create(ctx context.Context, req dto.MysqlDBCreate) (*mode
 	}
 
 	createSql := fmt.Sprintf("create database `%s` default character set %s collate %s", req.Name, req.Format, formatMap[req.Format])
-	if err := excuteSql(app.ContainerName, app.Password, createSql); err != nil {
+	if err := excSQL(app.ContainerName, app.Password, createSql); err != nil {
 		if strings.Contains(err.Error(), "ERROR 1007") {
 			return nil, buserr.New(constant.ErrDatabaseIsExist)
 		}
 		return nil, err
 	}
 	tmpPermission := req.Permission
-	if err := excuteSql(app.ContainerName, app.Password, fmt.Sprintf("create user '%s'@'%s' identified by '%s';", req.Username, tmpPermission, req.Password)); err != nil {
-		_ = excuteSql(app.ContainerName, app.Password, fmt.Sprintf("drop database `%s`", req.Name))
+	if err := excSQL(app.ContainerName, app.Password, fmt.Sprintf("create user '%s'@'%s' identified by '%s';", req.Username, tmpPermission, req.Password)); err != nil {
+		_ = excSQL(app.ContainerName, app.Password, fmt.Sprintf("drop database `%s`", req.Name))
 		if strings.Contains(err.Error(), "ERROR 1396") {
 			return nil, buserr.New(constant.ErrUserIsExist)
 		}
 		return nil, err
 	}
 	grantStr := fmt.Sprintf("grant all privileges on `%s`.* to '%s'@'%s'", req.Name, req.Username, tmpPermission)
+	if req.Name == "*" {
+		grantStr = fmt.Sprintf("grant all privileges on *.* to '%s'@'%s'", mysql.Username, tmpPermission)
+	}
 	if app.Version == "5.7.39" {
 		grantStr = fmt.Sprintf("%s identified by '%s' with grant option;", grantStr, req.Password)
 	}
-	if err := excuteSql(app.ContainerName, app.Password, grantStr); err != nil {
+	if err := excSQL(app.ContainerName, app.Password, grantStr); err != nil {
 		return nil, err
 	}
 
@@ -161,10 +163,10 @@ func (u *MysqlService) Delete(ctx context.Context, req dto.MysqlDBDelete) error
 		return err
 	}
 
-	if err := excuteSql(app.ContainerName, app.Password, fmt.Sprintf("drop user if exists '%s'@'%s'", db.Username, db.Permission)); err != nil && !req.ForceDelete {
+	if err := excSQL(app.ContainerName, app.Password, fmt.Sprintf("drop user if exists '%s'@'%s'", db.Username, db.Permission)); err != nil && !req.ForceDelete {
 		return err
 	}
-	if err := excuteSql(app.ContainerName, app.Password, fmt.Sprintf("drop database if exists `%s`", db.Name)); err != nil && !req.ForceDelete {
+	if err := excSQL(app.ContainerName, app.Password, fmt.Sprintf("drop database if exists `%s`", db.Name)); err != nil && !req.ForceDelete {
 		return err
 	}
 	global.LOG.Info("execute delete database sql successful, now start to drop uploads and records")
@@ -293,6 +295,9 @@ func (u *MysqlService) ChangeAccess(info dto.ChangeDBInfo) error {
 		return err
 	}
 	grantStr := fmt.Sprintf("grant all privileges on `%s`.* to '%s'@'%s'", mysql.Name, mysql.Username, info.Value)
+	if mysql.Name == "*" {
+		grantStr = fmt.Sprintf("grant all privileges on *.* to '%s'@'%s'", mysql.Username, info.Value)
+	}
 	if app.Version == "5.7.39" {
 		grantStr = fmt.Sprintf("%s identified by '%s' with grant option;", grantStr, mysql.Password)
 	}
@@ -339,7 +344,7 @@ func (u *MysqlService) UpdateVariables(updatas []dto.MysqlVariablesUpdate) error
 	var files []string
 
 	path := fmt.Sprintf("%s/mysql/%s/conf/my.cnf", constant.AppInstallDir, app.Name)
-	lineBytes, err := ioutil.ReadFile(path)
+	lineBytes, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -509,6 +514,21 @@ func excuteSql(containerName, password, command string) error {
 	return nil
 }
 
+func excSQL(containerName, password, command string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "docker", "exec", containerName, "mysql", "-uroot", "-p"+password, "-e", command)
+	err := cmd.Run()
+	if ctx.Err() == context.DeadlineExceeded {
+		return buserr.WithDetail(constant.ErrExecTimeOut, containerName, nil)
+	}
+	if err != nil {
+		stdStr := strings.ReplaceAll(err.Error(), "mysql: [Warning] Using a password on the command line interface can be insecure.\n", "")
+		return errors.New(stdStr)
+	}
+	return nil
+}
+
 func updateMyCnf(oldFiles []string, group string, param string, value interface{}) []string {
 	isOn := false
 	hasGroup := false

backend/app/service/database_redis.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -215,7 +214,7 @@ type redisConfig struct {
 
 func confSet(redisName string, changeConf []redisConfig) error {
 	path := fmt.Sprintf("%s/redis/%s/conf/redis.conf", constant.AppInstallDir, redisName)
-	lineBytes, err := ioutil.ReadFile(path)
+	lineBytes, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}

backend/app/service/docker.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"context"
 	"encoding/json"
-	"io/ioutil"
 	"os"
 	"path"
 	"strings"
@@ -35,6 +34,7 @@ type daemonJsonItem struct {
 	Mirrors     []string `json:"registry-mirrors"`
 	Registries  []string `json:"insecure-registries"`
 	LiveRestore bool     `json:"live-restore"`
+	IPTables    bool     `json:"iptables"`
 	ExecOpts    []string `json:"exec-opts"`
 }
 
@@ -49,55 +49,60 @@ func (u *DockerService) LoadDockerStatus() string {
 }
 
 func (u *DockerService) LoadDockerConf() *dto.DaemonJsonConf {
-	status := constant.StatusRunning
+	var data dto.DaemonJsonConf
+	data.IPTables = true
+	data.Status = constant.StatusRunning
 	stdout, err := cmd.Exec("systemctl is-active docker")
 	if string(stdout) != "active\n" || err != nil {
-		status = constant.Stopped
+		data.Status = constant.Stopped
 	}
-	version := "-"
+	data.IsSwarm = false
+	stdout2, _ := cmd.Exec("docker info  | grep Swarm")
+	if string(stdout2) == " Swarm: active\n" {
+		data.IsSwarm = true
+	}
+	data.Version = "-"
 	client, err := docker.NewDockerClient()
 	if err == nil {
 		ctx := context.Background()
 		itemVersion, err := client.ServerVersion(ctx)
 		if err == nil {
-			version = itemVersion.Version
+			data.Version = itemVersion.Version
 		}
 	}
 	if _, err := os.Stat(constant.DaemonJsonPath); err != nil {
-		return &dto.DaemonJsonConf{Status: status, Version: version}
+		return &data
 	}
-	file, err := ioutil.ReadFile(constant.DaemonJsonPath)
+	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
-		return &dto.DaemonJsonConf{Status: status, Version: version}
+		return &data
 	}
 	var conf daemonJsonItem
 	deamonMap := make(map[string]interface{})
 	if err := json.Unmarshal(file, &deamonMap); err != nil {
-		return &dto.DaemonJsonConf{Status: status, Version: version}
+		return &data
 	}
 	arr, err := json.Marshal(deamonMap)
 	if err != nil {
-		return &dto.DaemonJsonConf{Status: status, Version: version}
+		return &data
 	}
 	if err := json.Unmarshal(arr, &conf); err != nil {
-		return &dto.DaemonJsonConf{Status: status, Version: version}
+		return &data
 	}
-	driver := "cgroupfs"
+	if _, ok := deamonMap["iptables"]; !ok {
+		conf.IPTables = true
+	}
+	data.CgroupDriver = "cgroupfs"
 	for _, opt := range conf.ExecOpts {
 		if strings.HasPrefix(opt, "native.cgroupdriver=") {
-			driver = strings.ReplaceAll(opt, "native.cgroupdriver=", "")
+			data.CgroupDriver = strings.ReplaceAll(opt, "native.cgroupdriver=", "")
 			break
 		}
 	}
-	data := dto.DaemonJsonConf{
-		Status:       status,
-		Version:      version,
-		Mirrors:      conf.Mirrors,
-		Registries:   conf.Registries,
-		LiveRestore:  conf.LiveRestore,
-		CgroupDriver: driver,
-	}
-
+	data.Mirrors = conf.Mirrors
+	data.Registries = conf.Registries
+	data.IPTables = conf.IPTables
+	data.LiveRestore = conf.LiveRestore
 	return &data
 }
 
@@ -109,7 +114,7 @@ func (u *DockerService) UpdateConf(req dto.DaemonJsonConf) error {
 		_, _ = os.Create(constant.DaemonJsonPath)
 	}
 
-	file, err := ioutil.ReadFile(constant.DaemonJsonPath)
+	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		return err
 	}
@@ -131,6 +136,11 @@ func (u *DockerService) UpdateConf(req dto.DaemonJsonConf) error {
 	} else {
 		deamonMap["live-restore"] = req.LiveRestore
 	}
+	if req.IPTables {
+		delete(deamonMap, "iptables")
+	} else {
+		deamonMap["iptables"] = false
+	}
 	if opts, ok := deamonMap["exec-opts"]; ok {
 		if optsValue, isArray := opts.([]interface{}); isArray {
 			for i := 0; i < len(optsValue); i++ {
@@ -147,11 +157,15 @@ func (u *DockerService) UpdateConf(req dto.DaemonJsonConf) error {
 			deamonMap["exec-opts"] = []string{"native.cgroupdriver=systemd"}
 		}
 	}
+	if len(deamonMap) == 0 {
+		_ = os.Remove(constant.DaemonJsonPath)
+		return nil
+	}
 	newJson, err := json.MarshalIndent(deamonMap, "", "\t")
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
+	if err := os.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
 		return err
 	}
 
@@ -163,6 +177,16 @@ func (u *DockerService) UpdateConf(req dto.DaemonJsonConf) error {
 }
 
 func (u *DockerService) UpdateConfByFile(req dto.DaemonJsonUpdateByFile) error {
+	if len(req.File) == 0 {
+		_ = os.Remove(constant.DaemonJsonPath)
+		return nil
+	}
+	if _, err := os.Stat(constant.DaemonJsonPath); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(constant.DaemonJsonPath), os.ModePerm); err != nil {
+			return err
+		}
+		_, _ = os.Create(constant.DaemonJsonPath)
+	}
 	file, err := os.OpenFile(constant.DaemonJsonPath, os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {
 		return err

backend/app/service/entry.go

@@ -2,76 +2,38 @@ package service
 
 import "github.com/1Panel-dev/1Panel/backend/app/repo"
 
-type ServiceGroup struct {
-	AuthService
-	DashboardService
-
-	AppService
-	AppInstallService
-
-	ContainerService
-	ImageService
-	ImageRepoService
-	ComposeTemplateService
-	DockerService
-
-	MysqlService
-	RedisService
-
-	CronjobService
-
-	HostService
-	GroupService
-	CommandService
-	FileService
-
-	SettingService
-	BackupService
-
-	WebsiteService
-	WebsiteDnsAccountService
-	WebsiteSSLService
-	WebsiteAcmeAccountService
-
-	NginxService
-
-	LogService
-	SnapshotService
-	UpgradeService
-}
-
-var ServiceGroupApp = new(ServiceGroup)
-
 var (
-	commonRepo = repo.RepoGroupApp.CommonRepo
+	commonRepo = repo.NewCommonRepo()
 
-	appRepo                = repo.RepoGroupApp.AppRepo
-	appTagRepo             = repo.RepoGroupApp.AppTagRepo
-	appDetailRepo          = repo.RepoGroupApp.AppDetailRepo
-	tagRepo                = repo.RepoGroupApp.TagRepo
-	appInstallRepo         = repo.RepoGroupApp.AppInstallRepo
-	appInstallResourceRepo = repo.RepoGroupApp.AppInstallResourceRpo
+	appRepo                = repo.NewIAppRepo()
+	appTagRepo             = repo.NewIAppTagRepo()
+	appDetailRepo          = repo.NewIAppDetailRepo()
+	tagRepo                = repo.NewITagRepo()
+	appInstallRepo         = repo.NewIAppInstallRepo()
+	appInstallResourceRepo = repo.NewIAppInstallResourceRpo()
 
-	mysqlRepo = repo.RepoGroupApp.MysqlRepo
+	mysqlRepo = repo.NewIMysqlRepo()
 
-	imageRepoRepo = repo.RepoGroupApp.ImageRepoRepo
-	composeRepo   = repo.RepoGroupApp.ComposeTemplateRepo
+	imageRepoRepo = repo.NewIImageRepoRepo()
+	composeRepo   = repo.NewIComposeTemplateRepo()
 
-	cronjobRepo = repo.RepoGroupApp.CronjobRepo
+	cronjobRepo = repo.NewICronjobRepo()
 
-	hostRepo    = repo.RepoGroupApp.HostRepo
-	groupRepo   = repo.RepoGroupApp.GroupRepo
-	commandRepo = repo.RepoGroupApp.CommandRepo
+	hostRepo    = repo.NewIHostRepo()
+	groupRepo   = repo.NewIGroupRepo()
+	commandRepo = repo.NewICommandRepo()
 
-	settingRepo = repo.RepoGroupApp.SettingRepo
-	backupRepo  = repo.RepoGroupApp.BackupRepo
+	settingRepo = repo.NewISettingRepo()
+	backupRepo  = repo.NewIBackupRepo()
 
 	websiteRepo       = repo.NewIWebsiteRepo()
-	websiteDomainRepo = repo.RepoGroupApp.WebsiteDomainRepo
-	websiteDnsRepo    = repo.RepoGroupApp.WebsiteDnsAccountRepo
+	websiteDomainRepo = repo.NewIWebsiteDomainRepo()
+	websiteDnsRepo    = repo.NewIWebsiteDnsAccountRepo()
 	websiteSSLRepo    = repo.NewISSLRepo()
 	websiteAcmeRepo   = repo.NewIAcmeAccountRepo()
 
-	logRepo      = repo.RepoGroupApp.LogRepo
+	logRepo      = repo.NewILogRepo()
 	snapshotRepo = repo.NewISnapshotRepo()
+
+	runtimeRepo = repo.NewIRunTimeRepo()
 )

backend/app/service/file.go

@@ -22,7 +22,30 @@ import (
 type FileService struct {
 }
 
-func (f FileService) GetFileList(op request.FileOption) (response.FileInfo, error) {
+type IFileService interface {
+	GetFileList(op request.FileOption) (response.FileInfo, error)
+	SearchUploadWithPage(req request.SearchUploadWithPage) (int64, interface{}, error)
+	GetFileTree(op request.FileOption) ([]response.FileTree, error)
+	Create(op request.FileCreate) error
+	Delete(op request.FileDelete) error
+	BatchDelete(op request.FileBatchDelete) error
+	ChangeMode(op request.FileCreate) error
+	Compress(c request.FileCompress) error
+	DeCompress(c request.FileDeCompress) error
+	GetContent(op request.FileOption) (response.FileInfo, error)
+	SaveContent(edit request.FileEdit) error
+	FileDownload(d request.FileDownload) (string, error)
+	DirSize(req request.DirSizeReq) (response.DirSizeRes, error)
+	ChangeName(req request.FileRename) error
+	Wget(w request.FileWget) (string, error)
+	MvFile(m request.FileMove) error
+}
+
+func NewIFileService() IFileService {
+	return &FileService{}
+}
+
+func (f *FileService) GetFileList(op request.FileOption) (response.FileInfo, error) {
 	var fileInfo response.FileInfo
 	if _, err := os.Stat(op.Path); err != nil && os.IsNotExist(err) {
 		return fileInfo, nil
@@ -35,7 +58,7 @@ func (f FileService) GetFileList(op request.FileOption) (response.FileInfo, erro
 	return fileInfo, nil
 }
 
-func (f FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (int64, interface{}, error) {
+func (f *FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (int64, interface{}, error) {
 	var (
 		files    []response.UploadInfo
 		backData []response.UploadInfo
@@ -65,7 +88,7 @@ func (f FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (int
 	return int64(total), backData, nil
 }
 
-func (f FileService) GetFileTree(op request.FileOption) ([]response.FileTree, error) {
+func (f *FileService) GetFileTree(op request.FileOption) ([]response.FileTree, error) {
 	var treeArray []response.FileTree
 	info, err := files.NewFileInfo(op.FileOption)
 	if err != nil {
@@ -88,7 +111,7 @@ func (f FileService) GetFileTree(op request.FileOption) ([]response.FileTree, er
 	return append(treeArray, node), nil
 }
 
-func (f FileService) Create(op request.FileCreate) error {
+func (f *FileService) Create(op request.FileCreate) error {
 	fo := files.NewFileOp()
 	if fo.Stat(op.Path) {
 		return buserr.New(constant.ErrFileIsExit)
@@ -107,7 +130,7 @@ func (f FileService) Create(op request.FileCreate) error {
 	}
 }
 
-func (f FileService) Delete(op request.FileDelete) error {
+func (f *FileService) Delete(op request.FileDelete) error {
 	fo := files.NewFileOp()
 	if op.IsDir {
 		return fo.DeleteDir(op.Path)
@@ -116,7 +139,7 @@ func (f FileService) Delete(op request.FileDelete) error {
 	}
 }
 
-func (f FileService) BatchDelete(op request.FileBatchDelete) error {
+func (f *FileService) BatchDelete(op request.FileBatchDelete) error {
 	fo := files.NewFileOp()
 	if op.IsDir {
 		for _, file := range op.Paths {
@@ -134,12 +157,12 @@ func (f FileService) BatchDelete(op request.FileBatchDelete) error {
 	return nil
 }
 
-func (f FileService) ChangeMode(op request.FileCreate) error {
+func (f *FileService) ChangeMode(op request.FileCreate) error {
 	fo := files.NewFileOp()
 	return fo.Chmod(op.Path, fs.FileMode(op.Mode))
 }
 
-func (f FileService) Compress(c request.FileCompress) error {
+func (f *FileService) Compress(c request.FileCompress) error {
 	fo := files.NewFileOp()
 	if !c.Replace && fo.Stat(filepath.Join(c.Dst, c.Name)) {
 		return buserr.New(constant.ErrFileIsExit)
@@ -147,12 +170,12 @@ func (f FileService) Compress(c request.FileCompress) error {
 	return fo.Compress(c.Files, c.Dst, c.Name, files.CompressType(c.Type))
 }
 
-func (f FileService) DeCompress(c request.FileDeCompress) error {
+func (f *FileService) DeCompress(c request.FileDeCompress) error {
 	fo := files.NewFileOp()
 	return fo.Decompress(c.Path, c.Dst, files.CompressType(c.Type))
 }
 
-func (f FileService) GetContent(op request.FileOption) (response.FileInfo, error) {
+func (f *FileService) GetContent(op request.FileOption) (response.FileInfo, error) {
 	info, err := files.NewFileInfo(op.FileOption)
 	if err != nil {
 		return response.FileInfo{}, err
@@ -160,7 +183,7 @@ func (f FileService) GetContent(op request.FileOption) (response.FileInfo, error
 	return response.FileInfo{FileInfo: *info}, nil
 }
 
-func (f FileService) SaveContent(edit request.FileEdit) error {
+func (f *FileService) SaveContent(edit request.FileEdit) error {
 	info, err := files.NewFileInfo(files.FileOption{
 		Path:   edit.Path,
 		Expand: false,
@@ -173,18 +196,18 @@ func (f FileService) SaveContent(edit request.FileEdit) error {
 	return fo.WriteFile(edit.Path, strings.NewReader(edit.Content), info.FileMode)
 }
 
-func (f FileService) ChangeName(req request.FileRename) error {
+func (f *FileService) ChangeName(req request.FileRename) error {
 	fo := files.NewFileOp()
 	return fo.Rename(req.OldName, req.NewName)
 }
 
-func (f FileService) Wget(w request.FileWget) (string, error) {
+func (f *FileService) Wget(w request.FileWget) (string, error) {
 	fo := files.NewFileOp()
 	key := "file-wget-" + common.GetUuid()
 	return key, fo.DownloadFileWithProcess(w.Url, filepath.Join(w.Path, w.Name), key)
 }
 
-func (f FileService) MvFile(m request.FileMove) error {
+func (f *FileService) MvFile(m request.FileMove) error {
 	fo := files.NewFileOp()
 	if !fo.Stat(m.NewPath) {
 		return buserr.New(constant.ErrPathNotFound)
@@ -217,7 +240,7 @@ func (f FileService) MvFile(m request.FileMove) error {
 	return nil
 }
 
-func (f FileService) FileDownload(d request.FileDownload) (string, error) {
+func (f *FileService) FileDownload(d request.FileDownload) (string, error) {
 	filePath := d.Paths[0]
 	if d.Compress {
 		tempPath := filepath.Join(os.TempDir(), fmt.Sprintf("%d", time.Now().UnixNano()))
@@ -233,7 +256,7 @@ func (f FileService) FileDownload(d request.FileDownload) (string, error) {
 	return filePath, nil
 }
 
-func (f FileService) DirSize(req request.DirSizeReq) (response.DirSizeRes, error) {
+func (f *FileService) DirSize(req request.DirSizeReq) (response.DirSizeRes, error) {
 	fo := files.NewFileOp()
 	size, err := fo.GetDirSize(req.Path)
 	if err != nil {

backend/app/service/firewall.go

@@ -0,0 +1,440 @@
+package service
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
+	"github.com/1Panel-dev/1Panel/backend/utils/firewall"
+	fireClient "github.com/1Panel-dev/1Panel/backend/utils/firewall/client"
+	"github.com/jinzhu/copier"
+)
+
+const confPath = "/etc/sysctl.conf"
+
+type FirewallService struct{}
+
+type IFirewallService interface {
+	LoadBaseInfo() (dto.FirewallBaseInfo, error)
+	SearchWithPage(search dto.RuleSearch) (int64, interface{}, error)
+	OperateFirewall(operation string) error
+	OperatePortRule(req dto.PortRuleOperate, reload bool) error
+	OperateAddressRule(req dto.AddrRuleOperate, reload bool) error
+	UpdatePortRule(req dto.PortRuleUpdate) error
+	UpdateAddrRule(req dto.AddrRuleUpdate) error
+	BacthOperateRule(req dto.BatchRuleOperate) error
+}
+
+func NewIFirewallService() IFirewallService {
+	return &FirewallService{}
+}
+
+func (u *FirewallService) LoadBaseInfo() (dto.FirewallBaseInfo, error) {
+	var baseInfo dto.FirewallBaseInfo
+	baseInfo.PingStatus = u.pingStatus()
+	baseInfo.Status = "not running"
+	baseInfo.Version = "-"
+	baseInfo.Name = "-"
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		if err.Error() == "no such type" {
+			return baseInfo, nil
+		}
+		return baseInfo, err
+	}
+	baseInfo.Name = client.Name()
+	baseInfo.Status, err = client.Status()
+	if err != nil {
+		return baseInfo, err
+	}
+	if baseInfo.Status == "not running" {
+		return baseInfo, err
+	}
+	baseInfo.Version, err = client.Version()
+	if err != nil {
+		return baseInfo, err
+	}
+	return baseInfo, nil
+}
+
+func (u *FirewallService) SearchWithPage(req dto.RuleSearch) (int64, interface{}, error) {
+	var (
+		datas     []fireClient.FireInfo
+		backDatas []fireClient.FireInfo
+	)
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return 0, nil, err
+	}
+	if req.Type == "port" {
+		ports, err := client.ListPort()
+		if err != nil {
+			return 0, nil, err
+		}
+		if len(req.Info) != 0 {
+			for _, port := range ports {
+				if strings.Contains(port.Port, req.Info) {
+					datas = append(datas, port)
+				}
+			}
+		} else {
+			datas = ports
+		}
+	} else {
+		addrs, err := client.ListAddress()
+		if err != nil {
+			return 0, nil, err
+		}
+		if len(req.Info) != 0 {
+			for _, addr := range addrs {
+				if strings.Contains(addr.Address, req.Info) {
+					datas = append(datas, addr)
+				}
+			}
+		} else {
+			datas = addrs
+		}
+	}
+	total, start, end := len(datas), (req.Page-1)*req.PageSize, req.Page*req.PageSize
+	if start > total {
+		backDatas = make([]fireClient.FireInfo, 0)
+	} else {
+		if end >= total {
+			end = total
+		}
+		backDatas = datas[start:end]
+	}
+
+	if req.Type == "port" {
+		apps := u.loadPortByApp()
+		for i := 0; i < len(backDatas); i++ {
+			port, _ := strconv.Atoi(backDatas[i].Port)
+			backDatas[i].IsUsed = common.ScanPort(port)
+			if backDatas[i].Protocol == "udp" {
+				backDatas[i].IsUsed = common.ScanUDPPort(port)
+				continue
+			}
+			for _, app := range apps {
+				if app.HttpPort == backDatas[i].Port || app.HttpsPort == backDatas[i].Port {
+					backDatas[i].APPName = app.AppName
+					break
+				}
+			}
+		}
+	}
+
+	return int64(total), backDatas, nil
+}
+
+func (u *FirewallService) OperateFirewall(operation string) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	switch operation {
+	case "start":
+		if err := client.Start(); err != nil {
+			return err
+		}
+		if err := u.addPortsBeforeStart(client); err != nil {
+			_ = client.Stop()
+			return err
+		}
+		_, _ = cmd.Exec("systemctl restart docker")
+		return nil
+	case "stop":
+		if err := client.Stop(); err != nil {
+			return err
+		}
+		_, _ = cmd.Exec("systemctl restart docker")
+		return nil
+	case "disablePing":
+		return u.updatePingStatus("0")
+	case "enablePing":
+		return u.updatePingStatus("1")
+	}
+	return fmt.Errorf("not support such operation: %s", operation)
+}
+
+func (u *FirewallService) OperatePortRule(req dto.PortRuleOperate, reload bool) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	if client.Name() == "ufw" {
+		req.Port = strings.ReplaceAll(req.Port, "-", ":")
+		if req.Operation == "remove" && req.Protocol == "tcp/udp" {
+			req.Protocol = ""
+			return u.operatePort(client, req)
+		}
+	}
+	if req.Protocol == "tcp/udp" {
+		if client.Name() == "firewalld" && strings.Contains(req.Port, ",") {
+			ports := strings.Split(req.Port, ",")
+			for _, port := range ports {
+				if len(port) == 0 {
+					continue
+				}
+				req.Port = port
+				req.Protocol = "tcp"
+				if err := u.operatePort(client, req); err != nil {
+					return err
+				}
+				req.Protocol = "udp"
+				if err := u.operatePort(client, req); err != nil {
+					return err
+				}
+			}
+		} else {
+			req.Protocol = "tcp"
+			if err := u.operatePort(client, req); err != nil {
+				return err
+			}
+			req.Protocol = "udp"
+			if err := u.operatePort(client, req); err != nil {
+				return err
+			}
+		}
+	} else {
+		if strings.Contains(req.Port, ",") {
+			ports := strings.Split(req.Port, ",")
+			for _, port := range ports {
+				req.Port = port
+				if err := u.operatePort(client, req); err != nil {
+					return err
+				}
+			}
+		} else {
+			if err := u.operatePort(client, req); err != nil {
+				return err
+			}
+		}
+	}
+	if reload {
+		return client.Reload()
+	}
+	return nil
+}
+
+func (u *FirewallService) OperateAddressRule(req dto.AddrRuleOperate, reload bool) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+
+	var fireInfo fireClient.FireInfo
+	if err := copier.Copy(&fireInfo, &req); err != nil {
+		return err
+	}
+
+	addressList := strings.Split(req.Address, ",")
+	for _, addr := range addressList {
+		if len(addr) == 0 {
+			continue
+		}
+		fireInfo.Address = addr
+		if err := client.RichRules(fireInfo, req.Operation); err != nil {
+			return err
+		}
+	}
+	if reload {
+		return client.Reload()
+	}
+	return nil
+}
+
+func (u *FirewallService) UpdatePortRule(req dto.PortRuleUpdate) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	if err := u.OperatePortRule(req.OldRule, false); err != nil {
+		return err
+	}
+	if err := u.OperatePortRule(req.NewRule, false); err != nil {
+		return err
+	}
+	return client.Reload()
+}
+
+func (u *FirewallService) UpdateAddrRule(req dto.AddrRuleUpdate) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	if err := u.OperateAddressRule(req.OldRule, false); err != nil {
+		return err
+	}
+	if err := u.OperateAddressRule(req.NewRule, false); err != nil {
+		return err
+	}
+	return client.Reload()
+}
+
+func (u *FirewallService) BacthOperateRule(req dto.BatchRuleOperate) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	if req.Type == "port" {
+		for _, rule := range req.Rules {
+			if err := u.OperatePortRule(rule, false); err != nil {
+				return err
+			}
+		}
+		return client.Reload()
+	}
+	for _, rule := range req.Rules {
+		itemRule := dto.AddrRuleOperate{Operation: rule.Operation, Address: rule.Address, Strategy: rule.Strategy}
+		if err := u.OperateAddressRule(itemRule, false); err != nil {
+			return err
+		}
+	}
+	return client.Reload()
+}
+
+func OperateFirewallPort(oldPorts, newPorts []int) error {
+	client, err := firewall.NewFirewallClient()
+	if err != nil {
+		return err
+	}
+	for _, port := range newPorts {
+
+		if err := client.Port(fireClient.FireInfo{Port: strconv.Itoa(port), Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+			return err
+		}
+	}
+	for _, port := range oldPorts {
+		if err := client.Port(fireClient.FireInfo{Port: strconv.Itoa(port), Protocol: "tcp", Strategy: "accept"}, "remove"); err != nil {
+			return err
+		}
+	}
+	return client.Reload()
+}
+
+func (u *FirewallService) operatePort(client firewall.FirewallClient, req dto.PortRuleOperate) error {
+	var fireInfo fireClient.FireInfo
+	if err := copier.Copy(&fireInfo, &req); err != nil {
+		return err
+	}
+
+	if client.Name() == "ufw" {
+		if len(fireInfo.Address) != 0 && fireInfo.Address != "Anywhere" {
+			return client.RichRules(fireInfo, req.Operation)
+		}
+		return client.Port(fireInfo, req.Operation)
+	}
+
+	if len(fireInfo.Address) != 0 || fireInfo.Strategy == "drop" {
+		return client.RichRules(fireInfo, req.Operation)
+	}
+	return client.Port(fireInfo, req.Operation)
+}
+
+type portOfApp struct {
+	AppName   string
+	HttpPort  string
+	HttpsPort string
+}
+
+func (u *FirewallService) loadPortByApp() []portOfApp {
+	var datas []portOfApp
+	apps, err := appInstallRepo.ListBy()
+	if err != nil {
+		return datas
+	}
+	for i := 0; i < len(apps); i++ {
+		datas = append(datas, portOfApp{
+			AppName:   apps[i].App.Key,
+			HttpPort:  strconv.Itoa(apps[i].HttpPort),
+			HttpsPort: strconv.Itoa(apps[i].HttpsPort),
+		})
+	}
+	systemPort, err := settingRepo.Get(settingRepo.WithByKey("ServerPort"))
+	if err != nil {
+		return datas
+	}
+	datas = append(datas, portOfApp{AppName: "1panel", HttpPort: systemPort.Value})
+
+	return datas
+}
+
+func (u *FirewallService) pingStatus() string {
+	if _, err := os.Stat("/etc/sysctl.conf"); err != nil {
+		return constant.StatusNone
+	}
+	stdout, _ := cmd.Exec("sudo cat /etc/sysctl.conf | grep net/ipv4/icmp_echo_ignore_all= ")
+	if stdout == "net/ipv4/icmp_echo_ignore_all=1\n" {
+		return constant.StatusEnable
+	}
+	return constant.StatusDisable
+}
+
+func (u *FirewallService) updatePingStatus(enabel string) error {
+	lineBytes, err := os.ReadFile(confPath)
+	if err != nil {
+		return err
+	}
+	files := strings.Split(string(lineBytes), "\n")
+	var newFiles []string
+	hasLine := false
+	for _, line := range files {
+		if strings.Contains(line, "net/ipv4/icmp_echo_ignore_all") || strings.HasPrefix(line, "net/ipv4/icmp_echo_ignore_all") {
+			newFiles = append(newFiles, "net/ipv4/icmp_echo_ignore_all="+enabel)
+			hasLine = true
+		} else {
+			newFiles = append(newFiles, line)
+		}
+	}
+	if !hasLine {
+		newFiles = append(newFiles, "net/ipv4/icmp_echo_ignore_all="+enabel)
+	}
+	file, err := os.OpenFile(confPath, os.O_WRONLY|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	_, err = file.WriteString(strings.Join(newFiles, "\n"))
+	if err != nil {
+		return err
+	}
+
+	stdout, err := cmd.Exec("sudo sysctl -p")
+	if err != nil {
+		return fmt.Errorf("update ping status failed, err: %v", stdout)
+	}
+
+	return nil
+}
+
+func (u *FirewallService) addPortsBeforeStart(client firewall.FirewallClient) error {
+	serverPort, err := settingRepo.Get(settingRepo.WithByKey("ServerPort"))
+	if err != nil {
+		return err
+	}
+	if err := client.Port(fireClient.FireInfo{Port: serverPort.Value, Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+		return err
+	}
+	if err := client.Port(fireClient.FireInfo{Port: "22", Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+		return err
+	}
+	if err := client.Port(fireClient.FireInfo{Port: "80", Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+		return err
+	}
+	if err := client.Port(fireClient.FireInfo{Port: "443", Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+		return err
+	}
+	apps := u.loadPortByApp()
+	for _, app := range apps {
+		if err := client.Port(fireClient.FireInfo{Port: app.HttpPort, Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
+			return err
+		}
+	}
+
+	return client.Reload()
+}

backend/app/service/host.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"encoding/base64"
 	"fmt"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -15,6 +16,7 @@ type HostService struct{}
 
 type IHostService interface {
 	TestLocalConn(id uint) bool
+	TestByInfo(req dto.HostConnTest) bool
 	GetHostInfo(id uint) (*model.Host, error)
 	SearchForTree(search dto.SearchForTree) ([]dto.HostTree, error)
 	SearchWithPage(search dto.SearchHostWithPage) (int64, interface{}, error)
@@ -27,6 +29,46 @@ func NewIHostService() IHostService {
 	return &HostService{}
 }
 
+func (u *HostService) TestByInfo(req dto.HostConnTest) bool {
+	if req.AuthMode == "password" && len(req.Password) != 0 {
+		password, err := base64.StdEncoding.DecodeString(req.Password)
+		if err != nil {
+			return false
+		}
+		req.Password = string(password)
+	}
+	if req.AuthMode == "key" && len(req.PrivateKey) != 0 {
+		privateKey, err := base64.StdEncoding.DecodeString(req.PrivateKey)
+		if err != nil {
+			return false
+		}
+		req.PrivateKey = string(privateKey)
+	}
+	if len(req.Password) == 0 && len(req.PrivateKey) == 0 {
+		host, err := hostRepo.Get(hostRepo.WithByAddr(req.Addr))
+		if err != nil {
+			return false
+		}
+		req.Password = host.Password
+		req.AuthMode = host.AuthMode
+		req.PrivateKey = host.PrivateKey
+		req.PassPhrase = host.PassPhrase
+	}
+
+	var connInfo ssh.ConnInfo
+	_ = copier.Copy(&connInfo, &req)
+	connInfo.PrivateKey = []byte(req.PrivateKey)
+	if len(req.PassPhrase) != 0 {
+		connInfo.PassPhrase = []byte(req.PassPhrase)
+	}
+	client, err := connInfo.NewClient()
+	if err != nil {
+		return false
+	}
+	defer client.Close()
+	return true
+}
+
 func (u *HostService) TestLocalConn(id uint) bool {
 	var (
 		host model.Host
@@ -47,6 +89,10 @@ func (u *HostService) TestLocalConn(id uint) bool {
 	if err := copier.Copy(&connInfo, &host); err != nil {
 		return false
 	}
+	connInfo.PrivateKey = []byte(host.PrivateKey)
+	if len(host.PassPhrase) != 0 {
+		connInfo.PassPhrase = []byte(host.PassPhrase)
+	}
 	client, err := connInfo.NewClient()
 	if err != nil {
 		return false
@@ -77,6 +123,11 @@ func (u *HostService) SearchWithPage(search dto.SearchHostWithPage) (int64, inte
 		}
 		group, _ := groupRepo.Get(commonRepo.WithByID(host.GroupID))
 		item.GroupBelong = group.Name
+		if !item.RememberPassword {
+			item.Password = ""
+			item.PrivateKey = ""
+			item.PassPhrase = ""
+		}
 		dtoHosts = append(dtoHosts, item)
 	}
 	return total, dtoHosts, err
@@ -144,6 +195,8 @@ func (u *HostService) Create(req dto.HostOperate) (*dto.HostInfo, error) {
 		upMap["auth_mode"] = req.AuthMode
 		upMap["password"] = req.Password
 		upMap["private_key"] = req.PrivateKey
+		upMap["pass_phrase"] = req.PassPhrase
+		upMap["remember_password"] = req.RememberPassword
 		upMap["description"] = req.Description
 		if err := hostRepo.Update(sameHostID, upMap); err != nil {
 			return nil, err

backend/app/service/image.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path"
 	"strings"
@@ -34,6 +33,7 @@ type IImageService interface {
 	ImageSave(req dto.ImageSave) error
 	ImagePush(req dto.ImagePush) (string, error)
 	ImageRemove(req dto.BatchDelete) error
+	ImageTag(req dto.ImageTag) error
 }
 
 func NewIImageService() IImageService {
@@ -173,7 +173,7 @@ func (u *ImageService) ImageBuild(req dto.ImageBuild) (string, error) {
 			return
 		}
 		defer res.Body.Close()
-		body, err := ioutil.ReadAll(res.Body)
+		body, err := io.ReadAll(res.Body)
 		if err != nil {
 			global.LOG.Errorf("build image %s failed, err: %v", req.Name, err)
 			_, _ = file.WriteString(fmt.Sprintf("build image %s failed, err: %v", req.Name, err))
@@ -274,7 +274,7 @@ func (u *ImageService) ImageLoad(req dto.ImageLoad) error {
 	if err != nil {
 		return err
 	}
-	content, err := ioutil.ReadAll(res.Body)
+	content, err := io.ReadAll(res.Body)
 	if err != nil {
 		return err
 	}

backend/app/service/image_repo.go

@@ -3,7 +3,6 @@ package service
 import (
 	"context"
 	"encoding/json"
-	"io/ioutil"
 	"os"
 	"path"
 	"strings"
@@ -190,7 +189,7 @@ func (u *ImageRepoService) handleRegistries(newHost, delHost, handle string) err
 	}
 
 	deamonMap := make(map[string]interface{})
-	file, err := ioutil.ReadFile(constant.DaemonJsonPath)
+	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		return err
 	}
@@ -226,7 +225,7 @@ func (u *ImageRepoService) handleRegistries(newHost, delHost, handle string) err
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
+	if err := os.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
 		return err
 	}
 	return nil

backend/app/service/nginx.go

@@ -1,15 +1,16 @@
 package service
 
 import (
-	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
-	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 	"path"
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
@@ -18,6 +19,18 @@ import (
 type NginxService struct {
 }
 
+type INginxService interface {
+	GetNginxConfig() (response.FileInfo, error)
+	GetConfigByScope(req request.NginxScopeReq) ([]response.NginxParam, error)
+	UpdateConfigByScope(req request.NginxConfigUpdate) error
+	GetStatus() (response.NginxStatus, error)
+	UpdateConfigFile(req request.NginxConfigFileUpdate) error
+}
+
+func NewINginxService() INginxService {
+	return &NginxService{}
+}
+
 func (n NginxService) GetNginxConfig() (response.FileInfo, error) {
 	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
 	if err != nil {
@@ -55,7 +68,7 @@ func (n NginxService) GetStatus() (response.NginxStatus, error) {
 	if err != nil {
 		return response.NginxStatus{}, err
 	}
-	content, err := ioutil.ReadAll(res.Body)
+	content, err := io.ReadAll(res.Body)
 	if err != nil {
 		return response.NginxStatus{}, err
 	}

backend/app/service/nginx_utils.go

@@ -16,6 +16,7 @@ import (
 	"os"
 	"path"
 	"strings"
+	"time"
 )
 
 func getNginxFull(website *model.Website) (dto.NginxFull, error) {
@@ -191,7 +192,7 @@ func opNginx(containerName, operate string) error {
 	if operate == constant.NginxCheck {
 		nginxCmd = fmt.Sprintf("docker exec -i %s %s", containerName, "nginx -t")
 	}
-	if out, err := cmd.Exec(nginxCmd); err != nil {
+	if out, err := cmd.ExecWithTimeOut(nginxCmd, 2*time.Second); err != nil {
 		return errors.New(out)
 	}
 	return nil

backend/app/service/runtime.go

@@ -0,0 +1,276 @@
+package service
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/app/repo"
+	"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/docker"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
+	"github.com/subosito/gotenv"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type RuntimeService struct {
+}
+
+type IRuntimeService interface {
+	Page(req request.RuntimeSearch) (int64, []response.RuntimeRes, error)
+	Create(create request.RuntimeCreate) error
+	Delete(id uint) error
+	Update(req request.RuntimeUpdate) error
+	Get(id uint) (res *response.RuntimeRes, err error)
+}
+
+func NewRuntimeService() IRuntimeService {
+	return &RuntimeService{}
+}
+
+func (r *RuntimeService) Create(create request.RuntimeCreate) (err error) {
+	exist, _ := runtimeRepo.GetFirst(runtimeRepo.WithName(create.Name))
+	if exist != nil {
+		return buserr.New(constant.ErrNameIsExist)
+	}
+	if create.Resource == constant.ResourceLocal {
+		runtime := &model.Runtime{
+			Name:     create.Name,
+			Resource: create.Resource,
+			Type:     create.Type,
+			Version:  create.Version,
+			Status:   constant.RuntimeNormal,
+		}
+		return runtimeRepo.Create(context.Background(), runtime)
+	}
+	exist, _ = runtimeRepo.GetFirst(runtimeRepo.WithImage(create.Image))
+	if exist != nil {
+		return buserr.New(constant.ErrImageExist)
+	}
+	appDetail, err := appDetailRepo.GetFirst(commonRepo.WithByID(create.AppDetailID))
+	if err != nil {
+		return err
+	}
+	app, err := appRepo.GetFirst(commonRepo.WithByID(appDetail.AppId))
+	if err != nil {
+		return err
+	}
+	fileOp := files.NewFileOp()
+	buildDir := path.Join(constant.AppResourceDir, app.Key, "versions", appDetail.Version, "build")
+	if !fileOp.Stat(buildDir) {
+		return buserr.New(constant.ErrDirNotFound)
+	}
+	runtimeDir := path.Join(constant.RuntimeDir, create.Type)
+	tempDir := filepath.Join(runtimeDir, fmt.Sprintf("%d", time.Now().UnixNano()))
+	if err = fileOp.CopyDir(buildDir, tempDir); err != nil {
+		return
+	}
+	oldDir := path.Join(tempDir, "build")
+	newNameDir := path.Join(runtimeDir, create.Name)
+	defer func() {
+		if err != nil {
+			_ = fileOp.DeleteDir(newNameDir)
+		}
+	}()
+	if oldDir != newNameDir {
+		if err = fileOp.Rename(oldDir, newNameDir); err != nil {
+			return
+		}
+		if err = fileOp.DeleteDir(tempDir); err != nil {
+			return
+		}
+	}
+	composeContent, envContent, forms, err := handleParams(create.Image, create.Type, newNameDir, create.Params)
+	if err != nil {
+		return
+	}
+	composeService, err := getComposeService(create.Name, newNameDir, composeContent, envContent, false)
+	if err != nil {
+		return
+	}
+	runtime := &model.Runtime{
+		Name:          create.Name,
+		DockerCompose: string(composeContent),
+		Env:           string(envContent),
+		AppDetailID:   create.AppDetailID,
+		Type:          create.Type,
+		Image:         create.Image,
+		Resource:      create.Resource,
+		Status:        constant.RuntimeBuildIng,
+		Version:       create.Version,
+		Params:        string(forms),
+	}
+	if err = runtimeRepo.Create(context.Background(), runtime); err != nil {
+		return
+	}
+	go buildRuntime(runtime, composeService, "")
+	return
+}
+
+func (r *RuntimeService) Page(req request.RuntimeSearch) (int64, []response.RuntimeRes, error) {
+	var (
+		opts []repo.DBOption
+		res  []response.RuntimeRes
+	)
+	if req.Name != "" {
+		opts = append(opts, commonRepo.WithLikeName(req.Name))
+	}
+	if req.Status != "" {
+		opts = append(opts, runtimeRepo.WithStatus(req.Status))
+	}
+	total, runtimes, err := runtimeRepo.Page(req.Page, req.PageSize, opts...)
+	if err != nil {
+		return 0, nil, err
+	}
+	for _, runtime := range runtimes {
+		res = append(res, response.RuntimeRes{
+			Runtime: runtime,
+		})
+	}
+	return total, res, nil
+}
+
+func (r *RuntimeService) Delete(id uint) error {
+	runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(id))
+	if err != nil {
+		return err
+	}
+	website, _ := websiteRepo.GetFirst(websiteRepo.WithRuntimeID(id))
+	if website.ID > 0 {
+		return buserr.New(constant.ErrDelWithWebsite)
+	}
+	if runtime.Resource == constant.ResourceAppstore {
+		client, err := docker.NewClient()
+		if err != nil {
+			return err
+		}
+		imageID, err := client.GetImageIDByName(runtime.Image)
+		if err != nil {
+			return err
+		}
+		if imageID != "" {
+			if err := client.DeleteImage(imageID); err != nil {
+				global.LOG.Errorf("delete image id [%s] error %v", imageID, err)
+			}
+		}
+		runtimeDir := path.Join(constant.RuntimeDir, runtime.Type, runtime.Name)
+		if err := files.NewFileOp().DeleteDir(runtimeDir); err != nil {
+			return err
+		}
+	}
+	return runtimeRepo.DeleteBy(commonRepo.WithByID(id))
+}
+
+func (r *RuntimeService) Get(id uint) (*response.RuntimeRes, error) {
+	runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(id))
+	if err != nil {
+		return nil, err
+	}
+	res := &response.RuntimeRes{}
+	res.Runtime = *runtime
+	if runtime.Resource == constant.ResourceLocal {
+		return res, nil
+	}
+	appDetail, err := appDetailRepo.GetFirst(commonRepo.WithByID(runtime.AppDetailID))
+	if err != nil {
+		return nil, err
+	}
+	res.AppID = appDetail.AppId
+	var (
+		appForm   dto.AppForm
+		appParams []response.AppParam
+	)
+	if err := json.Unmarshal([]byte(runtime.Params), &appForm); err != nil {
+		return nil, err
+	}
+	envs, err := gotenv.Unmarshal(runtime.Env)
+	if err != nil {
+		return nil, err
+	}
+	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,
+				Required: form.Required,
+			}
+			if form.Edit {
+				appParam.Edit = true
+			}
+			appParam.LabelZh = form.LabelZh
+			appParam.LabelEn = form.LabelEn
+			appParam.Multiple = form.Multiple
+			appParam.Value = v
+			if form.Type == "select" {
+				if form.Multiple {
+					if v == "" {
+						appParam.Value = []string{}
+					} else {
+						appParam.Value = strings.Split(v, ",")
+					}
+				} else {
+					for _, fv := range form.Values {
+						if fv.Value == v {
+							appParam.ShowValue = fv.Label
+							break
+						}
+					}
+				}
+				appParam.Values = form.Values
+			}
+			appParams = append(appParams, appParam)
+		}
+	}
+	res.AppParams = appParams
+	return res, nil
+}
+
+func (r *RuntimeService) Update(req request.RuntimeUpdate) error {
+	runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	oldImage := runtime.Image
+	if runtime.Resource == constant.ResourceLocal {
+		runtime.Version = req.Version
+		return runtimeRepo.Save(runtime)
+	}
+	exist, _ := runtimeRepo.GetFirst(runtimeRepo.WithImage(req.Name), runtimeRepo.WithNotId(req.ID))
+	if exist != nil {
+		return buserr.New(constant.ErrImageExist)
+	}
+	runtimeDir := path.Join(constant.RuntimeDir, runtime.Type, runtime.Name)
+	composeContent, envContent, _, err := handleParams(req.Image, runtime.Type, runtimeDir, req.Params)
+	if err != nil {
+		return err
+	}
+	composeService, err := getComposeService(runtime.Name, runtimeDir, composeContent, envContent, false)
+	if err != nil {
+		return err
+	}
+	runtime.Image = req.Image
+	runtime.Env = string(envContent)
+	runtime.DockerCompose = string(composeContent)
+	runtime.Status = constant.RuntimeBuildIng
+	_ = runtimeRepo.Save(runtime)
+	client, err := docker.NewClient()
+	if err != nil {
+		return err
+	}
+	imageID, err := client.GetImageIDByName(oldImage)
+	if err != nil {
+		return err
+	}
+	go buildRuntime(runtime, composeService, imageID)
+	return nil
+}

backend/app/service/runtime_utils.go

@@ -0,0 +1,107 @@
+package service
+
+import (
+	"fmt"
+	"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/1Panel-dev/1Panel/backend/utils/docker"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
+	"github.com/docker/cli/cli/command"
+	"github.com/subosito/gotenv"
+	"os"
+	"path"
+	"strings"
+)
+
+func buildRuntime(runtime *model.Runtime, service *docker.ComposeService, oldImageID string) {
+	err := service.ComposeBuild()
+	if err != nil {
+		runtime.Status = constant.RuntimeError
+		runtime.Message = buserr.New(constant.ErrImageBuildErr).Error() + ":" + err.Error()
+	} else {
+		runtime.Status = constant.RuntimeNormal
+		if oldImageID != "" {
+			client, err := docker.NewClient()
+			if err == nil {
+				newImageID, err := client.GetImageIDByName(runtime.Image)
+				if err == nil && newImageID != oldImageID {
+					global.LOG.Infof("delete imageID [%s] ", oldImageID)
+					if err := client.DeleteImage(oldImageID); err != nil {
+						global.LOG.Errorf("delete imageID [%s] error %v", oldImageID, err)
+					} else {
+						global.LOG.Infof("delete old image success")
+					}
+				}
+			} else {
+				global.LOG.Errorf("delete imageID [%s] error %v", oldImageID, err)
+			}
+		}
+	}
+	_ = runtimeRepo.Save(runtime)
+}
+
+func handleParams(image, runtimeType, runtimeDir string, params map[string]interface{}) (composeContent []byte, envContent []byte, forms []byte, err error) {
+	fileOp := files.NewFileOp()
+	composeContent, err = fileOp.GetContent(path.Join(runtimeDir, "docker-compose.yml"))
+	if err != nil {
+		return
+	}
+	env, err := gotenv.Read(path.Join(runtimeDir, ".env"))
+	if err != nil {
+		return
+	}
+	forms, err = fileOp.GetContent(path.Join(runtimeDir, "config.json"))
+	if err != nil {
+		return
+	}
+	params["IMAGE_NAME"] = image
+	if runtimeType == constant.RuntimePHP {
+		if extends, ok := params["PHP_EXTENSIONS"]; ok {
+			if extendsArray, ok := extends.([]interface{}); ok {
+				strArray := make([]string, len(extendsArray))
+				for i, v := range extendsArray {
+					strArray[i] = fmt.Sprintf("%v", v)
+				}
+				params["PHP_EXTENSIONS"] = strings.Join(strArray, ",")
+			}
+		}
+	}
+	newMap := make(map[string]string)
+	handleMap(params, newMap)
+	for k, v := range newMap {
+		env[k] = v
+	}
+	envStr, err := gotenv.Marshal(env)
+	if err != nil {
+		return
+	}
+	if err = gotenv.Write(env, path.Join(runtimeDir, ".env")); err != nil {
+		return
+	}
+	envContent = []byte(envStr)
+	return
+}
+
+func getComposeService(name, runtimeDir string, composeFile, env []byte, skipNormalization bool) (*docker.ComposeService, error) {
+	project, err := docker.GetComposeProject(name, runtimeDir, composeFile, env, skipNormalization)
+	if err != nil {
+		return nil, err
+	}
+	logPath := path.Join(runtimeDir, "build.log")
+	fileOp := files.NewFileOp()
+	if fileOp.Stat(logPath) {
+		_ = fileOp.DeleteFile(logPath)
+	}
+	file, err := os.Create(logPath)
+	if err != nil {
+		return nil, err
+	}
+	composeService, err := docker.NewComposeService(command.WithOutputStream(file))
+	if err != nil {
+		return nil, err
+	}
+	composeService.SetProject(project)
+	return composeService, nil
+}

backend/app/service/setting.go

@@ -70,7 +70,14 @@ func (u *SettingService) UpdatePort(port uint) error {
 	if common.ScanPort(int(port)) {
 		return buserr.WithDetail(constant.ErrPortInUsed, port, nil)
 	}
-
+	serverPort, err := settingRepo.Get(settingRepo.WithByKey("ServerPort"))
+	if err != nil {
+		return err
+	}
+	portValue, _ := strconv.Atoi(serverPort.Value)
+	if err := OperateFirewallPort([]int{portValue}, []int{int(port)}); err != nil {
+		global.LOG.Errorf("set system firewall ports failed, err: %v", err)
+	}
 	if err := settingRepo.Update("ServerPort", strconv.Itoa(int(port))); err != nil {
 		return err
 	}

backend/app/service/snapshot.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"strings"
 	"time"
@@ -484,7 +483,7 @@ func (u *SnapshotService) SnapshotRollback(req dto.SnapshotRecover) error {
 
 func (u *SnapshotService) saveJson(snapJson SnapshotJson, path string) error {
 	remarkInfo, _ := json.MarshalIndent(snapJson, "", "\t")
-	if err := ioutil.WriteFile(fmt.Sprintf("%s/snapshot.json", path), remarkInfo, 0640); err != nil {
+	if err := os.WriteFile(fmt.Sprintf("%s/snapshot.json", path), remarkInfo, 0640); err != nil {
 		return err
 	}
 	return nil
@@ -793,7 +792,7 @@ 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 := ioutil.ReadFile(constant.DaemonJsonPath)
+	file, err := os.ReadFile(constant.DaemonJsonPath)
 	if err != nil {
 		return err
 	}
@@ -809,7 +808,7 @@ func (u *SnapshotService) updateLiveRestore(enabled bool) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
+	if err := os.WriteFile(constant.DaemonJsonPath, newJson, 0640); err != nil {
 		return err
 	}
 
@@ -855,7 +854,7 @@ func (u *SnapshotService) handleTar(sourceDir, targetDir, name, exclusionRules s
 
 	commands := fmt.Sprintf("tar --warning=no-file-changed -zcf %s %s -C %s .", targetDir+"/"+name, exStr, sourceDir)
 	global.LOG.Debug(commands)
-	stdout, err := cmd.Exec(commands)
+	stdout, err := cmd.ExecWithTimeOut(commands, 30*time.Minute)
 	if err != nil {
 		global.LOG.Errorf("do handle tar failed, stdout: %s, err: %v", stdout, err)
 		return errors.New(stdout)
@@ -872,7 +871,7 @@ func (u *SnapshotService) handleUnTar(sourceDir, targetDir string) error {
 
 	commands := fmt.Sprintf("tar -zxf %s -C %s .", sourceDir, targetDir)
 	global.LOG.Debug(commands)
-	stdout, err := cmd.Exec(commands)
+	stdout, err := cmd.ExecWithTimeOut(commands, 30*time.Minute)
 	if err != nil {
 		global.LOG.Errorf("do handle untar failed, stdout: %s, err: %v", stdout, err)
 		return errors.New(stdout)

backend/app/service/upgrade.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"os"
 	"runtime"
@@ -148,7 +148,7 @@ func (u *UpgradeService) Upgrade(req dto.Upgrade) error {
 		go writeLogs(req.Version)
 		_ = settingRepo.Update("SystemVersion", req.Version)
 		_ = settingRepo.Update("SystemStatus", "Free")
-		_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
+		_, _ = cmd.ExecWithTimeOut("systemctl daemon-reload && systemctl restart 1panel.service", 1*time.Minute)
 	}()
 	return nil
 }
@@ -203,7 +203,7 @@ func (u *UpgradeService) loadVersion(isLatest bool, currentVersion string) (stri
 		return "", err
 	}
 	defer latestVersionRes.Body.Close()
-	version, err := ioutil.ReadAll(latestVersionRes.Body)
+	version, err := io.ReadAll(latestVersionRes.Body)
 	if err != nil {
 		return "", err
 	}
@@ -231,7 +231,7 @@ func (u *UpgradeService) loadReleaseNotes(path string) (string, error) {
 		return "", err
 	}
 	defer releaseNotes.Body.Close()
-	release, err := ioutil.ReadAll(releaseNotes.Body)
+	release, err := io.ReadAll(releaseNotes.Body)
 	if err != nil {
 		return "", err
 	}

backend/app/service/website.go

@@ -1,13 +1,21 @@
 package service
 
 import (
+	"bufio"
+	"bytes"
 	"context"
 	"crypto/x509"
 	"encoding/pem"
+	"errors"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/1Panel-dev/1Panel/cmd/server/nginx_conf"
+	"gorm.io/gorm"
 	"os"
 	"path"
 	"reflect"
+	"regexp"
 	"strings"
 	"time"
 
@@ -21,8 +29,6 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
 )
 
 type WebsiteService struct {
@@ -31,18 +37,18 @@ type WebsiteService struct {
 type IWebsiteService interface {
 	PageWebsite(req request.WebsiteSearch) (int64, []response.WebsiteDTO, error)
 	GetWebsites() ([]response.WebsiteDTO, error)
-	CreateWebsite(ctx context.Context, create request.WebsiteCreate) error
+	CreateWebsite(create request.WebsiteCreate) error
 	OpWebsite(req request.WebsiteOp) error
 	GetWebsiteOptions() ([]string, error)
 	UpdateWebsite(req request.WebsiteUpdate) error
-	DeleteWebsite(ctx context.Context, req request.WebsiteDelete) error
+	DeleteWebsite(req request.WebsiteDelete) error
 	GetWebsite(id uint) (response.WebsiteDTO, error)
 	CreateWebsiteDomain(create request.WebsiteDomainCreate) (model.WebsiteDomain, error)
 	GetWebsiteDomain(websiteId uint) ([]model.WebsiteDomain, error)
 	DeleteWebsiteDomain(domainId uint) error
 	GetNginxConfigByScope(req request.NginxScopeReq) (*response.WebsiteNginxConfig, error)
 	UpdateNginxConfigByScope(req request.NginxConfigUpdate) error
-	GetWebsiteNginxConfig(websiteId uint) (response.FileInfo, error)
+	GetWebsiteNginxConfig(websiteId uint, configType string) (response.FileInfo, error)
 	GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS, error)
 	OpWebsiteHTTPS(ctx context.Context, req request.WebsiteHTTPSOp) (response.WebsiteHTTPS, error)
 	PreInstallCheck(req request.WebsiteInstallCheckReq) ([]response.WebsitePreInstallCheck, error)
@@ -50,9 +56,17 @@ type IWebsiteService interface {
 	UpdateWafConfig(req request.WebsiteWafUpdate) error
 	UpdateNginxConfigFile(req request.WebsiteNginxUpdate) error
 	OpWebsiteLog(req request.WebsiteLogReq) (*response.WebsiteLog, error)
+	ChangeDefaultServer(id uint) error
+	GetPHPConfig(id uint) (*response.PHPConfig, error)
+	UpdatePHPConfig(req request.WebsitePHPConfigUpdate) error
+	UpdatePHPConfigFile(req request.WebsitePHPFileUpdate) error
+	GetRewriteConfig(req request.NginxRewriteReq) (*response.NginxRewriteRes, error)
+	UpdateRewriteConfig(req request.NginxRewriteUpdate) error
+	UpdateSiteDir(req request.WebsiteUpdateDir) error
+	UpdateSitePermission(req request.WebsiteUpdateDirPermission) error
 }
 
-func NewWebsiteService() IWebsiteService {
+func NewIWebsiteService() IWebsiteService {
 	return &WebsiteService{}
 }
 
@@ -73,17 +87,28 @@ func (w WebsiteService) PageWebsite(req request.WebsiteSearch) (int64, []respons
 		return 0, nil, err
 	}
 	for _, web := range websites {
-		var appName string
-		if web.Type == constant.Deployment {
+		var (
+			appName     string
+			runtimeName string
+		)
+		switch web.Type {
+		case constant.Deployment:
 			appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(web.AppInstallID))
 			if err != nil {
 				return 0, nil, err
 			}
 			appName = appInstall.Name
+		case constant.Runtime:
+			runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(web.RuntimeID))
+			if err != nil {
+				return 0, nil, err
+			}
+			runtimeName = runtime.Name
 		}
 		websiteDTOs = append(websiteDTOs, response.WebsiteDTO{
-			Website: web,
-			AppName: appName,
+			Website:     web,
+			AppName:     appName,
+			RuntimeName: runtimeName,
 		})
 	}
 	return total, websiteDTOs, nil
@@ -103,7 +128,7 @@ func (w WebsiteService) GetWebsites() ([]response.WebsiteDTO, error) {
 	return websiteDTOs, nil
 }
 
-func (w WebsiteService) CreateWebsite(ctx context.Context, create request.WebsiteCreate) error {
+func (w WebsiteService) CreateWebsite(create request.WebsiteCreate) (err error) {
 	if exist, _ := websiteRepo.GetBy(websiteRepo.WithDomain(create.PrimaryDomain)); len(exist) > 0 {
 		return buserr.New(constant.ErrDomainIsExist)
 	}
@@ -122,50 +147,117 @@ func (w WebsiteService) CreateWebsite(ctx context.Context, create request.Websit
 		Remark:         create.Remark,
 		Status:         constant.WebRunning,
 		ExpireDate:     defaultDate,
-		AppInstallID:   create.AppInstallID,
 		WebsiteGroupID: create.WebsiteGroupID,
 		Protocol:       constant.ProtocolHTTP,
 		Proxy:          create.Proxy,
+		SiteDir:        "/",
 		AccessLog:      true,
 		ErrorLog:       true,
 	}
 
-	var appInstall *model.AppInstall
+	var (
+		appInstall *model.AppInstall
+		runtime    *model.Runtime
+	)
+
+	defer func() {
+		if err != nil {
+			if website.AppInstallID > 0 {
+				req := request.AppInstalledOperate{
+					InstallId:   website.AppInstallID,
+					Operate:     constant.Delete,
+					ForceDelete: true,
+				}
+				if err := NewIAppInstalledService().Operate(req); err != nil {
+					global.LOG.Errorf(err.Error())
+				}
+			}
+		}
+	}()
+	var proxy string
+
 	switch create.Type {
 	case constant.Deployment:
 		if create.AppType == constant.NewApp {
-			var req request.AppInstallCreate
+			var (
+				req     request.AppInstallCreate
+				install *model.AppInstall
+			)
 			req.Name = create.AppInstall.Name
 			req.AppDetailId = create.AppInstall.AppDetailId
 			req.Params = create.AppInstall.Params
-			install, err := ServiceGroupApp.Install(ctx, req)
+			tx, installCtx := getTxAndContext()
+			install, err = NewIAppService().Install(installCtx, req)
 			if err != nil {
+				tx.Rollback()
 				return err
 			}
-			website.AppInstallID = install.ID
+			tx.Commit()
 			appInstall = install
+			website.AppInstallID = install.ID
+			website.Proxy = fmt.Sprintf("127.0.0.1:%d", appInstall.HttpPort)
 		} else {
-			install, err := appInstallRepo.GetFirst(commonRepo.WithByID(create.AppInstallID))
+			var install model.AppInstall
+			install, err = appInstallRepo.GetFirst(commonRepo.WithByID(create.AppInstallID))
 			if err != nil {
 				return err
 			}
 			appInstall = &install
 			website.AppInstallID = appInstall.ID
+			website.Proxy = fmt.Sprintf("127.0.0.1:%d", appInstall.HttpPort)
+		}
+	case constant.Runtime:
+		runtime, err = runtimeRepo.GetFirst(commonRepo.WithByID(create.RuntimeID))
+		if err != nil {
+			return err
+		}
+		website.RuntimeID = runtime.ID
+		if runtime.Resource == constant.ResourceAppstore {
+			var (
+				req          request.AppInstallCreate
+				nginxInstall model.AppInstall
+				install      *model.AppInstall
+			)
+			reg, _ := regexp.Compile(`[^a-z0-9_-]+`)
+			req.Name = reg.ReplaceAllString(strings.ToLower(create.PrimaryDomain), "")
+			req.AppDetailId = create.AppInstall.AppDetailId
+			req.Params = create.AppInstall.Params
+			req.Params["IMAGE_NAME"] = runtime.Image
+			nginxInstall, err = getAppInstallByKey(constant.AppOpenresty)
+			if err != nil {
+				return err
+			}
+			req.Params["PANEL_WEBSITE_DIR"] = path.Join(nginxInstall.GetPath(), "/www")
+			tx, installCtx := getTxAndContext()
+			install, err = NewIAppService().Install(installCtx, req)
+			if err != nil {
+				tx.Rollback()
+				return err
+			}
+			tx.Commit()
+			website.AppInstallID = install.ID
+			appInstall = install
+			website.Proxy = fmt.Sprintf("127.0.0.1:%d", appInstall.HttpPort)
+		} else {
+			website.ProxyType = create.ProxyType
+			if website.ProxyType == constant.RuntimeProxyUnix {
+				proxy = fmt.Sprintf("unix:%s", path.Join("/www/sites", website.Alias, "php-pool", "php-fpm.sock"))
+			}
+			if website.ProxyType == constant.RuntimeProxyTcp {
+				proxy = fmt.Sprintf("127.0.0.1:%d", create.Port)
+			}
+			website.Proxy = proxy
 		}
 	}
 
-	if err := websiteRepo.Create(ctx, website); err != nil {
-		return err
-	}
 	var domains []model.WebsiteDomain
-	domains = append(domains, model.WebsiteDomain{Domain: website.PrimaryDomain, WebsiteID: website.ID, Port: 80})
-
+	domains = append(domains, model.WebsiteDomain{Domain: website.PrimaryDomain, Port: 80})
 	otherDomainArray := strings.Split(create.OtherDomains, "\n")
 	for _, domain := range otherDomainArray {
 		if domain == "" {
 			continue
 		}
-		domainModel, err := getDomain(domain, website.ID)
+		domainModel, err := getDomain(domain)
 		if err != nil {
 			return err
 		}
@@ -174,12 +266,22 @@ func (w WebsiteService) CreateWebsite(ctx context.Context, create request.Websit
 		}
 		domains = append(domains, domainModel)
 	}
-	if len(domains) > 0 {
-		if err := websiteDomainRepo.BatchCreate(ctx, domains); err != nil {
-			return err
-		}
+	if err = configDefaultNginx(website, domains, appInstall, runtime); err != nil {
+		return err
 	}
-	return configDefaultNginx(website, domains, appInstall)
+	tx, ctx := helper.GetTxAndContext()
+	defer tx.Rollback()
+	if err = websiteRepo.Create(ctx, website); err != nil {
+		return err
+	}
+	for i := range domains {
+		domains[i].WebsiteID = website.ID
+	}
+	if err = websiteDomainRepo.BatchCreate(ctx, domains); err != nil {
+		return err
+	}
+	tx.Commit()
+	return nil
 }
 
 func (w WebsiteService) OpWebsite(req request.WebsiteOp) error {
@@ -243,7 +345,7 @@ func (w WebsiteService) GetWebsite(id uint) (response.WebsiteDTO, error) {
 	return res, nil
 }
 
-func (w WebsiteService) DeleteWebsite(ctx context.Context, req request.WebsiteDelete) error {
+func (w WebsiteService) DeleteWebsite(req request.WebsiteDelete) error {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
 	if err != nil {
 		return err
@@ -252,44 +354,40 @@ func (w WebsiteService) DeleteWebsite(ctx context.Context, req request.WebsiteDe
 		return err
 	}
 
-	if req.DeleteApp {
-		websites, _ := websiteRepo.GetBy(websiteRepo.WithAppInstallId(website.AppInstallID))
-		if len(websites) > 1 {
-			return buserr.New(constant.ErrAppDelete)
-		}
+	if checkIsLinkApp(website) && req.DeleteApp {
 		appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 			return err
 		}
 		if !reflect.DeepEqual(model.AppInstall{}, appInstall) {
-			if err := deleteAppInstall(ctx, appInstall, true, req.ForceDelete, true); err != nil && !req.ForceDelete {
+			if err := deleteAppInstall(appInstall, true, req.ForceDelete, true); err != nil && !req.ForceDelete {
 				return err
 			}
 		}
 	}
 
-	uploadDir := fmt.Sprintf("%s/1panel/uploads/website/%s", global.CONF.System.BaseDir, website.Alias)
-	if _, err := os.Stat(uploadDir); err == nil {
-		_ = os.RemoveAll(uploadDir)
+	tx, ctx := helper.GetTxAndContext()
+	defer tx.Rollback()
+	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType("website"), commonRepo.WithByName(website.Alias))
+	if err := websiteRepo.DeleteBy(ctx, commonRepo.WithByID(req.ID)); err != nil {
+		return err
 	}
+	if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebsiteId(req.ID)); err != nil {
+		return err
+	}
+	tx.Commit()
+
 	if req.DeleteBackup {
-		localDir, err := loadLocalDir()
-		if err != nil && !req.ForceDelete {
-			return err
-		}
+		localDir, _ := loadLocalDir()
 		backupDir := fmt.Sprintf("%s/website/%s", localDir, website.Alias)
 		if _, err := os.Stat(backupDir); err == nil {
 			_ = os.RemoveAll(backupDir)
 		}
 		global.LOG.Infof("delete website %s backups successful", website.Alias)
 	}
-	_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType("website"), commonRepo.WithByName(website.Alias))
-
-	if err := websiteRepo.DeleteBy(ctx, commonRepo.WithByID(req.ID)); err != nil {
-		return err
-	}
-	if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebsiteId(req.ID)); err != nil {
-		return err
+	uploadDir := fmt.Sprintf("%s/1panel/uploads/website/%s", global.CONF.System.BaseDir, website.Alias)
+	if _, err := os.Stat(uploadDir); err == nil {
+		_ = os.RemoveAll(uploadDir)
 	}
 	return nil
 }
@@ -401,23 +499,36 @@ func (w WebsiteService) UpdateNginxConfigByScope(req request.NginxConfigUpdate)
 	return updateNginxConfig(constant.NginxScopeServer, params, &website)
 }
 
-func (w WebsiteService) GetWebsiteNginxConfig(websiteId uint) (response.FileInfo, error) {
+func (w WebsiteService) GetWebsiteNginxConfig(websiteId uint, configType string) (response.FileInfo, error) {
 	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteId))
 	if err != nil {
 		return response.FileInfo{}, err
 	}
-
-	nginxApp, err := appRepo.GetFirst(appRepo.WithKey(constant.AppOpenresty))
-	if err != nil {
-		return response.FileInfo{}, err
+	configPath := ""
+	switch configType {
+	case constant.AppOpenresty:
+		nginxApp, err := appRepo.GetFirst(appRepo.WithKey(constant.AppOpenresty))
+		if err != nil {
+			return response.FileInfo{}, err
+		}
+		nginxInstall, err := appInstallRepo.GetFirst(appInstallRepo.WithAppId(nginxApp.ID))
+		if err != nil {
+			return response.FileInfo{}, err
+		}
+		configPath = path.Join(nginxInstall.GetPath(), "conf", "conf.d", website.Alias+".conf")
+	case constant.ConfigFPM:
+		runtimeInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
+		if err != nil {
+			return response.FileInfo{}, err
+		}
+		configPath = path.Join(runtimeInstall.GetPath(), "conf", "php-fpm.conf")
+	case constant.ConfigPHP:
+		runtimeInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
+		if err != nil {
+			return response.FileInfo{}, err
+		}
+		configPath = path.Join(runtimeInstall.GetPath(), "conf", "php.ini")
 	}
-	nginxInstall, err := appInstallRepo.GetFirst(appInstallRepo.WithAppId(nginxApp.ID))
-	if err != nil {
-		return response.FileInfo{}, err
-	}
-
-	configPath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "conf", "conf.d", website.Alias+".conf")
-
 	info, err := files.NewFileInfo(files.FileOption{
 		Path:   configPath,
 		Expand: true,
@@ -764,3 +875,227 @@ func (w WebsiteService) ChangeDefaultServer(id uint) error {
 	}
 	return nil
 }
+
+func (w WebsiteService) GetPHPConfig(id uint) (*response.PHPConfig, error) {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(id))
+	if err != nil {
+		return nil, err
+	}
+	appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
+	if err != nil {
+		return nil, err
+	}
+	phpConfigPath := path.Join(appInstall.GetPath(), "conf", "php.ini")
+	fileOp := files.NewFileOp()
+	if !fileOp.Stat(phpConfigPath) {
+		return nil, buserr.WithDetail(constant.ErrFileCanNotRead, "php.ini", nil)
+	}
+	params := make(map[string]string)
+	configFile, err := fileOp.OpenFile(phpConfigPath)
+	if err != nil {
+		return nil, err
+	}
+	defer configFile.Close()
+	scanner := bufio.NewScanner(configFile)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(line, ";") {
+			continue
+		}
+		matches := regexp.MustCompile(`^\s*([a-z_]+)\s*=\s*(.*)$`).FindStringSubmatch(line)
+		if len(matches) == 3 {
+			params[matches[1]] = matches[2]
+		}
+	}
+	return &response.PHPConfig{Params: params}, nil
+}
+
+func (w WebsiteService) UpdatePHPConfig(req request.WebsitePHPConfigUpdate) (err error) {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
+	if err != nil {
+		return err
+	}
+	phpConfigPath := path.Join(appInstall.GetPath(), "conf", "php.ini")
+	fileOp := files.NewFileOp()
+	if !fileOp.Stat(phpConfigPath) {
+		return buserr.WithDetail(constant.ErrFileCanNotRead, "php.ini", nil)
+	}
+	configFile, err := fileOp.OpenFile(phpConfigPath)
+	if err != nil {
+		return err
+	}
+	defer configFile.Close()
+
+	contentBytes, err := fileOp.GetContent(phpConfigPath)
+	content := string(contentBytes)
+	lines := strings.Split(content, "\n")
+	for i, line := range lines {
+		if strings.HasPrefix(line, ";") {
+			continue
+		}
+		for key, value := range req.Params {
+			pattern := "^" + regexp.QuoteMeta(key) + "\\s*=\\s*.*$"
+			if matched, _ := regexp.MatchString(pattern, line); matched {
+				lines[i] = key + " = " + value
+			}
+		}
+	}
+	updatedContent := strings.Join(lines, "\n")
+	if err := fileOp.WriteFile(phpConfigPath, strings.NewReader(updatedContent), 0755); err != nil {
+		return err
+	}
+	appInstallReq := request.AppInstalledOperate{
+		InstallId: appInstall.ID,
+		Operate:   constant.Restart,
+	}
+	if err = NewIAppInstalledService().Operate(appInstallReq); err != nil {
+		_ = fileOp.WriteFile(phpConfigPath, strings.NewReader(string(contentBytes)), 0755)
+		return err
+	}
+	return nil
+}
+
+func (w WebsiteService) UpdatePHPConfigFile(req request.WebsitePHPFileUpdate) error {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	if website.Type != constant.Runtime {
+		return nil
+	}
+	runtime, err := runtimeRepo.GetFirst(commonRepo.WithByID(website.RuntimeID))
+	if err != nil {
+		return err
+	}
+	if runtime.Resource != constant.ResourceAppstore {
+		return nil
+	}
+	runtimeInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(website.AppInstallID))
+	if err != nil {
+		return err
+	}
+	configPath := ""
+	if req.Type == constant.ConfigFPM {
+		configPath = path.Join(runtimeInstall.GetPath(), "conf", "php-fpm.conf")
+	} else {
+		configPath = path.Join(runtimeInstall.GetPath(), "conf", "php.ini")
+	}
+	if err := files.NewFileOp().WriteFile(configPath, strings.NewReader(req.Content), 0755); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (w WebsiteService) UpdateRewriteConfig(req request.NginxRewriteUpdate) error {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
+	if err != nil {
+		return err
+	}
+	nginxFull, err := getNginxFull(&website)
+	if err != nil {
+		return err
+	}
+	includePath := fmt.Sprintf("/www/sites/%s/rewrite/%s.conf", website.Alias, website.PrimaryDomain)
+	absolutePath := path.Join(nginxFull.Install.GetPath(), includePath)
+	fileOp := files.NewFileOp()
+	var oldRewriteContent []byte
+	if !fileOp.Stat(path.Dir(absolutePath)) {
+		if err := fileOp.CreateDir(path.Dir(absolutePath), 0755); err != nil {
+			return err
+		}
+	}
+	if !fileOp.Stat(absolutePath) {
+		if err := fileOp.CreateFile(absolutePath); err != nil {
+			return err
+		}
+	} else {
+		oldRewriteContent, err = fileOp.GetContent(absolutePath)
+		if err != nil {
+			return err
+		}
+	}
+	if err := fileOp.WriteFile(absolutePath, strings.NewReader(req.Content), 0755); err != nil {
+		return err
+	}
+
+	if err := updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "include", Params: []string{includePath}}}, &website); err != nil {
+		_ = fileOp.WriteFile(absolutePath, bytes.NewReader(oldRewriteContent), 0755)
+		return err
+	}
+	website.Rewrite = req.Name
+	return websiteRepo.Save(context.Background(), &website)
+}
+
+func (w WebsiteService) GetRewriteConfig(req request.NginxRewriteReq) (*response.NginxRewriteRes, error) {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
+	if err != nil {
+		return nil, err
+	}
+	var contentByte []byte
+	if req.Name == "current" {
+		nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+		if err != nil {
+			return nil, err
+		}
+		rewriteConfPath := path.Join(nginxInstall.GetPath(), "www", "sites", website.Alias, "rewrite", fmt.Sprintf("%s.conf", website.PrimaryDomain))
+		fileOp := files.NewFileOp()
+		if fileOp.Stat(rewriteConfPath) {
+			contentByte, err = fileOp.GetContent(rewriteConfPath)
+			if err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		rewriteFile := fmt.Sprintf("rewrite/%s.conf", strings.ToLower(req.Name))
+		contentByte, err = nginx_conf.Rewrites.ReadFile(rewriteFile)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &response.NginxRewriteRes{
+		Content: string(contentByte),
+	}, err
+}
+
+func (w WebsiteService) UpdateSiteDir(req request.WebsiteUpdateDir) error {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	runDir := req.SiteDir
+	siteDir := path.Join("/www/sites", website.Alias, "index")
+	if req.SiteDir != "/" {
+		siteDir = fmt.Sprintf("%s/%s", siteDir, req.SiteDir)
+	}
+	if err := updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "root", Params: []string{siteDir}}}, &website); err != nil {
+		return err
+	}
+	website.SiteDir = runDir
+	return websiteRepo.Save(context.Background(), &website)
+}
+
+func (w WebsiteService) UpdateSitePermission(req request.WebsiteUpdateDirPermission) error {
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+	if err != nil {
+		return err
+	}
+	absoluteIndexPath := path.Join(nginxInstall.GetPath(), "www", "sites", website.Alias, "index")
+	if website.SiteDir != "/" {
+		absoluteIndexPath = path.Join(absoluteIndexPath, website.SiteDir)
+	}
+	chownCmd := fmt.Sprintf("chown -R %s:%s %s", req.User, req.Group, absoluteIndexPath)
+	if _, err := cmd.ExecWithTimeOut(chownCmd, 1*time.Second); err != nil {
+		return err
+	}
+	website.User = req.User
+	website.Group = req.Group
+	return websiteRepo.Save(context.Background(), &website)
+}

backend/app/service/website_acme_account.go

@@ -13,6 +13,16 @@ import (
 type WebsiteAcmeAccountService struct {
 }
 
+type IWebsiteAcmeAccountService interface {
+	Page(search dto.PageInfo) (int64, []response.WebsiteAcmeAccountDTO, error)
+	Create(create request.WebsiteAcmeAccountCreate) (response.WebsiteAcmeAccountDTO, error)
+	Delete(id uint) error
+}
+
+func NewIWebsiteAcmeAccountService() IWebsiteAcmeAccountService {
+	return &WebsiteAcmeAccountService{}
+}
+
 func (w WebsiteAcmeAccountService) Page(search dto.PageInfo) (int64, []response.WebsiteAcmeAccountDTO, error) {
 	total, accounts, err := websiteAcmeRepo.Page(search.Page, search.PageSize, commonRepo.WithOrderBy("created_at desc"))
 	var accountDTOs []response.WebsiteAcmeAccountDTO

backend/app/service/website_dns_account.go

@@ -13,6 +13,17 @@ import (
 type WebsiteDnsAccountService struct {
 }
 
+type IWebsiteDnsAccountService interface {
+	Page(search dto.PageInfo) (int64, []response.WebsiteDnsAccountDTO, error)
+	Create(create request.WebsiteDnsAccountCreate) (request.WebsiteDnsAccountCreate, error)
+	Update(update request.WebsiteDnsAccountUpdate) (request.WebsiteDnsAccountUpdate, error)
+	Delete(id uint) error
+}
+
+func NewIWebsiteDnsAccountService() IWebsiteDnsAccountService {
+	return &WebsiteDnsAccountService{}
+}
+
 func (w WebsiteDnsAccountService) Page(search dto.PageInfo) (int64, []response.WebsiteDnsAccountDTO, error) {
 	total, accounts, err := websiteDnsRepo.Page(search.Page, search.PageSize, commonRepo.WithOrderBy("created_at desc"))
 	var accountDTOs []response.WebsiteDnsAccountDTO

backend/app/service/website_ssl.go

@@ -83,6 +83,8 @@ func (w WebsiteSSLService) Create(create request.WebsiteSSLCreate) (request.Webs
 		return res, err
 	}
 
+	var websiteSSL model.WebsiteSSL
+
 	switch create.Provider {
 	case constant.DNSAccount:
 		dnsAccount, err := websiteDnsRepo.GetFirst(commonRepo.WithByID(create.DnsAccountID))
@@ -92,6 +94,7 @@ func (w WebsiteSSLService) Create(create request.WebsiteSSLCreate) (request.Webs
 		if err := client.UseDns(ssl.DnsType(dnsAccount.Type), dnsAccount.Authorization); err != nil {
 			return res, err
 		}
+		websiteSSL.AutoRenew = create.AutoRenew
 	case constant.Http:
 		appInstall, err := getAppInstallByKey(constant.AppOpenresty)
 		if err != nil {
@@ -100,6 +103,7 @@ func (w WebsiteSSLService) Create(create request.WebsiteSSLCreate) (request.Webs
 		if err := client.UseHTTP(path.Join(constant.AppInstallDir, constant.AppOpenresty, appInstall.Name, "root")); err != nil {
 			return res, err
 		}
+		websiteSSL.AutoRenew = create.AutoRenew
 	case constant.DnsManual:
 		if err := client.UseManualDns(); err != nil {
 			return res, err
@@ -115,7 +119,7 @@ func (w WebsiteSSLService) Create(create request.WebsiteSSLCreate) (request.Webs
 	if err != nil {
 		return res, err
 	}
-	var websiteSSL model.WebsiteSSL
+
 	websiteSSL.DnsAccountID = create.DnsAccountID
 	websiteSSL.AcmeAccountID = acmeAccount.ID
 	websiteSSL.Provider = create.Provider
@@ -133,7 +137,6 @@ func (w WebsiteSSLService) Create(create request.WebsiteSSLCreate) (request.Webs
 	websiteSSL.StartDate = cert.NotBefore
 	websiteSSL.Type = cert.Issuer.CommonName
 	websiteSSL.Organization = cert.Issuer.Organization[0]
-	websiteSSL.AutoRenew = create.AutoRenew
 
 	if err := websiteSSLRepo.Create(context.TODO(), &websiteSSL); err != nil {
 		return res, err

backend/app/service/website_utils.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"path"
 	"strconv"
 	"strings"
@@ -20,10 +21,8 @@ import (
 	"gorm.io/gorm"
 )
 
-func getDomain(domainStr string, websiteID uint) (model.WebsiteDomain, error) {
-	domain := model.WebsiteDomain{
-		WebsiteID: websiteID,
-	}
+func getDomain(domainStr string) (model.WebsiteDomain, error) {
+	domain := model.WebsiteDomain{}
 	domainArray := strings.Split(domainStr, ":")
 	if len(domainArray) == 1 {
 		domain.Domain = domainArray[0]
@@ -43,15 +42,26 @@ func getDomain(domainStr string, websiteID uint) (model.WebsiteDomain, error) {
 	return model.WebsiteDomain{}, nil
 }
 
-func createStaticHtml(website *model.Website) error {
+func createIndexFile(website *model.Website, runtime *model.Runtime) error {
 	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
 	if err != nil {
 		return err
 	}
 
 	indexFolder := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "www", "sites", website.Alias, "index")
-	indexPath := path.Join(indexFolder, "index.html")
-	indexContent := string(nginx_conf.Index)
+	indexPath := ""
+	indexContent := ""
+	switch website.Type {
+	case constant.Static:
+		indexPath = path.Join(indexFolder, "index.html")
+		indexContent = string(nginx_conf.Index)
+	case constant.Runtime:
+		if runtime.Type == constant.RuntimePHP {
+			indexPath = path.Join(indexFolder, "index.php")
+			indexContent = string(nginx_conf.IndexPHP)
+		}
+	}
+
 	fileOp := files.NewFileOp()
 	if !fileOp.Stat(indexFolder) {
 		if err := fileOp.CreateDir(indexFolder, 0755); err != nil {
@@ -63,13 +73,18 @@ func createStaticHtml(website *model.Website) error {
 			return err
 		}
 	}
+	if website.Type == constant.Runtime && runtime.Resource == constant.ResourceAppstore {
+		if err := chownRootDir(indexFolder); err != nil {
+			return err
+		}
+	}
 	if err := fileOp.WriteFile(indexPath, strings.NewReader(indexContent), 0755); err != nil {
 		return err
 	}
 	return nil
 }
 
-func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website) error {
+func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website, runtime *model.Runtime) error {
 	nginxFolder := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name)
 	siteFolder := path.Join(nginxFolder, "www", "sites", website.Alias)
 	fileOp := files.NewFileOp()
@@ -86,14 +101,25 @@ func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website)
 		if err := fileOp.CreateFile(path.Join(siteFolder, "log", "error.log")); err != nil {
 			return err
 		}
-		if err := fileOp.CreateDir(path.Join(siteFolder, "index"), 0755); err != nil {
+		if err := fileOp.CreateDir(path.Join(siteFolder, "index"), 0775); err != nil {
 			return err
 		}
 		if err := fileOp.CreateDir(path.Join(siteFolder, "ssl"), 0755); err != nil {
 			return err
 		}
-		if website.Type == constant.Static {
-			if err := createStaticHtml(website); err != nil {
+		if website.Type == constant.Runtime {
+			if runtime.Type == constant.RuntimePHP && runtime.Resource == constant.ResourceLocal {
+				phpPoolDir := path.Join(siteFolder, "php-pool")
+				if err := fileOp.CreateDir(phpPoolDir, 0755); err != nil {
+					return err
+				}
+				if err := fileOp.CreateFile(path.Join(phpPoolDir, "php-fpm.sock")); err != nil {
+					return err
+				}
+			}
+		}
+		if website.Type == constant.Static || website.Type == constant.Runtime {
+			if err := createIndexFile(website, runtime); err != nil {
 				return err
 			}
 		}
@@ -101,12 +127,12 @@ func createWebsiteFolder(nginxInstall model.AppInstall, website *model.Website)
 	return fileOp.CopyDir(path.Join(nginxFolder, "www", "common", "waf", "rules"), path.Join(siteFolder, "waf"))
 }
 
-func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain, appInstall *model.AppInstall) error {
+func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain, appInstall *model.AppInstall, runtime *model.Runtime) error {
 	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
 	if err != nil {
 		return err
 	}
-	if err := createWebsiteFolder(nginxInstall, website); err != nil {
+	if err := createWebsiteFolder(nginxInstall, website, runtime); err != nil {
 		return err
 	}
 
@@ -134,15 +160,32 @@ func configDefaultNginx(website *model.Website, domains []model.WebsiteDomain, a
 	server.UpdateDirective("set", []string{"$RulePath", path.Join(siteFolder, "waf", "rules")})
 	server.UpdateDirective("set", []string{"$logdir", path.Join(siteFolder, "log")})
 
+	rootIndex := path.Join("/www/sites", website.Alias, "index")
 	switch website.Type {
 	case constant.Deployment:
 		proxy := fmt.Sprintf("http://127.0.0.1:%d", appInstall.HttpPort)
 		server.UpdateRootProxy([]string{proxy})
 	case constant.Static:
-		server.UpdateRoot(path.Join("/www/sites", website.Alias, "index"))
-		server.UpdateRootLocation()
+		server.UpdateRoot(rootIndex)
+		//server.UpdateRootLocation()
 	case constant.Proxy:
 		server.UpdateRootProxy([]string{website.Proxy})
+	case constant.Runtime:
+		if runtime.Resource == constant.ResourceLocal {
+			switch runtime.Type {
+			case constant.RuntimePHP:
+				server.UpdateRoot(rootIndex)
+				localPath := path.Join(nginxInstall.GetPath(), rootIndex, "index.php")
+				server.UpdatePHPProxy([]string{website.Proxy}, localPath)
+			}
+		}
+		if runtime.Resource == constant.ResourceAppstore {
+			switch runtime.Type {
+			case constant.RuntimePHP:
+				server.UpdateRoot(rootIndex)
+				server.UpdatePHPProxy([]string{website.Proxy}, "")
+			}
+		}
 	}
 
 	config.FilePath = configPath
@@ -410,8 +453,11 @@ func opWebsite(website *model.Website, operate string) error {
 	}
 	server := servers[0]
 	if operate == constant.StopWeb {
-		if website.Type != constant.Static {
-			server.RemoveDirective("location", []string{"/"})
+		if website.Type == constant.Deployment || website.Type == constant.Static || website.Type == constant.Proxy {
+			server.RemoveDirective("location", []string{"", "/"})
+		}
+		if website.Type == constant.Runtime {
+			server.RemoveDirective("location", []string{"~", "[^/]\\.php(/|$)"})
 		}
 		server.UpdateRoot("/usr/share/nginx/html/stop")
 		website.Status = constant.WebStopped
@@ -432,6 +478,14 @@ func opWebsite(website *model.Website, operate string) error {
 		case constant.Proxy:
 			server.RemoveDirective("root", nil)
 			server.UpdateRootProxy([]string{website.Proxy})
+		case constant.Runtime:
+			rootIndex := path.Join("/www/sites", website.Alias, "index")
+			server.UpdateRoot(rootIndex)
+			localPath := ""
+			if website.ProxyType == constant.RuntimeProxyUnix {
+				localPath = path.Join(nginxInstall.Install.GetPath(), rootIndex, "index.php")
+			}
+			server.UpdatePHPProxy([]string{website.Proxy}, localPath)
 		}
 		website.Status = constant.WebRunning
 		now := time.Now()
@@ -446,3 +500,22 @@ func opWebsite(website *model.Website, operate string) error {
 	}
 	return nginxCheckAndReload(nginxInstall.SiteConfig.OldContent, config.FilePath, nginxInstall.Install.ContainerName)
 }
+
+func checkIsLinkApp(website model.Website) bool {
+	if website.Type == constant.Deployment {
+		return true
+	}
+	if website.Type == constant.Runtime {
+		runtime, _ := runtimeRepo.GetFirst(commonRepo.WithByID(website.RuntimeID))
+		return runtime.Resource == constant.ResourceAppstore
+	}
+	return false
+}
+
+func chownRootDir(path string) error {
+	_, err := cmd.ExecWithTimeOut(fmt.Sprintf("chown -R 1000:1000 %s", path), 1*time.Second)
+	if err != nil {
+		return err
+	}
+	return nil
+}

backend/constant/app.go

@@ -16,6 +16,9 @@ const (
 	AppOpenresty = "openresty"
 	AppMysql     = "mysql"
 	AppRedis     = "redis"
+
+	AppResourceLocal  = "local"
+	AppResourceRemote = "remote"
 )
 
 type AppOperate string

backend/constant/backup.go

@@ -8,4 +8,6 @@ const (
 	OSS          = "OSS"
 	Sftp         = "SFTP"
 	MinIo        = "MINIO"
+	Cos          = "COS"
+	Kodo         = "KODO"
 )

backend/constant/dir.go

@@ -7,8 +7,11 @@ import (
 )
 
 var (
-	DataDir        = global.CONF.System.DataDir
-	ResourceDir    = path.Join(DataDir, "resource")
-	AppResourceDir = path.Join(ResourceDir, "apps")
-	AppInstallDir  = path.Join(DataDir, "apps")
+	DataDir             = global.CONF.System.DataDir
+	ResourceDir         = path.Join(DataDir, "resource")
+	AppResourceDir      = path.Join(ResourceDir, "apps")
+	AppInstallDir       = path.Join(DataDir, "apps")
+	LocalAppResourceDir = path.Join(ResourceDir, "localApps")
+	LocalAppInstallDir  = path.Join(DataDir, "localApps")
+	RuntimeDir          = path.Join(DataDir, "runtime")
 )

backend/constant/errs.go

@@ -60,9 +60,10 @@ var (
 	ErrDbUserNotValid      = "ErrDbUserNotValid"
 	ErrUpdateBuWebsite     = "ErrUpdateBuWebsite"
 	Err1PanelNetworkFailed = "Err1PanelNetworkFailed"
+	ErrCmdTimeout          = "ErrCmdTimeout"
 )
 
-//website
+// website
 var (
 	ErrDomainIsExist = "ErrDomainIsExist"
 	ErrAliasIsExist  = "ErrAliasIsExist"
@@ -70,7 +71,7 @@ var (
 	ErrGroupIsUsed   = "ErrGroupIsUsed"
 )
 
-//ssl
+// ssl
 var (
 	ErrSSLCannotDelete     = "ErrSSLCannotDelete"
 	ErrAccountCannotDelete = "ErrAccountCannotDelete"
@@ -78,7 +79,7 @@ var (
 	ErrEmailIsExist        = "ErrEmailIsExist"
 )
 
-//file
+// file
 var (
 	ErrPathNotFound     = "ErrPathNotFound"
 	ErrMovePathFailed   = "ErrMovePathFailed"
@@ -87,19 +88,33 @@ var (
 	ErrFileUpload       = "ErrFileUpload"
 )
 
-//mysql
+// mysql
 var (
 	ErrUserIsExist     = "ErrUserIsExist"
 	ErrDatabaseIsExist = "ErrDatabaseIsExist"
+	ErrExecTimeOut     = "ErrExecTimeOut"
 )
 
-//redis
+// redis
 var (
 	ErrTypeOfRedis = "ErrTypeOfRedis"
 )
 
-//container
+// container
 var (
 	ErrInUsed       = "ErrInUsed"
 	ErrObjectInUsed = "ErrObjectInUsed"
 )
+
+// runtime
+var (
+	ErrDirNotFound    = "ErrDirNotFound"
+	ErrFileNotExist   = "ErrFileNotExist"
+	ErrImageBuildErr  = "ErrImageBuildErr"
+	ErrImageExist     = "ErrImageExist"
+	ErrDelWithWebsite = "ErrDelWithWebsite"
+)
+
+var (
+	ErrBackupInUsed = "ErrBackupInUsed"
+)

backend/constant/runtime.go

@@ -0,0 +1,15 @@
+package constant
+
+const (
+	ResourceLocal    = "local"
+	ResourceAppstore = "appstore"
+
+	RuntimeNormal   = "normal"
+	RuntimeError    = "error"
+	RuntimeBuildIng = "building"
+
+	RuntimePHP = "php"
+
+	RuntimeProxyUnix = "unix"
+	RuntimeProxyTcp  = "tcp"
+)

backend/constant/status.go

@@ -9,4 +9,5 @@ const (
 	StatusUploading = "Uploading"
 	StatusEnable    = "Enable"
 	StatusDisable   = "Disable"
+	StatusNone      = "None"
 )

backend/constant/website.go

@@ -17,6 +17,7 @@ const (
 	Deployment = "deployment"
 	Static     = "static"
 	Proxy      = "proxy"
+	Runtime    = "runtime"
 
 	SSLExisted = "existed"
 	SSLAuto    = "auto"
@@ -40,4 +41,7 @@ const (
 
 	AccessLog = "access.log"
 	ErrorLog  = "error.log"
+
+	ConfigPHP = "php"
+	ConfigFPM = "fpm"
 )

backend/cron/cron.go

@@ -15,7 +15,7 @@ import (
 func Run() {
 	nyc, _ := time.LoadLocation("Asia/Shanghai")
 	Cron := cron.New(cron.WithLocation(nyc), cron.WithChain(cron.Recover(cron.DefaultLogger)), cron.WithChain(cron.DelayIfStillRunning(cron.DefaultLogger)))
-	_, err := Cron.AddJob("@every 1m", job.NewMonitorJob())
+	_, err := Cron.AddJob("@every 5m", job.NewMonitorJob())
 	if err != nil {
 		global.LOG.Errorf("can not add monitor corn job: %s", err.Error())
 	}
@@ -44,13 +44,13 @@ func Run() {
 		}).Error; err != nil {
 		global.LOG.Errorf("start my cronjob failed, err: %v", err)
 	}
-	for _, cronjob := range cronJobs {
-		entryID, err := service.ServiceGroupApp.StartJob(&cronjob)
+	for i := 0; i < len(cronJobs); i++ {
+		entryID, err := service.NewICronjobService().StartJob(&cronJobs[i])
 		if err != nil {
-			global.LOG.Errorf("start %s job %s failed, err: %v", cronjob.Type, cronjob.Name, err)
+			global.LOG.Errorf("start %s job %s failed, err: %v", cronJobs[i].Type, cronJobs[i].Name, err)
 		}
-		if err := repo.NewICronjobRepo().Update(cronjob.ID, map[string]interface{}{"entry_id": entryID}); err != nil {
-			global.LOG.Errorf("update cronjob %s %s failed, err: %v", cronjob.Type, cronjob.Name, err)
+		if err := repo.NewICronjobRepo().Update(cronJobs[i].ID, map[string]interface{}{"entry_id": entryID}); err != nil {
+			global.LOG.Errorf("update cronjob %s %s failed, err: %v", cronJobs[i].Type, cronJobs[i].Name, err)
 		}
 	}
 }

backend/cron/job/monitor.go

@@ -66,6 +66,7 @@ func loadDiskIO() {
 	time.Sleep(60 * time.Second)
 
 	ioStat2, _ := disk.IOCounters()
+	var ioList []model.MonitorIO
 	for _, io2 := range ioStat2 {
 		for _, io1 := range ioStat {
 			if io2.Name == io1.Name {
@@ -85,13 +86,14 @@ func loadDiskIO() {
 				if writeTime > itemIO.Time {
 					itemIO.Time = writeTime
 				}
-				if err := global.DB.Create(&itemIO).Error; err != nil {
-					global.LOG.Errorf("Insert io monitoring data failed, err: %v", err)
-				}
+				ioList = append(ioList, itemIO)
 				break
 			}
 		}
 	}
+	if err := global.DB.CreateInBatches(ioList, len(ioList)).Error; err != nil {
+		global.LOG.Errorf("Insert io monitoring data failed, err: %v", err)
+	}
 }
 
 func loadNetIO() {
@@ -101,6 +103,7 @@ func loadNetIO() {
 	time.Sleep(60 * time.Second)
 
 	netStat2, _ := net.IOCounters(true)
+	var netList []model.MonitorNetwork
 	for _, net2 := range netStat2 {
 		for _, net1 := range netStat {
 			if net2.Name == net1.Name {
@@ -108,9 +111,7 @@ func loadNetIO() {
 				itemNet.Name = net1.Name
 				itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / 60
 				itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / 60
-				if err := global.DB.Create(&itemNet).Error; err != nil {
-					global.LOG.Errorf("Insert network monitoring data failed, err: %v", err)
-				}
+				netList = append(netList, itemNet)
 				break
 			}
 		}
@@ -126,11 +127,13 @@ func loadNetIO() {
 				itemNet.Name = net1.Name
 				itemNet.Up = float64(net2.BytesSent-net1.BytesSent) / 1024 / 60
 				itemNet.Down = float64(net2.BytesRecv-net1.BytesRecv) / 1024 / 60
-				if err := global.DB.Create(&itemNet).Error; err != nil {
-					global.LOG.Errorf("Insert network all monitoring data failed, err: %v", err)
-				}
+				netList = append(netList, itemNet)
 				break
 			}
 		}
 	}
+
+	if err := global.DB.CreateInBatches(netList, len(netList)).Error; err != nil {
+		global.LOG.Errorf("Insert network monitoring data failed, err: %v", err)
+	}
 }

backend/cron/job/ssl.go

@@ -3,7 +3,6 @@ package job
 import (
 	"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"
 	"time"
 )
@@ -19,19 +18,22 @@ func (ssl *ssl) Run() {
 	sslRepo := repo.NewISSLRepo()
 	sslService := service.NewIWebsiteSSLService()
 	sslList, _ := sslRepo.List()
-	global.LOG.Info("ssl renew cron job start...")
+	global.LOG.Info("The scheduled certificate update task is currently in progress ...")
 	now := time.Now().Add(10 * time.Second)
 	for _, s := range sslList {
 		if !s.AutoRenew || s.Provider == "manual" || s.Provider == "dnsManual" {
 			continue
 		}
-		expireDate, _ := time.ParseInLocation(constant.DateTimeLayout, s.ExpireDate.String(), time.Now().Location())
-		sum := expireDate.Sub(now)
-		if sum.Hours() < 720 {
+		expireDate := s.ExpireDate.In(time.Now().Location())
+		sub := expireDate.Sub(now)
+		if sub.Hours() < 720 {
+			global.LOG.Errorf("Update the SSL certificate for the [%s] domain", s.PrimaryDomain)
 			if err := sslService.Renew(s.ID); err != nil {
-				global.LOG.Errorf("renew doamin [%s] ssl failed err:%s", s.PrimaryDomain, err.Error())
+				global.LOG.Errorf("Failed to update the SSL certificate for the [%s] domain , err:%s", s.PrimaryDomain, err.Error())
+				continue
 			}
+			global.LOG.Errorf("The SSL certificate for the [%s] domain has been successfully updated", s.PrimaryDomain)
 		}
 	}
-	global.LOG.Info("ssl renew cron job end...")
+	global.LOG.Info("The scheduled certificate update task has completed")
 }

backend/cron/job/website.go

@@ -42,7 +42,7 @@ func (w *website) Run() {
 }
 
 func stopWebsite(websiteId uint, wg *sync.WaitGroup) {
-	websiteService := service.NewWebsiteService()
+	websiteService := service.NewIWebsiteService()
 	req := request.WebsiteOp{
 		ID:      websiteId,
 		Operate: constant.StopWeb,

backend/i18n/lang/en.yaml

@@ -16,6 +16,7 @@ ErrRepoNotValid: "Remote repository verification failed！"
 #common
 ErrNameIsExist: "Name is already exist"
 ErrDemoEnvironment: "Demo server, prohibit this operation!"
+ErrCmdTimeout: "Command execution timed out！"
 
 #app
 ErrPortInUsed: "{{ .detail }} port already in use"
@@ -52,10 +53,21 @@ ErrEmailIsExist: 'Email is already exist'
 #mysql
 ErrUserIsExist: "The current user already exists. Please enter a new user"
 ErrDatabaseIsExist: "The current database already exists. Please enter a new database"
+ErrExecTimeOut: "SQL execution timed out, please check the {{ .detail }} container"
 
 #redis
 ErrTypeOfRedis: "The recovery file type does not match the current persistence mode. Modify the file type and try again"
 
 #container 
 ErrInUsed: "{{ .detail }} is in use and cannot be deleted"
-ErrObjectInUsed: "This object is in use and cannot be deleted"
+ErrObjectInUsed: "This object is in use and cannot be deleted"
+
+#runtime
+ErrDirNotFound: "The build folder does not exist! Please check file integrity！"
+ErrFileNotExist: "{{ .detail }} file does not exist! Please check source file integrity！"
+ErrImageBuildErr: "Image build failed"
+ErrImageExist: "Image is already exist！"
+ErrDelWithWebsite: "The operating environment has been associated with a website and cannot be deleted"
+
+#setting
+ErrBackupInUsed: "The backup account is already being used in a cronjob and cannot be deleted."

backend/i18n/lang/zh.yaml

@@ -16,6 +16,7 @@ ErrRepoNotValid: "远程仓库校验失败！"
 #common
 ErrNameIsExist: "名称已存在"
 ErrDemoEnvironment: "演示服务器，禁止此操作!"
+ErrCmdTimeout: "命令执行超时！"
 
 #app
 ErrPortInUsed: "{{ .detail }} 端口已被占用！"
@@ -52,10 +53,21 @@ ErrEmailIsExist: '邮箱已存在'
 #mysql
 ErrUserIsExist: "当前用户已存在，请重新输入"
 ErrDatabaseIsExist: "当前数据库已存在，请重新输入"
+ErrExecTimeOut: "SQL 执行超时，请检查{{ .detail }}容器"
 
 #redis
 ErrTypeOfRedis: "恢复文件类型与当前持久化方式不符，请修改后重试"
 
 #container 
 ErrInUsed: "{{ .detail }} 正被使用，无法删除"
-ErrObjectInUsed: "该对象正被使用，无法删除"
+ErrObjectInUsed: "该对象正被使用，无法删除"
+
+#runtime
+ErrDirNotFound: "build 文件夹不存在！请检查文件完整性！"
+ErrFileNotExist: "{{ .detail }} 文件不存在！请检查源文件完整性！"
+ErrImageBuildErr: "镜像 build 失败"
+ErrImageExist: "镜像已存在！"
+ErrDelWithWebsite: "运行环境已经关联网站，无法删除"
+
+#setting
+ErrBackupInUsed: "该备份账号已在计划任务中使用，无法删除"

backend/init/app/app.go

@@ -14,8 +14,11 @@ func Init() {
 	constant.ResourceDir = path.Join(constant.DataDir, "resource")
 	constant.AppResourceDir = path.Join(constant.ResourceDir, "apps")
 	constant.AppInstallDir = path.Join(constant.DataDir, "apps")
+	constant.RuntimeDir = path.Join(constant.DataDir, "runtime")
+	constant.LocalAppResourceDir = path.Join(constant.ResourceDir, "localApps")
+	constant.LocalAppInstallDir = path.Join(constant.DataDir, "localApps")
 
-	dirs := []string{constant.DataDir, constant.ResourceDir, constant.AppResourceDir, constant.AppInstallDir, global.CONF.System.Backup}
+	dirs := []string{constant.DataDir, constant.ResourceDir, constant.AppResourceDir, constant.AppInstallDir, global.CONF.System.Backup, constant.RuntimeDir, constant.LocalAppResourceDir}
 
 	fileOp := files.NewFileOp()
 	for _, dir := range dirs {

backend/init/business/business.go

@@ -21,7 +21,7 @@ func syncApp() {
 		return
 	}
 	global.LOG.Info("sync app start...")
-	if err := service.NewIAppService().SyncAppList(); err != nil {
+	if err := service.NewIAppService().SyncAppListFromRemote(); err != nil {
 		global.LOG.Errorf("sync app error: %s", err.Error())
 		return
 	}

backend/init/db/db.go

@@ -2,6 +2,8 @@ package db
 
 import (
 	"fmt"
+	"gorm.io/gorm/logger"
+	"log"
 	"os"
 	"time"
 
@@ -24,8 +26,19 @@ func Init() {
 		}
 	}
 
+	newLogger := logger.New(
+		log.New(os.Stdout, "\r\n", log.LstdFlags),
+		logger.Config{
+			SlowThreshold:             time.Second,
+			LogLevel:                  logger.Silent,
+			IgnoreRecordNotFoundError: true,
+			Colorful:                  false,
+		},
+	)
+
 	db, err := gorm.Open(sqlite.Open(fullPath), &gorm.Config{
 		DisableForeignKeyConstraintWhenMigrating: true,
+		Logger:                                   newLogger,
 	})
 	if err != nil {
 		panic(err)

backend/init/migration/migrate.go

@@ -21,6 +21,10 @@ func Init() {
 		migrations.AddTableDatabaseMysql,
 		migrations.AddTableSnap,
 		migrations.AddDefaultGroup,
+		migrations.AddTableRuntime,
+		migrations.UpdateTableApp,
+		migrations.UpdateTableHost,
+		migrations.UpdateTableWebsite,
 	})
 	if err := m.Migrate(); err != nil {
 		global.LOG.Error(err)