保存证书校验后台任务及独立结果的修复前基线

校验结果事务持久化、三库迁移及前端详情接线已实现,完整回归仍在执行。审查发现前端校验幂等键包含路径分隔符,下一批补回归并修复;本提交不是正式发布或生产验收结论。
This commit is contained in:
xuans committed 2026-10-02 20:25:28 +08:00
1 parent fce5a84dd4
commit 24a9683c43
27 files changed
+803 -23

No files matched your search

@@ -94,6 +94,10 @@ func (s *Server) listCertificateVersions(c *gin.Context) {
}
func (s *Server) validateCertificate(c *gin.Context) {
if s.validateCertificateTask != nil {
s.submitDomainTask(c, "certificate_validate")
return
}
if !s.authorizeVisibleDomainPermission(c, domain.PermissionPrivateKeyRead) {
return
}
@@ -0,0 +1,146 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"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 TestAsyncValidationLifecycle(t *testing.T) {
for _, scenario := range []string{"success", "failure", "panic", "cancel", "shutdown", "replay", "stopped", "full"} {
t.Run(scenario, func(t *testing.T) {
server, tasks, _, cleanup := newTaskAPITestServer(t, nil)
defer cleanup()
var calls atomic.Int32
server.validateCertificateTask = func(ctx context.Context, id string) (certificate.IssueResult, certificate.ValidationResult, error) {
calls.Add(1)
if ctx.Err() != nil || id != "domain-1" {
t.Error("后台校验沿用已断开的请求或错误域名")
}
if scenario == "panic" {
panic("private-validation-detail")
}
if scenario == "failure" {
return certificate.IssueResult{}, certificate.ValidationResult{}, errors.New("private-validation-detail")
}
return certificate.IssueResult{Saved: certificate.SavedResource{PrivateKeyPath: "/private-path/key.pem"}},
certificate.ValidationResult{Domains: []string{"example.com"}, FingerprintSHA256: "validated-fingerprint", ChainLength: 2}, nil
}
server.asyncTasks = make(map[string]bool)
server.taskSlots = make(chan struct{}, 1)
server.taskSlots <- struct{}{}
if scenario == "stopped" {
server.stopTaskWorkers()
}
if scenario == "full" {
for index := range 32 {
server.asyncTasks[string(rune('a'+index))] = true
}
}
response := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodPost, "/api/v1/domains/domain-1/certificate/validate", nil)
request.Header.Set("Idempotency-Key", "validation-request")
ctx, cancel := context.WithCancel(request.Context())
serveAdminHTTP(server, response, request.WithContext(ctx))
cancel()
if scenario == "stopped" || scenario == "full" {
if response.Code != http.StatusServiceUnavailable || calls.Load() != 0 {
t.Fatalf("服务拒绝后仍执行校验:%d %d", response.Code, calls.Load())
}
return
}
task := submittedTask(t, response)
if task.TaskType != "certificate_validate" || calls.Load() != 0 {
t.Fatalf("校验没有正确排队:%+v %d", task, calls.Load())
}
if scenario == "replay" {
replayed := httptest.NewRecorder()
serveAdminHTTP(server, replayed, request)
if replayed.Code != http.StatusConflict || !strings.Contains(replayed.Body.String(), task.ID) || !strings.Contains(replayed.Body.String(), `"replayed":true`) {
t.Fatalf("校验重复请求没有复用原任务:%d %s", replayed.Code, replayed.Body.String())
}
}
switch scenario {
case "cancel":
cancelled := httptest.NewRecorder()
serveAdminHTTP(server, cancelled, httptest.NewRequest(http.MethodDelete, "/api/v1/tasks/"+task.ID, nil))
if cancelled.Code != http.StatusAccepted {
t.Fatalf("取消排队校验失败:%d", cancelled.Code)
}
case "shutdown":
server.stopTaskWorkers()
default:
<-server.taskSlots
}
waitTaskWorkersForTest(t, server)
want, wantCalls := "success", int32(1)
if scenario == "failure" || scenario == "panic" {
want = "failed"
}
if scenario == "cancel" || scenario == "shutdown" {
want, wantCalls = "cancelled", 0
}
stored, err := tasks.GetTask(t.Context(), task.ID)
if err != nil || stored.Status != want || calls.Load() != wantCalls || strings.Contains(stored.Message, "private-") {
t.Fatalf("校验终态或调用次数错误:%+v %v %d", stored, err, calls.Load())
}
result := httptest.NewRecorder()
serveAdminHTTP(server, result, httptest.NewRequest(http.MethodGet, "/api/v1/tasks/"+task.ID+"/validation-results", nil))
var body struct {
Items []repository.TaskValidationResult `json:"items"`
}
if result.Code != http.StatusOK || json.Unmarshal(result.Body.Bytes(), &body) != nil || strings.Contains(result.Body.String(), "private-") {
t.Fatalf("读取校验结果失败或泄露内部内容:%d %s", result.Code, result.Body.String())
}
if want == "success" {
if len(body.Items) != 1 || body.Items[0].Validation.FingerprintSHA256 != "validated-fingerprint" {
t.Fatalf("后台校验详情丢失:%+v", body)
}
} else if len(body.Items) != 0 {
t.Fatal("未通过校验却保存通过结果")
}
reports, err := tasks.ListTaskDeploymentReports(t.Context(), task.ID)
if err != nil || len(reports) != 0 {
t.Fatalf("校验生成伪部署报告:%+v %v", reports, err)
}
})
}
}
func TestAsyncValidationRequiresOnlyExistingPrivateKeyPermission(t *testing.T) {
for _, allowed := range []bool{true, false} {
server, _, _, cleanup := newTaskAPITestServer(t, nil)
server.validateCertificateTask = func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error) {
return certificate.IssueResult{}, certificate.ValidationResult{Domains: []string{"example.com"}}, nil
}
server.projectMembers = permissionProjectMemberRepository{
ProjectMemberRepository: server.projectMembers,
allow: func(permission domain.ProjectPermission) error {
if allowed && permission == domain.PermissionPrivateKeyRead {
return nil
}
return repository.ErrProjectAccessDenied
},
}
response := httptest.NewRecorder()
serveAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, "/api/v1/domains/domain-1/certificate/validate", nil))
want := http.StatusForbidden
if allowed {
want = http.StatusAccepted
}
if response.Code != want {
t.Fatalf("校验改变了原有权限要求:%d %s", response.Code, response.Body.String())
}
waitTaskWorkersForTest(t, server)
cleanup()
}
}
+5
View File
@@ -67,6 +67,8 @@ type Dependencies struct {
DeployCertificateTask func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
RestoreCertificateVersion func(context.Context, string, string) (certificate.IssueResult, error)
ValidateCertificate func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error)
// ValidateCertificateTask 直接校验当前证书,不重复创建任务。
ValidateCertificateTask func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error)
RunRenewal func(context.Context) (certificate.RenewalReport, error)
UpdateRenewalPolicy func(certificate.RenewalPolicy)
@@ -106,6 +108,7 @@ type Server struct {
deployCertificateTask func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
restoreVersion func(context.Context, string, string) (certificate.IssueResult, error)
validateCertificateWorkflow func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error)
validateCertificateTask func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error)
runRenewal func(context.Context) (certificate.RenewalReport, error)
updateRenewalPolicy func(certificate.RenewalPolicy)
@@ -175,6 +178,7 @@ func New(deps Dependencies) *Server {
deployCertificateTask: deps.DeployCertificateTask,
restoreVersion: deps.RestoreCertificateVersion,
validateCertificateWorkflow: deps.ValidateCertificate,
validateCertificateTask: deps.ValidateCertificateTask,
runRenewal: deps.RunRenewal,
updateRenewalPolicy: deps.UpdateRenewalPolicy,
currentCertificate: deps.CurrentCertificate,
@@ -231,6 +235,7 @@ func (s *Server) registerRoutes() {
api.POST("/tasks/:id/retry", s.retryTask)
api.GET("/tasks/:id/attempts", s.listTaskAttempts)
api.GET("/tasks/:id/deployment-results", s.listTaskDeploymentResults)
api.GET("/tasks/:id/validation-results", s.listTaskValidationResults)
adminAPI.GET("/settings", s.getSettings)
adminAPI.PUT("/settings", s.requireSuperAdminSystemConfig, s.updateSettings)
+56 -7
View File
@@ -38,7 +38,7 @@ func (s *Server) submitPreparedDomainTask(c *gin.Context, taskType string, prepa
prepared.cleanup()
}
}()
if (taskType == "certificate_issue" && s.issueCertificate == nil) || (taskType == "certificate_deploy" && s.deployCertificateTask == nil) {
if (taskType == "certificate_issue" && s.issueCertificate == nil) || (taskType == "certificate_deploy" && s.deployCertificateTask == nil) || (taskType == "certificate_validate" && s.validateCertificateTask == nil) {
s.writeError(c, http.StatusNotImplemented, "证书申请接口尚未配置", errors.New("证书申请工作流未配置"))
return
}
@@ -75,9 +75,17 @@ func (s *Server) submitPreparedDomainTask(c *gin.Context, taskType string, prepa
return
}
}
if err := authorizer.AuthorizeProject(c.Request.Context(), c.GetString(authenticatedActorKey), resource.ResourceScope.Normalize().ProjectID, domain.PermissionDeploymentExecute); err != nil {
permission := domain.PermissionDeploymentExecute
if taskType == "certificate_validate" {
permission = domain.PermissionPrivateKeyRead
}
if err := authorizer.AuthorizeProject(c.Request.Context(), c.GetString(authenticatedActorKey), resource.ResourceScope.Normalize().ProjectID, permission); err != nil {
if errors.Is(err, repository.ErrProjectAccessDenied) {
s.writeError(c, http.StatusForbidden, "无权执行此项目的证书部署任务", nil)
message := "无权执行此项目的证书部署任务"
if taskType == "certificate_validate" {
message = "无权读取此项目的私钥进行证书校验"
}
s.writeError(c, http.StatusForbidden, message, nil)
return
}
s.writeError(c, http.StatusInternalServerError, "检查证书部署权限失败", err)
@@ -176,6 +184,10 @@ func (s *Server) submitPreparedDomainTask(c *gin.Context, taskType string, prepa
s.executeCertificateDeployTask(c, task, attempt, taskType)
return
}
if taskType == "certificate_validate" {
s.executeCertificateValidationTask(c, task, attempt)
return
}
s.executeCertificateIssueTask(c, task, attempt, taskType)
}
@@ -192,6 +204,19 @@ func (s *Server) executeCertificateDeployTask(c *gin.Context, task repository.Ta
}
func (s *Server) runCertificateTask(ctx context.Context, task repository.Task, attempt repository.TaskAttempt, auditAction string, operation func(context.Context, string) (certificate.IssueResult, deployment.Report, error), stage, runningMessage, successMessage string) {
s.runCertificateOperation(ctx, task, attempt, auditAction, func(ctx context.Context, id string) (certificateTaskResult, error) {
result, report, err := operation(ctx, id)
return certificateTaskResult{Certificate: result, Deployment: &report}, err
}, stage, runningMessage, successMessage)
}
type certificateTaskResult struct {
Certificate certificate.IssueResult
Deployment *deployment.Report
Validation *certificate.ValidationResult
}
func (s *Server) runCertificateOperation(ctx context.Context, task repository.Task, attempt repository.TaskAttempt, auditAction string, operation func(context.Context, string) (certificateTaskResult, error), stage, runningMessage, successMessage string) {
executionCtx := deployment.WithTransactionContext(ctx, deployment.TransactionContext{
TaskID: task.ID, AttemptID: attempt.ID, AttemptNumber: attempt.AttemptNumber,
})
@@ -241,7 +266,12 @@ func (s *Server) runCertificateTask(ctx context.Context, task repository.Task, a
if s.finishCancelledTask(task, attempt, executionCtx) {
return
}
certificateResult, deploymentReport, issueErr := operation(executionCtx, task.DomainID)
result, issueErr := operation(executionCtx, task.DomainID)
certificateResult := result.Certificate
var deploymentReport deployment.Report
if result.Deployment != nil {
deploymentReport = *result.Deployment
}
if task.TaskType == "certificate_import" {
deploymentReport.CertificateImported = issueErr == nil || (certificateResult.DomainID == task.DomainID &&
certificateResult.Saved.CertificatePath != "" && certificateResult.Saved.FullChainPath != "" && certificateResult.Saved.PrivateKeyPath != "")
@@ -275,6 +305,15 @@ func (s *Server) runCertificateTask(ctx context.Context, task repository.Task, a
message = "证书已导入,但部署未完成。请检查部署结果后重试部署,无需重新导入。"
}
}
if task.TaskType == "certificate_validate" && issueErr != nil {
message = "证书校验失败,请检查当前证书、私钥匹配及证书链"
if status == "cancelled" {
message = "证书校验已取消"
}
if errors.Is(issueErr, context.DeadlineExceeded) {
message = "证书校验超时"
}
}
s.taskMu.Lock()
defer s.taskMu.Unlock()
if persisted, err := s.tasks.GetTask(finishCtx, task.ID); err != nil {
@@ -287,13 +326,23 @@ func (s *Server) runCertificateTask(ctx context.Context, task repository.Task, a
} else if status == "cancelled" {
status = "cancelled"
message = "任务已停止;已执行操作是否回滚请查看部署结果"
if task.TaskType == "certificate_validate" {
message = "证书校验已停止,未保存通过结果"
}
}
}
if err := s.tasks.FinishTaskAttempt(finishCtx, repository.TaskCompletion{
completion := repository.TaskCompletion{
TaskID: task.ID, AttemptID: attempt.ID, Status: status, Stage: stage,
Message: message, StartedAt: &now, FinishedAt: finished,
Report: &deploymentReport, AuditAction: auditAction,
}); err != nil && s.logger != nil {
AuditAction: auditAction,
}
if result.Deployment != nil {
completion.Report = &deploymentReport
}
if status == "success" {
completion.Validation = result.Validation
}
if err := s.tasks.FinishTaskAttempt(finishCtx, completion); err != nil && s.logger != nil {
s.logger.Error("保存任务及尝试终态失败,保留中断恢复状态", "task_id", task.ID, "error", err)
}
}
@@ -28,6 +28,8 @@ func (s *Server) authorizeCertificateTaskExecution(ctx context.Context, task rep
case "certificate_deploy":
case "certificate_import":
permissions = append(permissions, domain.PermissionCertificateManage)
case "certificate_validate":
permissions = []domain.ProjectPermission{domain.PermissionPrivateKeyRead}
default:
return repository.ErrProjectAccessDenied
}
@@ -17,11 +17,11 @@ import (
)
func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
for _, taskType := range []string{"certificate_issue", "certificate_deploy", "certificate_import"} {
for _, taskType := range []string{"certificate_issue", "certificate_deploy", "certificate_import", "certificate_validate"} {
for _, scenario := range []string{
"unchanged", "disabled_user", "removed_member", "read_only_member",
"moved_domain", "deleted_domain", "deployment_denied", "certificate_denied",
"dns_denied", "authorization_error", "missing_authorizer", "missing_reader",
"dns_denied", "private_key_denied", "authorization_error", "missing_authorizer", "missing_reader",
} {
t.Run(taskType+"/"+scenario, func(t *testing.T) {
var calls atomic.Int32
@@ -32,6 +32,10 @@ func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
server, tasks, audit, cleanup := newTaskAPITestServer(t, operation)
defer cleanup()
server.deployCertificateTask = operation
server.validateCertificateTask = func(context.Context, string) (certificate.IssueResult, certificate.ValidationResult, error) {
calls.Add(1)
return certificate.IssueResult{}, certificate.ValidationResult{Domains: []string{"example.com"}}, nil
}
server.importCertificateTask = func(ctx context.Context, request certificate.ImportRequest) (certificate.IssueResult, deployment.Report, error) {
return operation(ctx, request.DomainID)
}
@@ -45,6 +49,9 @@ func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
if taskType == "certificate_import" {
path = "/api/v1/domains/domain-1/certificate/import"
}
if taskType == "certificate_validate" {
path = "/api/v1/domains/domain-1/certificate/validate"
}
response := httptest.NewRecorder()
serveAdminHTTP(server, response, httptest.NewRequest(http.MethodPost, path,
strings.NewReader(`{"certificate_path":"/managed/cert.pem","private_key_path":"/managed/key.pem"}`)))
@@ -78,7 +85,7 @@ func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
server.projectMembers = nil
case "missing_reader":
server.projectResources = nil
case "deployment_denied", "certificate_denied", "dns_denied", "authorization_error":
case "deployment_denied", "certificate_denied", "dns_denied", "private_key_denied", "authorization_error":
server.projectMembers = permissionProjectMemberRepository{
ProjectMemberRepository: server.projectMembers,
allow: func(permission domain.ProjectPermission) error {
@@ -87,7 +94,8 @@ func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
}
if scenario == "deployment_denied" && permission == domain.PermissionDeploymentExecute ||
scenario == "certificate_denied" && permission == domain.PermissionCertificateManage ||
scenario == "dns_denied" && permission == domain.PermissionDNSCredentialUse {
scenario == "dns_denied" && permission == domain.PermissionDNSCredentialUse ||
scenario == "private_key_denied" && permission == domain.PermissionPrivateKeyRead {
return repository.ErrProjectAccessDenied
}
return nil
@@ -102,6 +110,9 @@ func TestAsyncExecutionRechecksQueuedAuthorization(t *testing.T) {
<-server.taskSlots
waitTaskWorkersForTest(t, server)
want := "failed"
if taskType == "certificate_validate" && (scenario == "deployment_denied" || scenario == "certificate_denied" || scenario == "dns_denied") || taskType != "certificate_validate" && scenario == "private_key_denied" {
want = "success"
}
if scenario == "unchanged" || taskType == "certificate_deploy" && (scenario == "dns_denied" || scenario == "certificate_denied") || taskType == "certificate_import" && scenario == "dns_denied" {
want = "success"
}
+12 -2
View File
@@ -16,6 +16,12 @@ import (
// 持久化任务与尝试后才调用此入口;后台执行不得持有请求或响应对象。
// 进程中断由启动恢复标记失败,不自动重放可能已经签发或部署的外部操作。
func (s *Server) enqueueCertificateTask(c *gin.Context, task repository.Task, attempt repository.TaskAttempt, action string, operation func(context.Context, string) (certificate.IssueResult, deployment.Report, error), stage, runningMessage, successMessage string, cleanup func()) bool {
return s.enqueueTaskWorker(c, task, attempt, func(ctx context.Context) {
s.runCertificateTask(ctx, task, attempt, action, operation, stage, runningMessage, successMessage)
}, cleanup)
}
func (s *Server) enqueueTaskWorker(c *gin.Context, task repository.Task, attempt repository.TaskAttempt, execute func(context.Context), cleanup func()) bool {
s.taskMu.Lock()
if s.taskWorkersStopped || len(s.asyncTasks) >= 32 {
s.taskMu.Unlock()
@@ -44,7 +50,11 @@ func (s *Server) enqueueCertificateTask(c *gin.Context, task repository.Task, at
defer cancel()
defer func() {
if recover() != nil {
s.finishTaskBeforeExecution(task, attempt, "failed", "任务执行异常中断,请检查部署恢复状态后重试")
message := "任务执行异常中断,请检查部署恢复状态后重试"
if task.TaskType == "certificate_validate" {
message = "证书校验异常中断,未保存通过结果"
}
s.finishTaskBeforeExecution(task, attempt, "failed", message)
}
}()
select {
@@ -54,7 +64,7 @@ func (s *Server) enqueueCertificateTask(c *gin.Context, task repository.Task, at
s.finishTaskContext(task, attempt, ctx.Err())
return
}
s.runCertificateTask(ctx, task, attempt, action, operation, stage, runningMessage, successMessage)
execute(ctx)
}()
return true
}
@@ -0,0 +1,53 @@
package httpapi
import (
"context"
"database/sql"
"errors"
"net/http"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
func (s *Server) executeCertificateValidationTask(c *gin.Context, task repository.Task, attempt repository.TaskAttempt) {
if s.enqueueTaskWorker(c, task, attempt, func(ctx context.Context) {
s.runCertificateOperation(ctx, task, attempt, task.TaskType, func(ctx context.Context, id string) (certificateTaskResult, error) {
_, validation, err := s.validateCertificateTask(ctx, id)
if err != nil {
return certificateTaskResult{}, err
}
return certificateTaskResult{Validation: &validation}, nil
}, "certificate_validate", "正在校验证书、私钥匹配及证书链", "证书校验通过")
}, nil) {
writeAcceptedCertificateTask(c, task)
}
}
func (s *Server) listTaskValidationResults(c *gin.Context) {
reader, ok := s.projectTaskReader(c)
if !ok {
return
}
actorID := c.GetString(authenticatedActorKey)
if _, err := reader.GetVisibleTask(c.Request.Context(), actorID, c.Param("id")); err != nil {
if errors.Is(err, sql.ErrNoRows) || errors.Is(err, repository.ErrProjectAccessDenied) {
s.writeError(c, http.StatusForbidden, "无权访问此任务", nil)
return
}
s.writeError(c, http.StatusInternalServerError, "读取任务失败", err)
return
}
validationReader, ok := s.tasks.(repository.TaskValidationReader)
if !ok {
s.writeError(c, http.StatusNotImplemented, "任务校验结果接口尚未配置", nil)
return
}
items, err := validationReader.ListVisibleTaskValidations(c.Request.Context(), actorID, c.Param("id"))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询任务校验结果失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}