1Panel/backend/app/service/website.go

767 lines
23 KiB
Go
Raw Normal View History

2022-10-28 09:04:57 +00:00
package service
import (
2022-11-03 09:06:48 +00:00
"context"
2022-11-24 09:50:47 +00:00
"crypto/x509"
"encoding/pem"
2022-11-03 09:06:48 +00:00
"fmt"
2022-11-29 09:39:10 +00:00
"os"
"path"
"reflect"
"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/repo"
"github.com/1Panel-dev/1Panel/backend/buserr"
2023-03-02 05:54:07 +00:00
"github.com/1Panel-dev/1Panel/backend/global"
2022-10-28 09:04:57 +00:00
"github.com/1Panel-dev/1Panel/backend/app/dto"
"github.com/1Panel-dev/1Panel/backend/app/model"
"github.com/1Panel-dev/1Panel/backend/constant"
2022-11-19 09:16:02 +00:00
"github.com/1Panel-dev/1Panel/backend/utils/files"
2022-11-02 07:19:14 +00:00
"github.com/pkg/errors"
"gorm.io/gorm"
2022-10-28 09:04:57 +00:00
)
type WebsiteService struct {
}
type IWebsiteService interface {
2022-12-13 09:20:13 +00:00
PageWebsite(req request.WebsiteSearch) (int64, []response.WebsiteDTO, error)
2023-01-03 08:56:36 +00:00
GetWebsites() ([]response.WebsiteDTO, error)
CreateWebsite(ctx context.Context, create request.WebsiteCreate) error
2022-12-26 08:09:21 +00:00
OpWebsite(req request.WebsiteOp) error
GetWebsiteOptions() ([]string, error)
2022-12-13 09:20:13 +00:00
UpdateWebsite(req request.WebsiteUpdate) error
2023-03-02 03:38:56 +00:00
DeleteWebsite(ctx context.Context, req request.WebsiteDelete) error
2022-12-13 09:20:13 +00:00
GetWebsite(id uint) (response.WebsiteDTO, error)
CreateWebsiteDomain(create request.WebsiteDomainCreate) (model.WebsiteDomain, error)
GetWebsiteDomain(websiteId uint) ([]model.WebsiteDomain, error)
2022-12-06 03:42:11 +00:00
DeleteWebsiteDomain(domainId uint) error
2022-12-13 10:54:46 +00:00
GetNginxConfigByScope(req request.NginxScopeReq) (*response.WebsiteNginxConfig, error)
UpdateNginxConfigByScope(req request.NginxConfigUpdate) error
2022-12-14 11:39:32 +00:00
GetWebsiteNginxConfig(websiteId uint) (response.FileInfo, error)
2022-12-13 09:20:13 +00:00
GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS, error)
2022-12-28 08:07:43 +00:00
OpWebsiteHTTPS(ctx context.Context, req request.WebsiteHTTPSOp) (response.WebsiteHTTPS, error)
2022-12-13 09:20:13 +00:00
PreInstallCheck(req request.WebsiteInstallCheckReq) ([]response.WebsitePreInstallCheck, error)
GetWafConfig(req request.WebsiteWafReq) (response.WebsiteWafConfig, error)
2022-12-06 03:42:11 +00:00
UpdateWafConfig(req request.WebsiteWafUpdate) error
2022-12-30 09:39:17 +00:00
UpdateNginxConfigFile(req request.WebsiteNginxUpdate) error
OpWebsiteLog(req request.WebsiteLogReq) (*response.WebsiteLog, error)
}
func NewWebsiteService() IWebsiteService {
return &WebsiteService{}
}
2022-12-13 09:20:13 +00:00
func (w WebsiteService) PageWebsite(req request.WebsiteSearch) (int64, []response.WebsiteDTO, error) {
var (
websiteDTOs []response.WebsiteDTO
opts []repo.DBOption
)
opts = append(opts, commonRepo.WithOrderBy("created_at desc"))
if req.Name != "" {
2023-03-02 06:56:06 +00:00
opts = append(opts, websiteRepo.WithDomainLike(req.Name))
}
if req.WebsiteGroupID != 0 {
opts = append(opts, websiteRepo.WithGroupID(req.WebsiteGroupID))
}
total, websites, err := websiteRepo.Page(req.Page, req.PageSize, opts...)
2022-11-02 07:19:14 +00:00
if err != nil {
return 0, nil, err
}
for _, web := range websites {
2023-03-09 09:50:47 +00:00
var appName string
if web.Type == constant.Deployment {
appInstall, err := appInstallRepo.GetFirst(commonRepo.WithByID(web.AppInstallID))
if err != nil {
return 0, nil, err
}
appName = appInstall.Name
}
2022-12-13 09:20:13 +00:00
websiteDTOs = append(websiteDTOs, response.WebsiteDTO{
Website: web,
2023-03-09 09:50:47 +00:00
AppName: appName,
2022-11-02 07:19:14 +00:00
})
}
return total, websiteDTOs, nil
}
2022-10-28 09:04:57 +00:00
2023-01-03 08:56:36 +00:00
func (w WebsiteService) GetWebsites() ([]response.WebsiteDTO, error) {
var websiteDTOs []response.WebsiteDTO
websites, err := websiteRepo.List()
if err != nil {
return nil, err
}
for _, web := range websites {
websiteDTOs = append(websiteDTOs, response.WebsiteDTO{
Website: web,
})
}
return websiteDTOs, nil
}
func (w WebsiteService) CreateWebsite(ctx context.Context, create request.WebsiteCreate) error {
if exist, _ := websiteRepo.GetBy(websiteRepo.WithDomain(create.PrimaryDomain)); len(exist) > 0 {
2023-03-08 06:43:38 +00:00
return buserr.New(constant.ErrDomainIsExist)
}
if exist, _ := websiteRepo.GetBy(websiteRepo.WithAlias(create.Alias)); len(exist) > 0 {
return buserr.New(constant.ErrAliasIsExist)
}
if exist, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithDomain(create.PrimaryDomain)); len(exist) > 0 {
return buserr.New(constant.ErrDomainIsExist)
}
2022-10-28 09:04:57 +00:00
defaultDate, _ := time.Parse(constant.DateLayout, constant.DefaultDate)
2022-12-13 09:20:13 +00:00
website := &model.Website{
2022-10-28 09:04:57 +00:00
PrimaryDomain: create.PrimaryDomain,
Type: create.Type,
Alias: create.Alias,
Remark: create.Remark,
Status: constant.WebRunning,
ExpireDate: defaultDate,
AppInstallID: create.AppInstallID,
2022-12-13 09:20:13 +00:00
WebsiteGroupID: create.WebsiteGroupID,
2022-11-21 03:27:56 +00:00
Protocol: constant.ProtocolHTTP,
2022-12-12 07:36:45 +00:00
Proxy: create.Proxy,
2023-01-03 10:37:57 +00:00
AccessLog: true,
ErrorLog: true,
2022-10-28 09:04:57 +00:00
}
2022-12-22 07:26:25 +00:00
var appInstall *model.AppInstall
2022-12-12 07:36:45 +00:00
switch create.Type {
case constant.Deployment:
2022-12-13 09:20:13 +00:00
if create.AppType == constant.NewApp {
var req request.AppInstallCreate
req.Name = create.AppInstall.Name
req.AppDetailId = create.AppInstall.AppDetailId
req.Params = create.AppInstall.Params
install, err := ServiceGroupApp.Install(ctx, req)
if err != nil {
return err
}
website.AppInstallID = install.ID
appInstall = install
} else {
install, err := appInstallRepo.GetFirst(commonRepo.WithByID(create.AppInstallID))
if err != nil {
return err
2022-11-21 08:28:51 +00:00
}
appInstall = &install
website.AppInstallID = appInstall.ID
2022-11-21 08:28:51 +00:00
}
2022-11-02 07:19:14 +00:00
}
2022-10-28 09:04:57 +00:00
if err := websiteRepo.Create(ctx, website); err != nil {
return err
}
2022-12-13 09:20:13 +00:00
var domains []model.WebsiteDomain
domains = append(domains, model.WebsiteDomain{Domain: website.PrimaryDomain, WebsiteID: website.ID, Port: 80})
2022-11-03 09:06:48 +00:00
otherDomainArray := strings.Split(create.OtherDomains, "\n")
for _, domain := range otherDomainArray {
2022-11-19 09:16:02 +00:00
if domain == "" {
continue
}
2022-10-28 09:04:57 +00:00
domainModel, err := getDomain(domain, website.ID)
if err != nil {
return err
}
2022-12-13 09:20:13 +00:00
if reflect.DeepEqual(domainModel, model.WebsiteDomain{}) {
2022-10-28 09:04:57 +00:00
continue
}
domains = append(domains, domainModel)
}
if len(domains) > 0 {
if err := websiteDomainRepo.BatchCreate(ctx, domains); err != nil {
return err
}
}
return configDefaultNginx(website, domains, appInstall)
2022-10-28 09:04:57 +00:00
}
2022-11-02 07:19:14 +00:00
2022-12-26 08:09:21 +00:00
func (w WebsiteService) OpWebsite(req request.WebsiteOp) error {
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
if err != nil {
return err
}
if err := opWebsite(&website, req.Operate); err != nil {
return err
}
return websiteRepo.Save(context.Background(), &website)
}
func (w WebsiteService) GetWebsiteOptions() ([]string, error) {
webs, err := websiteRepo.GetBy()
2022-11-29 09:39:10 +00:00
if err != nil {
return nil, err
2022-11-29 09:39:10 +00:00
}
var datas []string
for _, web := range webs {
datas = append(datas, web.PrimaryDomain)
2022-11-29 09:39:10 +00:00
}
return datas, nil
}
2022-12-13 09:20:13 +00:00
func (w WebsiteService) UpdateWebsite(req request.WebsiteUpdate) error {
2022-11-08 09:21:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
if err != nil {
return err
}
website.PrimaryDomain = req.PrimaryDomain
2022-12-13 09:20:13 +00:00
website.WebsiteGroupID = req.WebsiteGroupID
2022-11-08 09:21:13 +00:00
website.Remark = req.Remark
if req.ExpireDate != "" {
expireDate, err := time.Parse(constant.DateLayout, req.ExpireDate)
if err != nil {
return err
}
website.ExpireDate = expireDate
}
2022-11-08 09:21:13 +00:00
return websiteRepo.Save(context.TODO(), &website)
}
2022-12-13 09:20:13 +00:00
func (w WebsiteService) GetWebsite(id uint) (response.WebsiteDTO, error) {
var res response.WebsiteDTO
2022-11-08 09:21:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(id))
if err != nil {
2022-11-16 02:31:35 +00:00
return res, err
2022-11-08 09:21:13 +00:00
}
2022-12-13 09:20:13 +00:00
res.Website = website
nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
if err != nil {
return res, err
}
sitePath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "www", "sites", website.Alias)
res.ErrorLogPath = path.Join(sitePath, "log", "error.log")
res.AccessLogPath = path.Join(sitePath, "log", "access.log")
res.SitePath = sitePath
2022-11-16 02:31:35 +00:00
return res, nil
2022-11-08 09:21:13 +00:00
}
2023-03-02 03:38:56 +00:00
func (w WebsiteService) DeleteWebsite(ctx context.Context, req request.WebsiteDelete) error {
2022-11-02 07:19:14 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
if err != nil {
return err
}
2022-12-12 07:36:45 +00:00
if err := delNginxConfig(website, req.ForceDelete); err != nil {
2022-11-02 07:19:14 +00:00
return err
}
if req.DeleteApp {
2022-11-03 09:06:48 +00:00
websites, _ := websiteRepo.GetBy(websiteRepo.WithAppInstallId(website.AppInstallID))
if len(websites) > 1 {
2022-12-12 07:36:45 +00:00
return buserr.New(constant.ErrAppDelete)
2022-11-03 09:06:48 +00:00
}
2022-11-02 07:19:14 +00:00
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 {
2022-11-02 07:19:14 +00:00
return err
}
}
}
2023-03-02 05:54:07 +00:00
uploadDir := fmt.Sprintf("%s/1panel/uploads/website/%s", global.CONF.System.BaseDir, website.Alias)
if _, err := os.Stat(uploadDir); err == nil {
_ = os.RemoveAll(uploadDir)
}
if req.DeleteBackup {
2023-03-02 05:54:07 +00:00
localDir, err := loadLocalDir()
if err != nil && !req.ForceDelete {
return err
}
backupDir := fmt.Sprintf("%s/website/%s", localDir, website.Alias)
if _, err := os.Stat(backupDir); err == nil {
_ = os.RemoveAll(backupDir)
}
2023-03-02 05:54:07 +00:00
global.LOG.Infof("delete website %s backups successful", website.Alias)
}
2023-03-02 05:54:07 +00:00
_ = backupRepo.DeleteRecord(ctx, commonRepo.WithByType("website"), commonRepo.WithByName(website.Alias))
2022-11-02 07:19:14 +00:00
if err := websiteRepo.DeleteBy(ctx, commonRepo.WithByID(req.ID)); err != nil {
return err
}
2022-12-13 09:20:13 +00:00
if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebsiteId(req.ID)); err != nil {
2022-11-02 07:19:14 +00:00
return err
}
return nil
}
2022-11-03 09:06:48 +00:00
2022-12-13 09:20:13 +00:00
func (w WebsiteService) CreateWebsiteDomain(create request.WebsiteDomainCreate) (model.WebsiteDomain, error) {
var domainModel model.WebsiteDomain
2022-11-03 10:02:07 +00:00
var ports []int
var domains []string
2022-11-03 09:06:48 +00:00
2022-12-13 09:20:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(create.WebsiteID))
2022-11-03 10:02:07 +00:00
if err != nil {
return domainModel, err
}
2022-12-13 09:20:13 +00:00
if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(create.WebsiteID), websiteDomainRepo.WithPort(create.Port)); len(oldDomains) == 0 {
2022-11-03 10:02:07 +00:00
ports = append(ports, create.Port)
}
domains = append(domains, create.Domain)
if err := addListenAndServerName(website, ports, domains); err != nil {
return domainModel, err
}
2022-12-13 09:20:13 +00:00
domainModel = model.WebsiteDomain{
2022-11-03 10:02:07 +00:00
Domain: create.Domain,
Port: create.Port,
2022-12-13 09:20:13 +00:00
WebsiteID: create.WebsiteID,
2022-11-03 10:02:07 +00:00
}
return domainModel, websiteDomainRepo.Create(context.TODO(), &domainModel)
2022-11-03 09:06:48 +00:00
}
2022-12-13 09:20:13 +00:00
func (w WebsiteService) GetWebsiteDomain(websiteId uint) ([]model.WebsiteDomain, error) {
return websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(websiteId))
2022-11-03 09:06:48 +00:00
}
func (w WebsiteService) DeleteWebsiteDomain(domainId uint) error {
webSiteDomain, err := websiteDomainRepo.GetFirst(commonRepo.WithByID(domainId))
if err != nil {
return err
}
2022-12-13 09:20:13 +00:00
if websiteDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID)); len(websiteDomains) == 1 {
2022-11-03 09:06:48 +00:00
return fmt.Errorf("can not delete last domain")
}
2022-12-13 09:20:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(webSiteDomain.WebsiteID))
2022-11-03 09:06:48 +00:00
if err != nil {
return err
}
var ports []int
2022-12-13 09:20:13 +00:00
if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID), websiteDomainRepo.WithPort(webSiteDomain.Port)); len(oldDomains) == 1 {
2022-11-03 09:06:48 +00:00
ports = append(ports, webSiteDomain.Port)
}
var domains []string
2022-12-13 09:20:13 +00:00
if oldDomains, _ := websiteDomainRepo.GetBy(websiteDomainRepo.WithWebsiteId(webSiteDomain.WebsiteID), websiteDomainRepo.WithDomain(webSiteDomain.Domain)); len(oldDomains) == 1 {
2022-11-03 09:06:48 +00:00
domains = append(domains, webSiteDomain.Domain)
}
if len(ports) > 0 || len(domains) > 0 {
if err := deleteListenAndServerName(website, ports, domains); err != nil {
return err
}
}
return websiteDomainRepo.DeleteBy(context.TODO(), commonRepo.WithByID(domainId))
}
2022-11-07 08:19:05 +00:00
2022-12-13 10:54:46 +00:00
func (w WebsiteService) GetNginxConfigByScope(req request.NginxScopeReq) (*response.WebsiteNginxConfig, error) {
2022-11-07 08:19:05 +00:00
keys, ok := dto.ScopeKeyMap[req.Scope]
if !ok || len(keys) == 0 {
return nil, nil
}
2022-12-13 09:20:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
2022-11-07 08:19:05 +00:00
if err != nil {
return nil, err
}
2022-12-13 09:20:13 +00:00
var config response.WebsiteNginxConfig
2022-11-30 16:41:50 +00:00
params, err := getNginxParamsByKeys(constant.NginxScopeServer, keys, &website)
if err != nil {
return nil, err
}
config.Params = params
config.Enable = len(params[0].Params) > 0
2022-11-07 08:19:05 +00:00
2022-11-30 16:41:50 +00:00
return &config, nil
2022-11-07 08:19:05 +00:00
}
2022-12-13 10:54:46 +00:00
func (w WebsiteService) UpdateNginxConfigByScope(req request.NginxConfigUpdate) error {
2022-11-07 08:19:05 +00:00
keys, ok := dto.ScopeKeyMap[req.Scope]
if !ok || len(keys) == 0 {
return nil
}
2022-12-13 09:20:13 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
2022-11-07 08:19:05 +00:00
if err != nil {
return err
}
2022-12-13 10:54:46 +00:00
if req.Operate == constant.ConfigDel {
var nginxParams []dto.NginxParam
for _, key := range keys {
nginxParams = append(nginxParams, dto.NginxParam{
Name: key,
})
}
return deleteNginxConfig(constant.NginxScopeServer, nginxParams, &website)
2022-11-08 07:42:31 +00:00
}
2022-11-30 16:41:50 +00:00
params := getNginxParams(req.Params, keys)
2022-12-13 10:54:46 +00:00
if req.Operate == constant.ConfigNew {
2022-11-30 16:41:50 +00:00
if _, ok := dto.StaticFileKeyMap[req.Scope]; ok {
params = getNginxParamsFromStaticFile(req.Scope, params)
}
}
return updateNginxConfig(constant.NginxScopeServer, params, &website)
2022-11-07 08:19:05 +00:00
}
2022-11-19 09:16:02 +00:00
2022-12-14 11:39:32 +00:00
func (w WebsiteService) GetWebsiteNginxConfig(websiteId uint) (response.FileInfo, error) {
2022-11-19 09:16:02 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteId))
if err != nil {
2022-12-14 11:39:32 +00:00
return response.FileInfo{}, err
2022-11-19 09:16:02 +00:00
}
nginxApp, err := appRepo.GetFirst(appRepo.WithKey(constant.AppOpenresty))
2022-11-19 09:16:02 +00:00
if err != nil {
2022-12-14 11:39:32 +00:00
return response.FileInfo{}, err
2022-11-19 09:16:02 +00:00
}
nginxInstall, err := appInstallRepo.GetFirst(appInstallRepo.WithAppId(nginxApp.ID))
if err != nil {
2022-12-14 11:39:32 +00:00
return response.FileInfo{}, err
2022-11-19 09:16:02 +00:00
}
configPath := path.Join(constant.AppInstallDir, constant.AppOpenresty, nginxInstall.Name, "conf", "conf.d", website.Alias+".conf")
2022-11-19 09:16:02 +00:00
info, err := files.NewFileInfo(files.FileOption{
Path: configPath,
Expand: true,
})
if err != nil {
2022-12-14 11:39:32 +00:00
return response.FileInfo{}, err
2022-11-19 09:16:02 +00:00
}
2022-12-14 11:39:32 +00:00
return response.FileInfo{FileInfo: *info}, nil
2022-11-19 09:16:02 +00:00
}
2022-11-20 10:32:56 +00:00
2022-12-13 09:20:13 +00:00
func (w WebsiteService) GetWebsiteHTTPS(websiteId uint) (response.WebsiteHTTPS, error) {
2022-11-20 10:32:56 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteId))
if err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-20 10:32:56 +00:00
}
2022-12-13 09:20:13 +00:00
var res response.WebsiteHTTPS
if website.WebsiteSSLID == 0 {
2022-11-20 10:32:56 +00:00
res.Enable = false
return res, nil
}
2022-12-13 09:20:13 +00:00
websiteSSL, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID))
2022-11-20 10:32:56 +00:00
if err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-20 10:32:56 +00:00
}
res.SSL = websiteSSL
res.Enable = true
2022-12-28 08:07:43 +00:00
if website.HttpConfig != "" {
res.HttpConfig = website.HttpConfig
} else {
res.HttpConfig = constant.HTTPToHTTPS
}
params, err := getNginxParamsByKeys(constant.NginxScopeServer, []string{"ssl_protocols", "ssl_ciphers"}, &website)
if err != nil {
return res, err
}
for _, p := range params {
if p.Name == "ssl_protocols" {
res.SSLProtocol = p.Params
}
if p.Name == "ssl_ciphers" {
res.Algorithm = p.Params[0]
}
}
2022-11-20 10:32:56 +00:00
return res, nil
}
2022-12-28 08:07:43 +00:00
func (w WebsiteService) OpWebsiteHTTPS(ctx context.Context, req request.WebsiteHTTPSOp) (response.WebsiteHTTPS, error) {
2022-11-20 10:32:56 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
if err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-20 10:32:56 +00:00
}
2022-11-24 09:50:47 +00:00
var (
2022-12-13 09:20:13 +00:00
res response.WebsiteHTTPS
websiteSSL model.WebsiteSSL
2022-11-24 09:50:47 +00:00
)
2022-11-20 10:32:56 +00:00
res.Enable = req.Enable
res.SSLProtocol = req.SSLProtocol
res.Algorithm = req.Algorithm
2022-12-28 09:21:15 +00:00
if !req.Enable {
2022-11-21 03:27:56 +00:00
website.Protocol = constant.ProtocolHTTP
2022-12-13 09:20:13 +00:00
website.WebsiteSSLID = 0
2022-11-28 07:11:39 +00:00
if err := deleteListenAndServerName(website, []int{443}, []string{}); err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-28 07:11:39 +00:00
}
nginxParams := getNginxParamsFromStaticFile(dto.SSL, nil)
nginxParams = append(nginxParams, dto.NginxParam{
Name: "if",
Params: []string{"($scheme", "=", "http)"},
})
if err := deleteNginxConfig(constant.NginxScopeServer, nginxParams, &website); err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-24 09:50:47 +00:00
}
2022-12-28 09:21:15 +00:00
if err := websiteRepo.Save(ctx, &website); err != nil {
return response.WebsiteHTTPS{}, err
}
return res, nil
}
if req.Type == constant.SSLExisted {
websiteSSL, err = websiteSSLRepo.GetFirst(commonRepo.WithByID(req.WebsiteSSLID))
if err != nil {
return response.WebsiteHTTPS{}, err
}
website.WebsiteSSLID = websiteSSL.ID
res.SSL = websiteSSL
}
if req.Type == constant.SSLManual {
certBlock, _ := pem.Decode([]byte(req.Certificate))
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return response.WebsiteHTTPS{}, err
}
websiteSSL.ExpireDate = cert.NotAfter
websiteSSL.StartDate = cert.NotBefore
websiteSSL.Type = cert.Issuer.CommonName
websiteSSL.Organization = cert.Issuer.Organization[0]
websiteSSL.PrimaryDomain = cert.Subject.CommonName
if len(cert.Subject.Names) > 0 {
var domains []string
for _, name := range cert.Subject.Names {
if v, ok := name.Value.(string); ok {
if v != cert.Subject.CommonName {
domains = append(domains, v)
}
}
}
if len(domains) > 0 {
websiteSSL.Domains = strings.Join(domains, "")
}
}
websiteSSL.Provider = constant.Manual
websiteSSL.PrivateKey = req.PrivateKey
websiteSSL.Pem = req.Certificate
res.SSL = websiteSSL
}
website.Protocol = constant.ProtocolHTTPS
if err := applySSL(website, websiteSSL, req); err != nil {
2022-12-28 09:21:15 +00:00
return response.WebsiteHTTPS{}, err
2022-11-20 10:32:56 +00:00
}
2022-12-28 09:21:15 +00:00
website.HttpConfig = req.HttpConfig
2022-11-20 10:32:56 +00:00
2022-11-24 09:50:47 +00:00
if websiteSSL.ID == 0 {
if err := websiteSSLRepo.Create(ctx, &websiteSSL); err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-24 09:50:47 +00:00
}
2022-12-13 09:20:13 +00:00
website.WebsiteSSLID = websiteSSL.ID
2022-11-24 09:50:47 +00:00
}
if err := websiteRepo.Save(ctx, &website); err != nil {
2022-12-13 09:20:13 +00:00
return response.WebsiteHTTPS{}, err
2022-11-24 09:50:47 +00:00
}
2022-11-20 10:32:56 +00:00
return res, nil
}
2022-12-13 09:20:13 +00:00
func (w WebsiteService) PreInstallCheck(req request.WebsiteInstallCheckReq) ([]response.WebsitePreInstallCheck, error) {
2022-12-04 09:45:54 +00:00
var (
2022-12-13 09:20:13 +00:00
res []response.WebsitePreInstallCheck
2022-12-04 09:45:54 +00:00
checkIds []uint
showErr = false
)
app, err := appRepo.GetFirst(appRepo.WithKey(constant.AppOpenresty))
2022-12-04 09:45:54 +00:00
if err != nil {
return nil, err
}
appInstall, _ := appInstallRepo.GetFirst(appInstallRepo.WithAppId(app.ID))
if reflect.DeepEqual(appInstall, model.AppInstall{}) {
2022-12-13 09:20:13 +00:00
res = append(res, response.WebsitePreInstallCheck{
2022-12-04 09:45:54 +00:00
Name: appInstall.Name,
AppName: app.Name,
2023-02-07 08:29:54 +00:00
Status: buserr.WithDetail(constant.ErrNotInstall, app.Name, nil).Error(),
2022-12-04 09:45:54 +00:00
Version: appInstall.Version,
})
showErr = true
} else {
checkIds = append(req.InstallIds, appInstall.ID)
}
for _, id := range checkIds {
if err := syncById(id); err != nil {
return nil, err
}
}
if len(checkIds) > 0 {
2023-02-07 08:29:54 +00:00
installList, _ := appInstallRepo.ListBy(commonRepo.WithIdsIn(checkIds))
2022-12-04 09:45:54 +00:00
for _, install := range installList {
2022-12-13 09:20:13 +00:00
res = append(res, response.WebsitePreInstallCheck{
2022-12-04 09:45:54 +00:00
Name: install.Name,
Status: install.Status,
Version: install.Version,
AppName: install.App.Name,
})
if install.Status != constant.StatusRunning {
showErr = true
}
}
}
if showErr {
return res, nil
} else {
return nil, nil
}
}
2022-12-06 03:42:11 +00:00
2022-12-13 09:20:13 +00:00
func (w WebsiteService) GetWafConfig(req request.WebsiteWafReq) (response.WebsiteWafConfig, error) {
var res response.WebsiteWafConfig
2022-12-06 03:42:11 +00:00
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
if err != nil {
return res, nil
}
2022-12-06 07:55:42 +00:00
res.Enable = true
if req.Key != "" {
params, err := getNginxParamsByKeys(constant.NginxScopeServer, []string{"set"}, &website)
if err != nil {
return res, nil
}
for _, param := range params {
if param.Params[0] == req.Key {
res.Enable = len(param.Params) > 1 && param.Params[1] == "on"
break
}
2022-12-06 03:42:11 +00:00
}
}
2022-12-06 07:55:42 +00:00
2022-12-06 03:42:11 +00:00
nginxFull, err := getNginxFull(&website)
if err != nil {
return res, nil
}
filePath := path.Join(nginxFull.SiteDir, "sites", website.Alias, "waf", "rules", req.Rule+".json")
2022-12-06 03:42:11 +00:00
content, err := os.ReadFile(filePath)
if err != nil {
return res, nil
}
res.FilePath = filePath
res.Content = string(content)
return res, nil
}
func (w WebsiteService) UpdateWafConfig(req request.WebsiteWafUpdate) error {
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
if err != nil {
return err
2022-12-06 03:42:11 +00:00
}
updateValue := "on"
if !req.Enable {
updateValue = "off"
}
return updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{
{Name: "set", Params: []string{req.Key, updateValue}},
}, &website)
}
func (w WebsiteService) UpdateNginxConfigFile(req request.WebsiteNginxUpdate) error {
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
if err != nil {
return err
}
nginxFull, err := getNginxFull(&website)
if err != nil {
return err
}
filePath := nginxFull.SiteConfig.FilePath
if err := files.NewFileOp().WriteFile(filePath, strings.NewReader(req.Content), 0755); err != nil {
return err
}
return nginxCheckAndReload(nginxFull.SiteConfig.OldContent, filePath, nginxFull.Install.ContainerName)
}
2022-12-30 09:39:17 +00:00
func (w WebsiteService) OpWebsiteLog(req request.WebsiteLogReq) (*response.WebsiteLog, error) {
website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.ID))
if err != nil {
return nil, err
}
nginx, err := getNginxFull(&website)
if err != nil {
return nil, err
}
sitePath := path.Join(nginx.SiteDir, "sites", website.Alias)
res := &response.WebsiteLog{
Content: "",
}
switch req.Operate {
case constant.GetLog:
switch req.LogType {
case constant.AccessLog:
res.Enable = website.AccessLog
if !website.AccessLog {
return res, nil
}
case constant.ErrorLog:
res.Enable = website.ErrorLog
if !website.ErrorLog {
return res, nil
}
}
content, err := os.ReadFile(path.Join(sitePath, "log", req.LogType))
if err != nil {
return nil, err
}
res.Content = string(content)
return res, nil
case constant.DisableLog:
key := "access_log"
switch req.LogType {
case constant.AccessLog:
website.AccessLog = false
case constant.ErrorLog:
key = "error_log"
website.ErrorLog = false
}
var nginxParams []dto.NginxParam
nginxParams = append(nginxParams, dto.NginxParam{
Name: key,
})
if err := deleteNginxConfig(constant.NginxScopeServer, nginxParams, &website); err != nil {
2022-12-30 09:39:17 +00:00
return nil, err
}
if err := websiteRepo.Save(context.Background(), &website); err != nil {
return nil, err
}
case constant.EnableLog:
key := "access_log"
logPath := path.Join("/www", "sites", website.Alias, "log", req.LogType)
switch req.LogType {
case constant.AccessLog:
website.AccessLog = true
case constant.ErrorLog:
key = "error_log"
website.ErrorLog = true
}
if err := updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: key, Params: []string{logPath}}}, &website); err != nil {
return nil, err
}
if err := websiteRepo.Save(context.Background(), &website); err != nil {
return nil, err
}
}
return res, nil
}
2023-01-03 08:56:36 +00:00
func (w WebsiteService) ChangeDefaultServer(id uint) error {
defaultWebsite, _ := websiteRepo.GetFirst(websiteRepo.WithDefaultServer())
if defaultWebsite.ID > 0 {
if err := updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "listen", Params: []string{"80"}}}, &defaultWebsite); err != nil {
return err
}
defaultWebsite.DefaultServer = false
if err := websiteRepo.Save(context.Background(), &defaultWebsite); err != nil {
return err
}
}
2023-01-03 09:54:26 +00:00
if id > 0 {
website, err := websiteRepo.GetFirst(commonRepo.WithByID(id))
if err != nil {
return err
}
if err := updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "listen", Params: []string{"80", "default_server"}}}, &website); err != nil {
return err
}
website.DefaultServer = true
return websiteRepo.Save(context.Background(), &website)
2023-01-03 08:56:36 +00:00
}
2023-01-03 09:54:26 +00:00
return nil
2023-01-03 08:56:36 +00:00
}