mirror of
https://github.com/1Panel-dev/1Panel.git
synced 2026-11-20 00:01:06 +00:00
206 lines
5.5 KiB
Go
206 lines
5.5 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
|
|
"github.com/1Panel-dev/1Panel/agent/app/dto/request"
|
|
"github.com/1Panel-dev/1Panel/agent/app/model"
|
|
"github.com/1Panel-dev/1Panel/agent/app/repo"
|
|
"github.com/1Panel-dev/1Panel/agent/app/task"
|
|
"github.com/1Panel-dev/1Panel/agent/constant"
|
|
"github.com/1Panel-dev/1Panel/agent/i18n"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func (w WebsiteService) BatchOpWebsite(req request.BatchWebsiteOp) error {
|
|
if req.Operate == "clearProxyCache" {
|
|
opTask, err := task.NewTaskWithOps(i18n.GetMsgByKey("ProxyCacheClear"), task.TaskBatch, task.TaskScopeWebsite, req.TaskID, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opTask.AddSubTask("", func(t *task.Task) error {
|
|
return batchClearProxyCache(t, req.IDs)
|
|
}, nil)
|
|
go func() { _ = opTask.Execute() }()
|
|
return nil
|
|
}
|
|
websites, err := websiteRepo.List(repo.WithByIDs(req.IDs))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opTask, err := task.NewTaskWithOps(i18n.GetMsgByKey("Status"), task.TaskBatch, task.TaskScopeWebsite, req.TaskID, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sort.SliceStable(websites, func(i, j int) bool {
|
|
if websites[i].Type == constant.Subsite && websites[j].Type != constant.Subsite {
|
|
return true
|
|
}
|
|
if websites[i].Type != constant.Subsite && websites[j].Type == constant.Subsite {
|
|
return false
|
|
}
|
|
return false
|
|
})
|
|
opWebsiteTask := func(t *task.Task) error {
|
|
for _, web := range websites {
|
|
msg := fmt.Sprintf("%s %s", i18n.GetMsgByKey(req.Operate), web.PrimaryDomain)
|
|
switch req.Operate {
|
|
case constant.StopWeb, constant.StartWeb:
|
|
if err := opWebsite(&web, req.Operate); err != nil {
|
|
t.LogFailedWithErr(msg, err)
|
|
continue
|
|
}
|
|
_ = websiteRepo.Save(context.Background(), &web)
|
|
case "delete":
|
|
if err := w.DeleteWebsite(request.WebsiteDelete{
|
|
ID: web.ID,
|
|
}); err != nil {
|
|
t.LogFailedWithErr(msg, err)
|
|
continue
|
|
}
|
|
}
|
|
|
|
t.LogSuccess(msg)
|
|
}
|
|
return nil
|
|
}
|
|
opTask.AddSubTask("", opWebsiteTask, nil)
|
|
|
|
go func() {
|
|
_ = opTask.Execute()
|
|
}()
|
|
return nil
|
|
}
|
|
|
|
func batchClearProxyCache(t *task.Task, ids []uint) error {
|
|
websites, err := websiteRepo.GetBy(repo.WithByIDs(ids))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// A nil entry is a requested website that no longer exists.
|
|
pending := make(map[uint]*model.Website, len(ids))
|
|
for _, id := range ids {
|
|
pending[id] = nil
|
|
}
|
|
for i := range websites {
|
|
pending[websites[i].ID] = &websites[i]
|
|
}
|
|
|
|
sitesDir := GetSiteDir("")
|
|
var cleared, skipped, failed int
|
|
var needsReload bool
|
|
for _, id := range ids {
|
|
web, ok := pending[id]
|
|
if !ok {
|
|
continue
|
|
}
|
|
delete(pending, id)
|
|
if web == nil {
|
|
t.LogFailedWithErr(fmt.Sprintf("ID %d", id), gorm.ErrRecordNotFound)
|
|
failed++
|
|
continue
|
|
}
|
|
changed, err := cleanWebsiteProxyCache(sitesDir, web.Alias)
|
|
needsReload = needsReload || changed
|
|
switch {
|
|
case err != nil:
|
|
t.LogFailedWithErr(web.PrimaryDomain, err)
|
|
failed++
|
|
case changed:
|
|
t.LogSuccess(web.PrimaryDomain)
|
|
cleared++
|
|
default:
|
|
t.Log(web.PrimaryDomain + " · " + i18n.GetMsgByKey("ProxyCacheEmpty"))
|
|
skipped++
|
|
}
|
|
}
|
|
summary := i18n.GetMsgWithMap("ProxyCacheSummary", map[string]interface{}{"cleared": cleared, "skipped": skipped, "failed": failed})
|
|
t.Log(summary)
|
|
if needsReload {
|
|
if err := reloadProxyCacheNginx(); err != nil {
|
|
return fmt.Errorf("%s: %w", i18n.GetMsgByKey("ProxyCacheReloadFailed"), err)
|
|
}
|
|
}
|
|
if failed > 0 {
|
|
return errors.New(summary)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (w WebsiteService) BatchSetGroup(req request.BatchWebsiteGroup) error {
|
|
websites, err := websiteRepo.List(repo.WithByIDs(req.IDs))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, web := range websites {
|
|
web.WebsiteGroupID = req.GroupID
|
|
if err := websiteRepo.Save(context.Background(), &web); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (w WebsiteService) BatchSetHttps(ctx context.Context, req request.BatchWebsiteHttps) error {
|
|
websites, err := websiteRepo.List(repo.WithByIDs(req.IDs))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
opTask, err := task.NewTaskWithOps(i18n.GetMsgByKey("SSL"), task.TaskBatch, task.TaskScopeWebsite, req.TaskID, 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
websiteHttpsOp := request.WebsiteHTTPSOp{
|
|
Enable: true,
|
|
WebsiteSSLID: req.WebsiteSSLID,
|
|
Type: req.Type,
|
|
PrivateKey: req.PrivateKey,
|
|
Certificate: req.Certificate,
|
|
PrivateKeyPath: req.PrivateKeyPath,
|
|
CertificatePath: req.CertificatePath,
|
|
ImportType: req.ImportType,
|
|
HttpConfig: req.HttpConfig,
|
|
SSLProtocol: req.SSLProtocol,
|
|
Algorithm: req.Algorithm,
|
|
Hsts: req.Hsts,
|
|
HstsIncludeSubDomains: req.HstsIncludeSubDomains,
|
|
HttpsPorts: req.HttpsPorts,
|
|
Http3: req.Http3,
|
|
}
|
|
if req.Type == constant.SSLManual {
|
|
websiteSSL, err := getManualWebsiteSSL(websiteHttpsOp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = websiteSSLRepo.Create(ctx, &websiteSSL); err != nil {
|
|
return err
|
|
}
|
|
websiteHttpsOp.Type = constant.SSLExisted
|
|
websiteHttpsOp.WebsiteSSLID = websiteSSL.ID
|
|
}
|
|
opWebsiteTask := func(t *task.Task) error {
|
|
for _, web := range websites {
|
|
if web.Type == constant.Stream {
|
|
continue
|
|
}
|
|
websiteHttpsOp.WebsiteID = web.ID
|
|
msg := fmt.Sprintf("%s [%s] %s", i18n.GetMsgByKey("Set"), web.PrimaryDomain, i18n.GetMsgByKey("SSL"))
|
|
if _, err := w.OpWebsiteHTTPS(ctx, websiteHttpsOp); err != nil {
|
|
t.LogFailedWithErr(msg, err)
|
|
continue
|
|
}
|
|
t.LogSuccess(msg)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
opTask.AddSubTask("", opWebsiteTask, nil)
|
|
go func() {
|
|
_ = opTask.Execute()
|
|
}()
|
|
return nil
|
|
}
|