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 }