保存完整任务报告及完成审计原子化基线,最新回归待确认

This commit is contained in:
xuans committed 2026-10-02 17:51:37 +08:00
1 parent 8a8b1a5e0e
commit 4e8d50919a
21 files changed
+505 -52

No files matched your search

@@ -17,6 +17,7 @@ type ProjectTaskReader interface {
GetVisibleTask(context.Context, string, string) (Task, error)
ListVisibleTaskAttempts(context.Context, string, string) ([]TaskAttempt, error)
ListVisibleTaskDeploymentResults(context.Context, string, string) ([]TaskDeploymentResult, error)
ListVisibleTaskDeploymentReports(context.Context, string, string) ([]TaskDeploymentReport, error)
CancelVisibleTask(context.Context, string, string, string, *time.Time) error
RequestCancelVisibleTask(context.Context, string, string) error
RetryVisibleTask(context.Context, string, string, *time.Time) (Task, TaskAttempt, error)
+21 -7
View File
@@ -7,17 +7,21 @@ import (
"fmt"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
// TaskCompletion 同时关闭任务与对应尝试,避免只保存其中一方的终态。
type TaskCompletion struct {
TaskID string
AttemptID string
Status string
Stage string
Message string
StartedAt *time.Time
FinishedAt time.Time
TaskID string
AttemptID string
Status string
Stage string
Message string
StartedAt *time.Time
FinishedAt time.Time
Report *deployment.Report
AuditAction string
}
func (r *SQLTaskRepository) FinishTaskAttempt(ctx context.Context, completion TaskCompletion) error {
@@ -66,6 +70,16 @@ func (r *SQLTaskRepository) FinishTaskAttempt(ctx context.Context, completion Ta
} else if count != 1 {
return sql.ErrNoRows
}
if completion.Report != nil {
if err := r.recordCompletionReport(ctx, tx, completion); err != nil {
return err
}
}
if completion.AuditAction != "" {
if err := r.recordCompletionAudit(ctx, tx, completion); err != nil {
return err
}
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("提交任务收尾事务失败:%w", err)
}
@@ -0,0 +1,30 @@
package repository
import (
"context"
"database/sql"
"fmt"
)
// 完成审计从已锁定的任务取资源、操作者及项目,不信任外部传入的归属字段。
func (r *SQLTaskRepository) recordCompletionAudit(ctx context.Context, tx *sql.Tx, completion TaskCompletion) error {
status := completion.Status
if status == "failed" {
status = "error"
}
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
FROM tasks WHERE id = ?`), completion.AuditAction, status, completion.Message,
completion.FinishedAt.UTC(), completion.TaskID)
if err != nil {
return fmt.Errorf("保存任务完成审计失败:%w", err)
}
if count, err := result.RowsAffected(); err != nil {
return fmt.Errorf("读取任务完成审计写入结果失败:%w", err)
} else if count != 1 {
return sql.ErrNoRows
}
return nil
}
+109
View File
@@ -0,0 +1,109 @@
package repository
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
// TaskDeploymentReport 保存一次尝试的完整公开报告,不包含远端输出或私钥。
type TaskDeploymentReport struct {
TaskID string `json:"task_id"`
AttemptID string `json:"attempt_id"`
AttemptNumber int `json:"attempt_number"`
Report deployment.Report `json:"report"`
CreatedAt time.Time `json:"created_at"`
}
func publicTaskReport(report deployment.Report) deployment.Report {
report.Results = append([]deployment.Result{}, report.Results...)
for index := range report.Results {
report.Results[index] = deployment.PublicResult(report.Results[index])
}
return report
}
// 报告、逐目标结果和两条终态共用事务;任一保存失败均保留活动记录供恢复接管。
func (r *SQLTaskRepository) recordCompletionReport(ctx context.Context, tx *sql.Tx, completion TaskCompletion) error {
var attemptNumber int
if err := tx.QueryRowContext(ctx, r.query(`SELECT attempt_number FROM task_attempts WHERE id = ? AND task_id = ?`),
completion.AttemptID, completion.TaskID).Scan(&attemptNumber); err != nil {
return fmt.Errorf("读取报告所属尝试失败:%w", err)
}
report := publicTaskReport(*completion.Report)
content, err := json.Marshal(report)
if err != nil {
return fmt.Errorf("序列化部署报告失败:%w", err)
}
if _, err := tx.ExecContext(ctx, r.query(`INSERT INTO task_deployment_reports
(task_id, attempt_id, attempt_number, report_json, created_at) VALUES (?, ?, ?, ?, ?)`),
completion.TaskID, completion.AttemptID, attemptNumber, string(content), completion.FinishedAt.UTC()); err != nil {
return fmt.Errorf("保存完整部署报告失败:%w", err)
}
if _, err := tx.ExecContext(ctx, r.query(`DELETE FROM task_deployment_results WHERE task_id = ? AND attempt_id = ?`),
completion.TaskID, completion.AttemptID); err != nil {
return fmt.Errorf("清理尝试旧结果失败:%w", err)
}
for index, result := range report.Results {
if _, err := tx.ExecContext(ctx, r.query(`INSERT INTO task_deployment_results
(task_id, attempt_id, attempt_number, result_index, server_id, server_name, status, message, backup_id, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), completion.TaskID, completion.AttemptID, attemptNumber,
index, result.ServerID, result.Server, result.Status, result.Message, result.BackupID, completion.FinishedAt.UTC()); err != nil {
return fmt.Errorf("保存报告逐服务器结果失败:%w", err)
}
}
return nil
}
func (r *SQLTaskRepository) ListTaskDeploymentReports(ctx context.Context, taskID string) ([]TaskDeploymentReport, error) {
if r == nil || r.db == nil || strings.TrimSpace(taskID) == "" {
return nil, errors.New("数据库连接和任务编号不能为空")
}
return r.listTaskReports(ctx, `SELECT task_id, attempt_id, attempt_number, report_json, created_at
FROM task_deployment_reports WHERE task_id = ? ORDER BY attempt_number`, taskID)
}
func (r *SQLTaskRepository) ListVisibleTaskDeploymentReports(ctx context.Context, actorID, taskID string) ([]TaskDeploymentReport, error) {
if r == nil || r.db == nil {
return nil, errors.New("数据库连接不能为空")
}
predicate, args := taskVisibilityPredicate("tasks", domain.PermissionTaskRead)
args[0] = strings.TrimSpace(actorID)
args = append(args, strings.TrimSpace(taskID))
return r.listTaskReports(ctx, `SELECT reports.task_id, reports.attempt_id, reports.attempt_number, reports.report_json, reports.created_at
FROM task_deployment_reports reports JOIN tasks ON tasks.id = reports.task_id
WHERE `+predicate+` AND reports.task_id = ? ORDER BY reports.attempt_number`, args...)
}
func (r *SQLTaskRepository) listTaskReports(ctx context.Context, query string, args ...any) ([]TaskDeploymentReport, error) {
rows, err := r.db.QueryContext(ctx, r.query(query), args...)
if err != nil {
return nil, fmt.Errorf("查询完整部署报告失败:%w", err)
}
defer rows.Close()
items := make([]TaskDeploymentReport, 0)
for rows.Next() {
var item TaskDeploymentReport
var content string
if err := rows.Scan(&item.TaskID, &item.AttemptID, &item.AttemptNumber, &content, &item.CreatedAt); err != nil {
return nil, fmt.Errorf("读取完整部署报告失败:%w", err)
}
if err := json.Unmarshal([]byte(content), &item.Report); err != nil {
return nil, fmt.Errorf("解析完整部署报告失败:%w", err)
}
item.Report = publicTaskReport(item.Report)
item.CreatedAt = item.CreatedAt.UTC()
items = append(items, item)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取完整部署报告列表失败:%w", err)
}
return items, nil
}
@@ -0,0 +1,123 @@
package repository
import (
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
func completionTestReport() *deployment.Report {
return &deployment.Report{
Total: 2, Success: 1, Failed: 1, Status: "failed", VerificationStatus: "failed", RecoveryStatus: "unconfirmed",
Results: []deployment.Result{
{ServerID: "server-1", Server: "第一台", Status: "success", BackupID: "backup-1"},
{ServerID: "server-2", Server: "第二台", Status: "failed", FailureCode: deployment.FailureRecoveryUnknown, Message: "secret-output-marker"},
},
}
}
func TestTaskCompletionReportPersistsAcrossRepositoryRestart(t *testing.T) {
repo, db := newTaskRepositoryTest(t)
defer db.Close()
completion := seedTaskCompletion(t, repo)
completion.Status = "failed"
completion.Report = completionTestReport()
completion.AuditAction = "certificate_deploy"
if err := repo.FinishTaskAttempt(t.Context(), completion); err != nil {
t.Fatal(err)
}
reader := NewSQLTaskRepository(db)
var auditStatus, scope, projectID, resourceID string
if err := db.QueryRowContext(t.Context(), `SELECT status, scope_type, project_id, resource_id FROM audit_logs WHERE task_id = ?`,
completion.TaskID).Scan(&auditStatus, &scope, &projectID, &resourceID); err != nil || auditStatus != "error" || scope != "project" || projectID != "default" || resourceID != "domain-1" {
t.Fatalf("完成审计与任务状态或归属不一致:%s %s %s %s %v", auditStatus, scope, projectID, resourceID, err)
}
reports, err := reader.ListTaskDeploymentReports(t.Context(), completion.TaskID)
if err != nil || len(reports) != 1 {
t.Fatalf("完整报告未保存:%+v %v", reports, err)
}
stored := reports[0]
if stored.AttemptNumber != 1 || stored.AttemptID != completion.AttemptID || stored.Report.VerificationStatus != "failed" || stored.Report.RecoveryStatus != "unconfirmed" || len(stored.Report.Results) != 2 {
t.Fatalf("重读后验证或恢复证据丢失:%+v", stored)
}
if stored.Report.Results[1].FailureCode != deployment.FailureRecoveryUnknown || strings.Contains(stored.Report.Results[1].Message, "secret-output-marker") {
t.Fatal("报告未保留固定诊断或泄露远端输出")
}
var raw string
if err := db.QueryRowContext(t.Context(), `SELECT report_json FROM task_deployment_reports WHERE task_id = ?`, completion.TaskID).Scan(&raw); err != nil || strings.Contains(raw, "secret-output-marker") {
t.Fatalf("持久化前未脱敏:%v", err)
}
results, err := reader.ListTaskDeploymentResults(t.Context(), completion.TaskID)
if err != nil || len(results) != 2 || results[1].Message != stored.Report.Results[1].Message {
t.Fatalf("逐目标结果与报告不一致:%+v %v", results, err)
}
if completion.Report.Results[1].Message != "secret-output-marker" {
t.Fatal("保存报告不能原地修改调用者结果")
}
if _, err := db.ExecContext(t.Context(), `INSERT INTO users (id, username, password_hash, role, status)
VALUES ('report-admin', 'report-admin', 'test', 'admin', 'active')`); err != nil {
t.Fatal(err)
}
if _, err := db.ExecContext(t.Context(), `INSERT INTO project_members (project_id, user_id, role)
VALUES ('default', 'report-admin', 'project_admin')`); err != nil {
t.Fatal(err)
}
_, retry, err := repo.RetryVisibleTask(t.Context(), "report-admin", completion.TaskID, nil)
if err != nil {
t.Fatal(err)
}
completion.AttemptID = retry.ID
completion.Status = "success"
completion.FinishedAt = time.Now().UTC()
completion.Report = &deployment.Report{Status: "success", VerificationStatus: "success"}
if err := repo.FinishTaskAttempt(t.Context(), completion); err != nil {
t.Fatal(err)
}
reports, err = reader.ListTaskDeploymentReports(t.Context(), completion.TaskID)
if err != nil || len(reports) != 2 || reports[0].Report.RecoveryStatus != "unconfirmed" || reports[1].AttemptNumber != 2 || reports[1].Report.VerificationStatus != "success" {
t.Fatalf("重试覆盖或混用了旧报告:%+v %v", reports, err)
}
if reports[1].Report.Results == nil {
t.Fatal("零目标报告必须返回空数组而非空值,避免前端忽略验证状态")
}
}
func TestTaskCompletionReportFailureRollsBackAllRecords(t *testing.T) {
for _, table := range []string{"task_deployment_reports", "task_deployment_results", "audit_logs"} {
t.Run(table, func(t *testing.T) {
repo, db := newTaskRepositoryTest(t)
defer db.Close()
completion := seedTaskCompletion(t, repo)
completion.Report = completionTestReport()
completion.AuditAction = "certificate_deploy"
if _, err := db.ExecContext(t.Context(), `CREATE TRIGGER reject_report BEFORE INSERT ON `+table+` BEGIN SELECT RAISE(ABORT, 'injected report failure'); END`); err != nil {
t.Fatal(err)
}
if err := repo.FinishTaskAttempt(t.Context(), completion); err == nil {
t.Fatal("报告保存失败必须拒绝提交终态")
}
task, err := repo.GetTask(t.Context(), completion.TaskID)
if err != nil || task.Status != "running" || task.FinishedAt != nil {
t.Fatalf("报告失败但任务被提交:%+v %v", task, err)
}
attempts, err := repo.ListAttempts(t.Context(), completion.TaskID)
if err != nil || len(attempts) != 1 || attempts[0].Status != "running" || attempts[0].FinishedAt != nil {
t.Fatalf("报告失败但尝试被提交:%+v %v", attempts, err)
}
reports, err := repo.ListTaskDeploymentReports(t.Context(), completion.TaskID)
if err != nil || len(reports) != 0 {
t.Fatalf("出现部分提交的报告:%+v %v", reports, err)
}
results, err := repo.ListTaskDeploymentResults(t.Context(), completion.TaskID)
if err != nil || len(results) != 0 {
t.Fatalf("出现部分提交的目标结果:%+v %v", results, err)
}
var auditCount int
if err := db.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM audit_logs WHERE task_id = ?`, completion.TaskID).Scan(&auditCount); err != nil || auditCount != 0 {
t.Fatalf("出现部分提交的完成审计:%d %v", auditCount, err)
}
})
}
}
@@ -72,6 +72,7 @@ type TaskRepository interface {
ListAttempts(context.Context, string) ([]TaskAttempt, error)
RecordTaskDeploymentResults(context.Context, string, string, int, []TaskDeploymentResult) error
ListTaskDeploymentResults(context.Context, string) ([]TaskDeploymentResult, error)
ListTaskDeploymentReports(context.Context, string) ([]TaskDeploymentReport, error)
}
type SQLTaskRepository struct {