完成手动续期后台任务及权限隔离并更新回归进度

保留管理与业务续期调度,增加系统级幂等任务、取消传播和统计审计原子收尾;前端跟踪真实任务状态。原生 Linux 全后端、静态检查、相关专项二十次重复及前端二百七十二项测试和生产构建通过,未进行正式生产部署。
This commit is contained in:
xuans committed 2026-10-02 21:32:30 +08:00
1 parent 4ab3f93beb
commit 413a0e66a9
25 files changed
+739 -107

No files matched your search

+3 -17
View File
@@ -12,23 +12,9 @@ func (s *Server) runRenewalNow(c *gin.Context) {
s.writeError(c, http.StatusNotImplemented, "续期服务未配置", errors.New("续期工作流未配置"))
return
}
report, err := s.runRenewal(c.Request.Context())
if len(report.Errors) > 0 {
// 保留失败数量,不将证书路径、凭据或下游 SDK 响应带回浏览器。
messages := make([]string, len(report.Errors))
for index := range messages {
messages[index] = "证书续期失败,请检查对应任务及受保护的服务日志"
}
report.Errors = messages
}
response := gin.H{"report": report}
if err != nil {
if s.logger != nil {
s.logger.Error("执行证书续期失败", "error", err)
}
response["error"] = "执行证书续期失败"
c.JSON(http.StatusConflict, response)
if taskRepositoryUnavailable(s.tasks) || s.users == nil {
s.writeError(c, http.StatusServiceUnavailable, "续期任务或权限服务尚未就绪", nil)
return
}
c.JSON(http.StatusOK, response)
s.submitRenewalTask(c)
}
+161
View File
@@ -0,0 +1,161 @@
package httpapi
import (
"context"
"database/sql"
"errors"
"fmt"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
// 全局检查不是业务域名,也不是单次管理证书签发;子续期仍由原调度器负责。
func (s *Server) submitRenewalTask(c *gin.Context) {
operatorID := s.currentOperatorID(c)
if err := s.authorizeRenewalOperator(c.Request.Context(), operatorID); err != nil {
s.writeError(c, http.StatusForbidden, "只有当前有效的超级管理员可以执行全局续期检查", nil)
return
}
key := strings.TrimSpace(c.GetHeader("Idempotency-Key"))
if key != "" && !validTaskIdempotencyKey(key) {
s.writeError(c, http.StatusBadRequest, "幂等键格式无效", nil)
return
}
s.issueTaskMu.Lock()
defer s.issueTaskMu.Unlock()
if key != "" {
item, err := s.tasks.FindTaskByIdempotencyKey(c.Request.Context(), repository.RenewalCheckResourceID, key)
if err == nil {
if item.TaskType != "renewal_check" || item.ScopeType != repository.ScopeSystem {
s.writeError(c, http.StatusConflict, "幂等键已用于另一种操作", nil)
return
}
c.JSON(http.StatusOK, gin.H{"task": item, "replayed": true})
return
}
if !errors.Is(err, sql.ErrNoRows) {
s.writeError(c, http.StatusInternalServerError, "检查续期幂等任务失败", err)
return
}
}
if active, err := s.tasks.FindActiveTaskByDomain(c.Request.Context(), repository.RenewalCheckResourceID, "renewal_check"); err == nil {
c.JSON(http.StatusConflict, gin.H{"error": "全局续期检查已在执行,请查看现有任务", "task": active, "replayed": true})
return
} else if !errors.Is(err, sql.ErrNoRows) {
s.writeError(c, http.StatusInternalServerError, "检查活动续期任务失败", err)
return
}
now := time.Now().UTC()
task := repository.Task{
HistoryScope: repository.HistoryScope{ScopeType: repository.ScopeSystem},
ID: domain.NewID(), DomainID: repository.RenewalCheckResourceID, TaskType: "renewal_check",
Status: "queued", Stage: "queued", Message: "等待检查管理证书和业务域名续期",
OperatorID: operatorID, IdempotencyKey: key, CreatedAt: now, UpdatedAt: now,
}
if err := s.tasks.CreateTask(c.Request.Context(), task); err != nil {
s.writeError(c, http.StatusInternalServerError, "创建续期检查任务失败", err)
return
}
attempt := repository.TaskAttempt{
ID: domain.NewID(), TaskID: task.ID, AttemptNumber: 1, Stage: "renewal_check",
Status: "running", Message: task.Message, CreatedAt: now,
}
if err := s.tasks.CreateAttempt(c.Request.Context(), attempt); err != nil {
finishCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if finishErr := s.tasks.FinishTaskAttempt(finishCtx, repository.TaskCompletion{
TaskID: task.ID, Status: "failed", Stage: "record", Message: "创建续期尝试失败,未执行续期",
FinishedAt: time.Now().UTC(), WithoutAttempt: true, AuditAction: task.TaskType,
}); finishErr != nil && s.logger != nil {
s.logger.Error("续期任务收尾失败,保留启动恢复状态", "task_id", task.ID, "error", finishErr)
}
s.writeError(c, http.StatusInternalServerError, "创建续期尝试失败", err)
return
}
if s.enqueueTaskWorker(c, task, attempt, func(ctx context.Context) {
s.runRenewalTask(ctx, task, attempt)
}, nil) {
writeAcceptedCertificateTask(c, task)
}
}
func (s *Server) authorizeRenewalOperator(ctx context.Context, operatorID string) error {
if s.users == nil || operatorID == "" {
return repository.ErrProjectAccessDenied
}
user, err := s.users.GetUserByID(ctx, operatorID)
if err != nil {
return err
}
if user.Role != repository.UserRoleSuperAdmin || user.Status != repository.UserStatusActive {
return repository.ErrProjectAccessDenied
}
return nil
}
func (s *Server) runRenewalTask(ctx context.Context, task repository.Task, attempt repository.TaskAttempt) {
if s.finishCancelledTask(task, attempt, ctx) {
return
}
if err := s.authorizeRenewalOperator(ctx, task.OperatorID); err != nil {
attempt.Stage = "authorize"
s.finishTaskBeforeExecution(task, attempt, "failed", "续期执行前超级管理员权限校验未通过,未执行续期")
return
}
now := time.Now().UTC()
if err := s.tasks.UpdateTask(ctx, task.ID, "running", "renewal_check", "正在检查管理证书和业务域名续期", &now, nil); err != nil {
if !s.finishCancelledTask(task, attempt, ctx) {
s.finishTaskBeforeExecution(task, attempt, "failed", "续期检查启动失败,未执行续期")
}
return
}
if s.audit != nil {
if err := s.audit.CreateAuditLog(ctx, repository.AuditLog{
TaskID: task.ID, OperatorID: task.OperatorID, Action: task.TaskType,
ResourceType: "task", ResourceID: task.ID, Status: "running", Message: "开始全局续期检查",
}); err != nil {
s.finishTaskBeforeExecution(task, attempt, "failed", "记录续期开始审计失败,未执行续期")
return
}
}
if s.finishCancelledTask(task, attempt, ctx) {
return
}
// 不继承父任务事务编号,原续期工作流自行生成子任务及部署事务。
executionCtx := repository.WithTaskOperator(ctx, task.OperatorID)
executionCtx = repository.WithTaskCancellationHooks(executionCtx, repository.TaskCancellationHooks{
Register: s.registerTaskCancel, Unregister: s.unregisterTaskCancel,
})
report, runErr := s.runRenewal(executionCtx)
s.taskMu.Lock()
defer s.taskMu.Unlock()
status, prefix := "success", "续期检查完成"
if runErr != nil || report.Failed > 0 || len(report.Errors) > 0 {
status, prefix = "failed", "续期检查未全部完成"
if report.Succeeded > 0 {
status = "partial_success"
}
}
// 即使下游忽略取消并返回成功,也不得将取消或超时伪装为整体成功。
if errors.Is(ctx.Err(), context.DeadlineExceeded) || errors.Is(runErr, context.DeadlineExceeded) {
status, prefix = "failed", "续期检查超时,以下为已执行统计"
} else if errors.Is(ctx.Err(), context.Canceled) || errors.Is(runErr, context.Canceled) {
status, prefix = "cancelled", "续期检查已取消,以下为已执行统计"
}
message := fmt.Sprintf("%s:检查 %d 项,临期 %d 项,选中 %d 项,紧急 %d 项,成功 %d 项,失败 %d 项,异常 %d 项;逐项结果请查看续期任务",
prefix, report.Checked, report.NearExpiry, report.Selected, report.Urgent, report.Succeeded, report.Failed, len(report.Errors))
finishCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := s.tasks.FinishTaskAttempt(finishCtx, repository.TaskCompletion{
TaskID: task.ID, AttemptID: attempt.ID, Status: status, Stage: "renewal_check",
Message: message, StartedAt: &now, FinishedAt: time.Now().UTC(), AuditAction: task.TaskType,
}); err != nil && s.logger != nil {
s.logger.Error("保存续期检查终态失败,保留启动恢复状态", "task_id", task.ID, "error", err)
}
}
@@ -0,0 +1,207 @@
package httpapi
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
func TestAsyncRenewalLifecycle(t *testing.T) {
for _, scenario := range []string{"success", "partial", "failure", "nested_error", "panic", "cancel", "shutdown", "timeout", "replay", "duplicate", "revoked", "demoted", "full", "stopped"} {
t.Run(scenario, func(t *testing.T) {
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
var calls atomic.Int32
server.runRenewal = func(ctx context.Context) (certificate.RenewalReport, error) {
calls.Add(1)
if ctx.Err() != nil || repository.TaskOperatorFromContext(ctx) != "test-super-admin" {
t.Error("后台续期上下文错误或继承已断开的请求")
}
report := certificate.RenewalReport{Checked: 3, NearExpiry: 2, Selected: 2, Urgent: 1, Succeeded: 2}
switch scenario {
case "partial":
report.Succeeded, report.Failed = 1, 1
case "failure":
return certificate.RenewalReport{}, errors.New("private-renewal-secret")
case "nested_error":
return certificate.RenewalReport{Failed: 1, Errors: []string{"private-renewal-secret"}}, nil
case "panic":
panic("private-renewal-secret")
case "timeout":
return report, context.DeadlineExceeded
}
return report, nil
}
server.asyncTasks = make(map[string]bool)
server.taskSlots = make(chan struct{}, 1)
server.taskSlots <- struct{}{}
if scenario == "full" {
for index := range 32 {
server.asyncTasks[string(rune('a'+index))] = true
}
}
if scenario == "stopped" {
server.stopTaskWorkers()
}
request := httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil)
request.Header.Set("Idempotency-Key", "renewal-check-test")
ctx, cancel := context.WithCancel(request.Context())
response := httptest.NewRecorder()
serveSuperAdminHTTP(server, response, request.WithContext(ctx))
cancel()
if scenario == "full" || scenario == "stopped" {
if response.Code != http.StatusServiceUnavailable {
t.Fatalf("未拒绝不可执行任务:%d", response.Code)
}
items, err := tasks.ListTasks(t.Context(), repository.RenewalCheckResourceID, 10)
if err != nil || len(items) != 1 || items[0].Status != "failed" || calls.Load() != 0 {
t.Fatalf("拒绝后遗留任务:%+v %v", items, err)
}
return
}
task := submittedTask(t, response)
if calls.Load() != 0 || task.ScopeType != repository.ScopeSystem || task.ProjectID != "" {
t.Fatalf("受理阶段已执行或伪装项目:%+v", task)
}
if scenario == "replay" || scenario == "duplicate" {
repeat := httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil)
key := "renewal-check-test"
if scenario == "duplicate" {
key = "renewal-check-other"
}
repeat.Header.Set("Idempotency-Key", key)
response = httptest.NewRecorder()
serveSuperAdminHTTP(server, response, repeat)
if (response.Code != http.StatusOK && response.Code != http.StatusConflict) || !strings.Contains(response.Body.String(), task.ID) || !strings.Contains(response.Body.String(), `"replayed":true`) {
t.Fatalf("未找回原任务:%s", response.Body.String())
}
}
want, wantCalls := "success", int32(1)
switch scenario {
case "partial":
want = "partial_success"
case "failure", "nested_error", "panic", "timeout":
want = "failed"
case "cancel":
response = httptest.NewRecorder()
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodDelete, "/api/v1/tasks/"+task.ID, nil))
if response.Code != http.StatusAccepted {
t.Fatalf("无法取消全局任务:%d %s", response.Code, response.Body.String())
}
want, wantCalls = "cancelled", 0
case "shutdown":
server.stopTaskWorkers()
want, wantCalls = "cancelled", 0
case "revoked", "demoted":
user, err := server.users.GetUserByID(t.Context(), task.OperatorID)
if err != nil {
t.Fatal(err)
}
if scenario == "revoked" {
user.Status = repository.UserStatusDisabled
} else {
user.Role = repository.UserRoleAdmin
}
if err := server.users.UpdateUser(t.Context(), user); err != nil {
t.Fatal(err)
}
want, wantCalls = "failed", 0
}
<-server.taskSlots
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != want || calls.Load() != wantCalls || strings.Contains(stored.Message, "private-renewal-secret") {
t.Fatalf("续期终态错误:%+v %v calls=%d", stored, err, calls.Load())
}
attempts, err := tasks.ListAttempts(t.Context(), task.ID)
if err != nil || len(attempts) != 1 || attempts[0].Status != want || attempts[0].Message != stored.Message || attempts[0].ScopeType != repository.ScopeSystem {
t.Fatalf("尝试与任务不一致:%+v %v", attempts, err)
}
for _, role := range []string{repository.UserRoleAdmin, repository.UserRoleUser} {
response = httptest.NewRecorder()
request = httptest.NewRequest(http.MethodGet, "/api/v1/tasks/"+task.ID, nil)
request.AddCookie(httpUserSessionCookie(server, "renewal-viewer-"+role, role))
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusForbidden {
t.Fatalf("普通账户可读取全局统计:%s %d", role, response.Code)
}
}
})
}
}
func TestAsyncRenewalRunningCancellationPreservesCounts(t *testing.T) {
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
started := make(chan struct{})
server.runRenewal = func(ctx context.Context) (certificate.RenewalReport, error) {
close(started)
<-ctx.Done()
// 下游错误地忽略取消返回成功时,父任务仍不得宣称全部成功。
return certificate.RenewalReport{Checked: 3, Selected: 2, Succeeded: 1}, nil
}
response := httptest.NewRecorder()
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil))
task := submittedTask(t, response)
select {
case <-started:
case <-time.After(3 * time.Second):
t.Fatal("续期未开始")
}
response = httptest.NewRecorder()
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodDelete, "/api/v1/tasks/"+task.ID, nil))
if response.Code != http.StatusAccepted {
t.Fatalf("取消未接收:%d", response.Code)
}
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != "cancelled" || !strings.Contains(stored.Message, "成功 1 项") {
t.Fatalf("取消丢失已执行事实:%+v %v", stored, err)
}
}
type renewalTaskDomainLister struct{}
func (renewalTaskDomainLister) List(context.Context) ([]domain.Domain, error) {
return []domain.Domain{{ID: "domain-1", Name: "example.test", AutoRenew: true}}, nil
}
type renewalTaskIssuer struct{ calls atomic.Int32 }
func (i *renewalTaskIssuer) Issue(context.Context, string) (certificate.IssueResult, error) {
i.calls.Add(1)
return certificate.IssueResult{}, nil
}
type renewalTaskManagement struct{ calls atomic.Int32 }
func (m *renewalTaskManagement) RunRenewal(context.Context, certificate.RenewalPolicy, time.Time) (certificate.RenewalReport, error) {
m.calls.Add(1)
return certificate.RenewalReport{Checked: 1, Selected: 1, Succeeded: 1}, nil
}
func TestAsyncRenewalPreservesManagementAndDomainScheduler(t *testing.T) {
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
issuer := &renewalTaskIssuer{}
management := &renewalTaskManagement{}
scheduler := certificate.NewRenewalSchedulerWithManagement(renewalTaskDomainLister{}, issuer, certificate.RenewalPolicy{}, management)
server.runRenewal = scheduler.RunOnce
response := httptest.NewRecorder()
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil))
task := submittedTask(t, response)
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != "success" || issuer.calls.Load() != 1 || management.calls.Load() != 1 || !strings.Contains(stored.Message, "检查 2 项") || !strings.Contains(stored.Message, "成功 2 项") {
t.Fatalf("真实调度器未完整运行管理及业务续期:%+v %v business=%d management=%d", stored, err, issuer.calls.Load(), management.calls.Load())
}
}
+11 -9
View File
@@ -13,18 +13,20 @@ import (
)
func TestRenewalReportHidesNestedWorkflowErrors(t *testing.T) {
server := New(Dependencies{
Config: readyTestConfig(t.TempDir()),
RunRenewal: func(context.Context) (certificate.RenewalReport, error) {
return certificate.RenewalReport{Failed: 1, Errors: []string{"internal-secret-sentinel"}}, nil
},
})
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
server.runRenewal = func(context.Context) (certificate.RenewalReport, error) {
return certificate.RenewalReport{Failed: 1, Errors: []string{"internal-secret-sentinel"}}, nil
}
response := httptest.NewRecorder()
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil))
if response.Code != http.StatusOK || strings.Contains(response.Body.String(), "internal-secret-sentinel") {
t.Fatalf("续期报告不得返回底层敏感错误:%d", response.Code)
task := submittedTask(t, response)
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != "failed" || strings.Contains(stored.Message, "internal-secret-sentinel") {
t.Fatalf("续期报告不得返回底层敏感错误:%+v %v", stored, err)
}
if !strings.Contains(response.Body.String(), `"failed":1`) {
if !strings.Contains(stored.Message, "失败 1 项") {
t.Fatal("脱敏不能丢失续期失败计数")
}
}
+1 -1
View File
@@ -243,7 +243,7 @@ func (s *Server) registerRoutes() {
adminAPI.GET("/dns/accounts", s.listDNSAccounts)
adminAPI.POST("/dns/test", s.requireSuperAdminSystemConfig, s.dnsOperation, s.testAdminDNS)
adminAPI.POST("/dns/aliyun/check", s.requireSuperAdminSystemConfig, s.dnsOperation, s.checkAliyunDNSDomain)
adminAPI.POST("/renewal/run", s.requireSuperAdmin, s.longOperation(certificateTaskTimeout), s.runRenewalNow)
adminAPI.POST("/renewal/run", s.requireSuperAdmin, s.runRenewalNow)
domainAPI.POST("/domains/:id/certificate/import", s.longOperation(certificateTaskTimeout), s.importCertificateFiles)
domainAPI.POST("/domains/:id/certificate/validate", s.longOperation(certificateTaskTimeout), s.validateCertificate)
domainAPI.POST("/domains/:id/deploy", s.deployCertificateCurrent)
+22 -45
View File
@@ -362,57 +362,34 @@ func TestSettingsAPIReturnsChineseNotificationCredentialError(t *testing.T) {
}
func TestRenewalAPIUsesConfiguredRunner(t *testing.T) {
cfg := config.Default(t.TempDir())
cfg.SetupReady = true
cfg.DNS.VerificationState = "verified"
cfg.Web.Hostname = "scert.example.test"
cfg.Admin.Username = "admin"
cfg.Admin.Email = "admin@example.test"
cfg.Admin.PasswordHash = mustTestPasswordHash(t, "Password123")
called := false
server := New(Dependencies{
Config: cfg,
RunRenewal: func(context.Context) (certificate.RenewalReport, error) {
called = true
return certificate.RenewalReport{Checked: 2, Selected: 1, Succeeded: 1}, nil
},
})
cookie := loginForSettingsTest(t, server)
request := httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil)
request.AddCookie(cookie)
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
server.runRenewal = func(context.Context) (certificate.RenewalReport, error) {
return certificate.RenewalReport{Checked: 2, Selected: 1, Succeeded: 1}, nil
}
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK || !called || !strings.Contains(response.Body.String(), `"selected":1`) {
t.Fatalf("续期接口调用结果不正确:%d %s;called=%v", response.Code, response.Body.String(), called)
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil))
task := submittedTask(t, response)
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != "success" || !strings.Contains(stored.Message, "检查 2 项") || !strings.Contains(stored.Message, "成功 1 项") {
t.Fatalf("续期任务结果不正确:%+v %v", stored, err)
}
}
func TestRenewalAPIHidesWorkflowErrors(t *testing.T) {
cfg := config.Default(t.TempDir())
cfg.SetupReady = true
cfg.Admin.Username = "admin"
cfg.Admin.Email = "admin@example.test"
cfg.Admin.PasswordHash = mustTestPasswordHash(t, "Password123")
server := New(Dependencies{
Config: cfg,
RunRenewal: func(context.Context) (certificate.RenewalReport, error) {
return certificate.RenewalReport{}, errors.New("private-key-secret-path")
},
})
cookie := loginForSettingsTest(t, server)
request := httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil)
request.AddCookie(cookie)
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
server.runRenewal = func(context.Context) (certificate.RenewalReport, error) {
return certificate.RenewalReport{}, errors.New("private-key-secret-path")
}
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusConflict {
t.Fatalf("renewal failure returned an unexpected status: %d %s", response.Code, response.Body.String())
}
body := response.Body.String()
if strings.Contains(body, "private-key-secret-path") {
t.Fatalf("renewal API leaked an internal error: %s", body)
}
if !strings.Contains(body, "\u6267\u884c\u8bc1\u4e66\u7eed\u671f\u5931\u8d25") {
t.Fatalf("renewal API did not include the safe error message: %s", body)
serveSuperAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/renewal/run", nil))
task := submittedTask(t, response)
waitTaskWorkersForTest(t, server)
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != "failed" || strings.Contains(stored.Message, "private-key-secret-path") || !strings.Contains(stored.Message, "未全部完成") {
t.Fatalf("续期失败任务未安全保留结果:%+v %v", stored, err)
}
}
func TestRenewalAPIRequiresSuperAdmin(t *testing.T) {
+6 -1
View File
@@ -444,7 +444,12 @@ func (s *Server) cancelTask(c *gin.Context) {
c.JSON(http.StatusConflict, gin.H{"error": "管理证书任务由续期调度控制,不能单独修改取消状态", "task": item})
return
}
if !s.authorizeProjectPermissions(c, item.ProjectID, domain.PermissionTaskCancel) {
if item.TaskType == "renewal_check" {
if err := s.authorizeRenewalOperator(c.Request.Context(), s.currentOperatorID(c)); err != nil {
s.writeError(c, http.StatusForbidden, "只有当前有效的超级管理员可以取消全局续期检查", nil)
return
}
} else if !s.authorizeProjectPermissions(c, item.ProjectID, domain.PermissionTaskCancel) {
return
}
s.taskMu.Lock()
@@ -54,6 +54,9 @@ func (s *Server) enqueueTaskWorker(c *gin.Context, task repository.Task, attempt
if task.TaskType == "certificate_validate" {
message = "证书校验异常中断,未保存通过结果"
}
if task.TaskType == "renewal_check" {
message = "续期检查异常中断,请检查已生成的续期任务,不会自动重放"
}
s.finishTaskBeforeExecution(task, attempt, "failed", message)
}
}()
+5 -4
View File
@@ -7,10 +7,11 @@ import (
)
const (
ScopeProject = "project"
ScopeSystem = "system"
ScopeUnknown = "unknown"
ManagementResourceID = "management-certificate"
ScopeProject = "project"
ScopeSystem = "system"
ScopeUnknown = "unknown"
ManagementResourceID = "management-certificate"
RenewalCheckResourceID = "global-renewal-check"
)
// HistoryScope 保存事件发生时的范围,资源或项目删除后仍保留;不是项目授权凭证。
@@ -26,6 +26,9 @@ func (r *SQLProjectMemberRepository) ListVisibleAuditLogs(ctx context.Context, a
logs.scope_type, logs.project_id, logs.task_id, logs.operator_id
FROM audit_logs logs WHERE EXISTS (
SELECT 1 FROM users actor WHERE actor.id = ? AND actor.status = 'active'
AND (actor.role = 'super_admin' OR NOT EXISTS (
SELECT 1 FROM tasks restricted_task WHERE restricted_task.id = logs.task_id
AND restricted_task.task_type = 'renewal_check'))
AND (actor.role IN ('super_admin', 'admin') OR (actor.role = 'user'
AND logs.scope_type = 'project' AND EXISTS (
SELECT 1 FROM project_members member
@@ -48,6 +48,7 @@ func taskVisibilityPredicate(alias string, permission domain.ProjectPermission)
return `EXISTS (
SELECT 1 FROM users task_actor
WHERE task_actor.id = ? AND task_actor.status = 'active'
AND (` + alias + `.task_type <> 'renewal_check' OR task_actor.role = 'super_admin')
AND (task_actor.role IN ('super_admin', 'admin') OR (
task_actor.role = 'user' AND ` + alias + `.scope_type = 'project'
AND EXISTS (SELECT 1 FROM project_members task_member
@@ -0,0 +1,93 @@
package repository
import (
"database/sql"
"errors"
"testing"
"time"
)
func TestRenewalCheckScopeVisibilityAndCompletion(t *testing.T) {
repo, db := newTaskRepositoryTest(t)
defer db.Close()
ctx := t.Context()
for _, role := range []string{UserRoleSuperAdmin, UserRoleAdmin, UserRoleUser} {
if _, err := db.ExecContext(ctx, `INSERT INTO users (id, username, password_hash, role, status) VALUES (?, ?, 'test-hash', ?, 'active')`, role, role, role); err != nil {
t.Fatal(err)
}
}
task := Task{ID: "global-check", DomainID: RenewalCheckResourceID, TaskType: "renewal_check", Status: "queued", Stage: "queued", OperatorID: UserRoleSuperAdmin}
for _, forged := range []Task{
{ID: "forged-domain", DomainID: "domain-1", TaskType: "renewal_check", Status: "queued", Stage: "queued"},
{ID: "forged-management", DomainID: ManagementResourceID, TaskType: "renewal_check", Status: "queued", Stage: "queued"},
{ID: "forged-type", DomainID: RenewalCheckResourceID, TaskType: "certificate_issue", Status: "queued", Stage: "queued"},
{ID: "forged-project", DomainID: RenewalCheckResourceID, TaskType: "renewal_check", Status: "queued", Stage: "queued", HistoryScope: HistoryScope{ScopeType: ScopeProject, ProjectID: "default"}},
} {
if err := repo.CreateTask(ctx, forged); err == nil {
t.Fatalf("接受了伪造范围:%+v", forged)
}
}
if err := repo.CreateTask(ctx, task); err != nil {
t.Fatal(err)
}
duplicate := task
duplicate.ID = "duplicate-check"
if err := repo.CreateTask(ctx, duplicate); !errors.Is(err, ErrTaskAlreadyRunning) {
t.Fatalf("未拒绝重复检查:%v", err)
}
if err := repo.CreateAttempt(ctx, TaskAttempt{ID: "check-attempt", TaskID: task.ID, AttemptNumber: 1, Status: "running", Stage: "renewal_check"}); err != nil {
t.Fatal(err)
}
for _, role := range []string{UserRoleAdmin, UserRoleUser} {
if _, err := repo.GetVisibleTask(ctx, role, task.ID); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("全局任务越权可见:%s %v", role, err)
}
if err := repo.RequestCancelVisibleTask(ctx, role, task.ID); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("全局任务越权取消:%s %v", role, err)
}
}
if stored, err := repo.GetVisibleTask(ctx, UserRoleSuperAdmin, task.ID); err != nil || stored.ScopeType != ScopeSystem || stored.ProjectID != "" {
t.Fatalf("系统范围丢失:%+v %v", stored, err)
}
completion := TaskCompletion{TaskID: task.ID, AttemptID: "check-attempt", Status: "success", Stage: "renewal_check", Message: "续期检查完成:检查 2 项,成功 1 项", FinishedAt: time.Now().UTC(), AuditAction: "renewal_check"}
if _, err := db.ExecContext(ctx, `CREATE TRIGGER reject_renewal_audit BEFORE INSERT ON audit_logs BEGIN SELECT RAISE(ABORT, 'injected failure'); END`); err != nil {
t.Fatal(err)
}
if err := repo.FinishTaskAttempt(ctx, completion); err == nil {
t.Fatal("审计失败未回滚")
}
stored, err := repo.GetTask(ctx, task.ID)
if err != nil || stored.Status != "queued" {
t.Fatalf("审计失败仍保存任务成功:%+v %v", stored, err)
}
attempts, err := repo.ListAttempts(ctx, task.ID)
if err != nil || len(attempts) != 1 || attempts[0].Status != "running" {
t.Fatalf("审计失败仍保存尝试成功:%+v %v", attempts, err)
}
if _, err := db.ExecContext(ctx, `DROP TRIGGER reject_renewal_audit`); err != nil {
t.Fatal(err)
}
if err := repo.FinishTaskAttempt(ctx, completion); err != nil {
t.Fatal(err)
}
var scope, resourceType, resourceID, message string
if err := db.QueryRowContext(ctx, `SELECT scope_type, resource_type, resource_id, message FROM audit_logs WHERE task_id = ?`, task.ID).Scan(&scope, &resourceType, &resourceID, &message); err != nil {
t.Fatal(err)
}
if scope != ScopeSystem || resourceType != "task" || resourceID != task.ID || message != completion.Message {
t.Fatalf("全局检查被伪装为管理证书或未记录摘要:%s %s %s %s", scope, resourceType, resourceID, message)
}
for _, role := range []string{UserRoleSuperAdmin, UserRoleAdmin, UserRoleUser} {
logs, err := NewSQLProjectMemberRepository(db).ListVisibleAuditLogs(ctx, role, 10)
want := 0
if role == UserRoleSuperAdmin {
want = 1
}
if err != nil || len(logs) != want {
t.Fatalf("全局续期审计可见性错误:%s %+v %v", role, logs, err)
}
}
if _, _, err := repo.RetryVisibleTask(ctx, UserRoleSuperAdmin, task.ID, nil); !errors.Is(err, ErrTaskNotRetryable) {
t.Fatalf("全局检查不应通用重试:%v", err)
}
}
@@ -14,8 +14,8 @@ func (r *SQLTaskRepository) recordCompletionAudit(ctx context.Context, tx *sql.T
}
result, err := tx.ExecContext(ctx, r.query(`INSERT INTO audit_logs
(action, resource_type, resource_id, status, message, created_at, scope_type, project_id, task_id, operator_id)
SELECT ?, CASE WHEN scope_type = 'system' THEN 'management_certificate' ELSE 'domain' END,
domain_id, ?, ?, ?, scope_type, project_id, id, operator_id
SELECT ?, CASE WHEN task_type = 'renewal_check' THEN 'task' WHEN scope_type = 'system' THEN 'management_certificate' ELSE 'domain' END,
CASE WHEN task_type = 'renewal_check' THEN id ELSE domain_id END, ?, ?, ?, scope_type, project_id, id, operator_id
FROM tasks WHERE id = ?`), completion.AuditAction, status, completion.Message,
completion.FinishedAt.UTC(), completion.TaskID)
if err != nil {
@@ -110,8 +110,12 @@ func (r *SQLTaskRepository) CreateTask(ctx context.Context, item Task) error {
}
insertQuery := `INSERT INTO tasks
(id, domain_id, task_type, status, stage, message, operator_id, certificate_version_id, idempotency_key, started_at, finished_at, created_at, updated_at, scope_type, project_id) `
if item.TaskType == "management_renewal" {
if item.DomainID != ManagementResourceID || !item.HistoryScope.matches(HistoryScope{ScopeType: ScopeSystem}) {
if item.TaskType == "management_renewal" || item.TaskType == "renewal_check" {
resourceID := ManagementResourceID
if item.TaskType == "renewal_check" {
resourceID = RenewalCheckResourceID
}
if item.DomainID != resourceID || !item.HistoryScope.matches(HistoryScope{ScopeType: ScopeSystem}) {
return errors.New("管理证书任务范围无效")
}
tx, err := r.db.BeginTx(ctx, nil)
@@ -139,7 +143,7 @@ func (r *SQLTaskRepository) CreateTask(ctx context.Context, item Task) error {
}
return nil
}
if item.DomainID == ManagementResourceID || (item.ScopeType != "" && item.ScopeType != ScopeProject) {
if item.DomainID == ManagementResourceID || item.DomainID == RenewalCheckResourceID || (item.ScopeType != "" && item.ScopeType != ScopeProject) {
return errors.New("业务任务必须归属于实际域名项目")
}
@@ -441,6 +445,7 @@ func (r *SQLTaskRepository) CreateAttempt(ctx context.Context, item TaskAttempt)
SELECT ?, id, ?, ?, ?, ?, ?, ?, ? FROM tasks t WHERE id = ?
AND (? = '' OR scope_type = ?) AND (? = '' OR project_id = ?)
AND ((t.scope_type = 'system' AND t.task_type = 'management_renewal' AND t.domain_id = 'management-certificate')
OR (t.scope_type = 'system' AND t.task_type = 'renewal_check' AND t.domain_id = 'global-renewal-check')
OR (t.scope_type = 'project' AND EXISTS (SELECT 1 FROM domains d JOIN projects p ON p.id = d.project_id
WHERE d.id = t.domain_id AND d.project_id = t.project_id)))`), item.ID, item.AttemptNumber, item.Stage, item.Status, item.Message,
nullableTime(item.StartedAt), nullableTime(item.FinishedAt), item.CreatedAt.UTC(), item.TaskID,