完成手动续期后台任务及权限隔离并更新回归进度
保留管理与业务续期调度,增加系统级幂等任务、取消传播和统计审计原子收尾;前端跟踪真实任务状态。原生 Linux 全后端、静态检查、相关专项二十次重复及前端二百七十二项测试和生产构建通过,未进行正式生产部署。
This commit is contained in:
1 parent
4ab3f93beb
commit
413a0e66a9
25 files changed
+739
-107
No files matched your search
@@ -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)
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
}
|
||||
@@ -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("脱敏不能丢失续期失败计数")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}()
|
||||
|
||||
@@ -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,
|
||||
|
||||
Reference in new issue
Block a user