完善任务审计范围快照与身份关联并同步整改进度

新增三库第13号迁移和历史范围回填,保留已删除资源的任务与审计。补充仓储、调用链、身份来源及迁移失败重试回归,同步任务清单、支持矩阵和运维边界。项目成员授权与生产验收仍待完成。
This commit is contained in:
xuans committed 2026-09-28 11:48:27 +08:00
1 parent 5237e8d810
commit 0ccdb14b26
34 files changed
+989 -48

No files matched your search

+4 -2
View File
@@ -18,7 +18,8 @@ func (r *SQLAuditRepository) ListAuditLogs(ctx context.Context, limit int) ([]Au
if limit <= 0 || limit > 200 {
limit = 50
}
rows, err := r.db.QueryContext(ctx, r.query(`SELECT id, action, resource_type, resource_id, status, message, created_at FROM audit_logs ORDER BY created_at DESC, id DESC LIMIT `+fmt.Sprintf("%d", limit)))
rows, err := r.db.QueryContext(ctx, r.query(`SELECT id, action, resource_type, resource_id, status, message, created_at,
scope_type, project_id, task_id, operator_id FROM audit_logs ORDER BY created_at DESC, id DESC LIMIT `+fmt.Sprintf("%d", limit)))
if err != nil {
return nil, fmt.Errorf("查询审计日志失败:%w", err)
}
@@ -26,7 +27,8 @@ func (r *SQLAuditRepository) ListAuditLogs(ctx context.Context, limit int) ([]Au
logs := make([]AuditLog, 0)
for rows.Next() {
var item AuditLog
if err := rows.Scan(&item.ID, &item.Action, &item.ResourceType, &item.ResourceID, &item.Status, &item.Message, &item.CreatedAt); err != nil {
if err := rows.Scan(&item.ID, &item.Action, &item.ResourceType, &item.ResourceID, &item.Status, &item.Message, &item.CreatedAt,
&item.ScopeType, &item.ProjectID, &item.TaskID, &item.OperatorID); err != nil {
return nil, fmt.Errorf("读取审计日志失败:%w", err)
}
item.CreatedAt = item.CreatedAt.UTC()
@@ -10,6 +10,9 @@ import (
)
type AuditLog struct {
HistoryScope
TaskID string `json:"task_id"`
OperatorID string `json:"operator_id"`
ID int64 `json:"id"`
Action string `json:"action"`
ResourceType string `json:"resource_type"`
@@ -44,15 +47,28 @@ func (r *SQLAuditRepository) CreateAuditLog(ctx context.Context, item AuditLog)
item.ResourceType = strings.TrimSpace(item.ResourceType)
item.ResourceID = strings.TrimSpace(item.ResourceID)
item.Status = strings.TrimSpace(item.Status)
item.TaskID = strings.TrimSpace(item.TaskID)
item.OperatorID = strings.TrimSpace(item.OperatorID)
if item.Action == "" || item.ResourceType == "" || item.Status == "" {
return errors.New("审计日志必要字段不能为空")
}
if item.CreatedAt.IsZero() {
item.CreatedAt = time.Now().UTC()
}
_, err := r.db.ExecContext(ctx, r.query(`INSERT INTO audit_logs
(action, resource_type, resource_id, status, message, created_at)
VALUES (?, ?, ?, ?, ?, ?)`), item.Action, item.ResourceType, item.ResourceID, item.Status, item.Message, item.CreatedAt.UTC())
if item.ResourceType == "task" && item.TaskID == "" {
item.TaskID = item.ResourceID
}
scope, err := r.resolveScope(ctx, item)
if err != nil {
return fmt.Errorf("解析审计范围失败:%w", err)
}
if !item.HistoryScope.matches(scope) {
return errors.New("审计项目与资源范围不匹配")
}
_, err = r.db.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)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), item.Action, item.ResourceType, item.ResourceID, item.Status, item.Message,
item.CreatedAt.UTC(), scope.ScopeType, scope.ProjectID, item.TaskID, item.OperatorID)
if err != nil {
return fmt.Errorf("保存审计日志失败:%w", err)
}
@@ -0,0 +1,71 @@
package repository
import (
"context"
"database/sql"
"errors"
)
const (
ScopeProject = "project"
ScopeSystem = "system"
ScopeUnknown = "unknown"
ManagementResourceID = "management-certificate"
)
// HistoryScope 保存事件发生时的范围,资源或项目删除后仍保留;不是项目授权凭证。
// 未知历史归属保持为空,不自动降级为系统范围,也不归入默认项目。
type HistoryScope struct {
ScopeType string `json:"scope_type"`
ProjectID string `json:"project_id"`
}
func (s HistoryScope) matches(actual HistoryScope) bool {
return (s.ScopeType == "" || s.ScopeType == actual.ScopeType) && (s.ProjectID == "" || s.ProjectID == actual.ProjectID)
}
func (r *SQLAuditRepository) resolveScope(ctx context.Context, item AuditLog) (HistoryScope, error) {
if item.TaskID != "" {
task, err := NewSQLTaskRepository(r.db, r.driver).GetTask(ctx, item.TaskID)
if err != nil {
return HistoryScope{}, err
}
valid := item.ResourceType == "task" && item.ResourceID == task.ID
if item.ResourceType == "domain" || item.ResourceType == "certificate" {
valid = task.ScopeType != ScopeSystem && item.ResourceID == task.DomainID
}
if item.ResourceType == "management_certificate" {
valid = task.ScopeType == ScopeSystem && item.ResourceID == ManagementResourceID
}
if !valid {
return HistoryScope{}, errors.New("审计任务与资源不匹配")
}
return task.HistoryScope, nil
}
var table string
switch item.ResourceType {
case "auth", "user", "super_admin":
return HistoryScope{ScopeType: ScopeSystem}, nil
case "management_certificate":
if item.ResourceID == ManagementResourceID {
return HistoryScope{ScopeType: ScopeSystem}, nil
}
case "domain", "certificate":
table = "domains"
case "server":
table = "servers"
}
result := HistoryScope{ScopeType: ScopeUnknown}
if table != "" {
err := r.db.QueryRowContext(ctx, r.query("SELECT project_id FROM "+table+" WHERE id = ?"), item.ResourceID).Scan(&result.ProjectID)
if errors.Is(err, sql.ErrNoRows) {
// 对不存在资源的失败操作也需要审计,但不能伪造其项目。
return result, nil
}
if err != nil {
return HistoryScope{}, err
}
result.ScopeType = ScopeProject
}
return result, nil
}
@@ -0,0 +1,246 @@
package repository
import (
"context"
"path/filepath"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/testsupport/mysqltest"
)
func TestHistoryScopeSQLite(t *testing.T) {
cfg := config.Default(t.TempDir()).Database
cfg.DSN = filepath.Join(t.TempDir(), "history.db")
checkHistoryScope(t, cfg)
}
func TestHistoryScopeMySQLReal(t *testing.T) {
server := mysqltest.New(t)
checkHistoryScope(t, server.Database(t))
}
func checkHistoryScope(t *testing.T, cfg config.DatabaseConfig) {
t.Helper()
ctx := t.Context()
db, err := database.Open(ctx, cfg)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = db.Close() })
if err := database.Migrate(ctx, db.DB, cfg.Driver); err != nil {
t.Fatal(err)
}
projects := NewSQLProjectRepository(db.DB, cfg.Driver)
domains := NewSQLDomainRepository(db.DB, cfg.Driver)
tasks := NewSQLTaskRepository(db.DB, cfg.Driver)
audit := NewSQLAuditRepository(db.DB, cfg.Driver)
for _, id := range []string{"history-a", "history-b"} {
if err := projects.CreateProject(ctx, domain.Project{ID: id, Name: id}); err != nil {
t.Fatal(err)
}
}
resource, err := domain.NewDomain("history.example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
resource.ProjectID = "history-a"
if err := domains.Create(ctx, resource); err != nil {
t.Fatal(err)
}
expected := HistoryScope{ScopeType: ScopeProject, ProjectID: "history-a"}
task := Task{ID: "history-task", DomainID: resource.ID, TaskType: "certificate_issue", Status: "running", Stage: "issue", OperatorID: "actor", IdempotencyKey: "history-key"}
if err := tasks.CreateTask(ctx, task); err != nil {
t.Fatal(err)
}
for name, read := range map[string]func() (Task, error){
"get": func() (Task, error) { return tasks.GetTask(ctx, task.ID) },
"active": func() (Task, error) { return tasks.FindActiveTaskByDomain(ctx, resource.ID, task.TaskType) },
"idempotency": func() (Task, error) { return tasks.FindTaskByIdempotencyKey(ctx, resource.ID, task.IdempotencyKey) },
} {
t.Run(name, func(t *testing.T) {
stored, err := read()
if err != nil || stored.HistoryScope != expected || stored.OperatorID != "actor" {
t.Fatalf("任务范围读取错误:%+v,%v", stored, err)
}
})
}
for _, invalid := range []Task{
{ID: "missing", DomainID: "missing", TaskType: "certificate_issue"},
{ID: "forged-project", DomainID: resource.ID, TaskType: "certificate_issue", HistoryScope: HistoryScope{ProjectID: "history-b"}},
{ID: "forged-system", DomainID: resource.ID, TaskType: "certificate_issue", HistoryScope: HistoryScope{ScopeType: ScopeSystem}},
{ID: "forged-unknown", DomainID: resource.ID, TaskType: "certificate_issue", HistoryScope: HistoryScope{ScopeType: ScopeUnknown}},
{ID: "false-management", DomainID: resource.ID, TaskType: "management_renewal"},
{ID: "false-resource", DomainID: ManagementResourceID, TaskType: "certificate_issue"},
{ID: "system-project", DomainID: ManagementResourceID, TaskType: "management_renewal", HistoryScope: expected},
} {
t.Run(invalid.ID, func(t *testing.T) {
invalid.Status, invalid.Stage = "queued", "queued"
if err := tasks.CreateTask(ctx, invalid); err == nil {
t.Fatal("无效任务范围未拒绝")
}
})
}
attempt := TaskAttempt{ID: "history-attempt", TaskID: task.ID, AttemptNumber: 1, Stage: "issue", Status: "running"}
if err := tasks.CreateAttempt(ctx, attempt); err != nil {
t.Fatal(err)
}
for _, invalid := range []TaskAttempt{
{ID: "missing-parent", TaskID: "missing"},
{ID: "wrong-project", TaskID: task.ID, HistoryScope: HistoryScope{ProjectID: "history-b"}},
{ID: "wrong-system", TaskID: task.ID, HistoryScope: HistoryScope{ScopeType: ScopeSystem}},
} {
t.Run(invalid.ID, func(t *testing.T) {
invalid.AttemptNumber, invalid.Stage, invalid.Status = 2, "issue", "running"
if err := tasks.CreateAttempt(ctx, invalid); err == nil {
t.Fatal("无效任务尝试关联未拒绝")
}
})
}
management := Task{ID: "management", DomainID: ManagementResourceID, TaskType: "management_renewal", Status: "running", Stage: "issue"}
if err := tasks.CreateTask(ctx, management); err != nil {
t.Fatal(err)
}
if stored, err := tasks.GetTask(ctx, management.ID); err != nil || stored.HistoryScope != (HistoryScope{ScopeType: ScopeSystem}) {
t.Fatalf("系统任务范围错误:%+v,%v", stored, err)
}
if err := tasks.CreateAttempt(ctx, TaskAttempt{ID: "management-attempt", TaskID: management.ID, AttemptNumber: 1, Stage: "issue", Status: "running"}); err != nil {
t.Fatal(err)
}
if attempts, err := tasks.ListAttempts(ctx, management.ID); err != nil || len(attempts) != 1 || attempts[0].HistoryScope != (HistoryScope{ScopeType: ScopeSystem}) {
t.Fatalf("系统尝试范围错误:%+v,%v", attempts, err)
}
for _, entry := range []AuditLog{
{Action: "direct", ResourceType: "domain", ResourceID: resource.ID},
{Action: "linked", ResourceType: "domain", ResourceID: resource.ID, TaskID: task.ID, OperatorID: "actor"},
{Action: "task", ResourceType: "task", ResourceID: task.ID},
{Action: "system", ResourceType: "management_certificate", ResourceID: ManagementResourceID, TaskID: management.ID},
{Action: "auth", ResourceType: "auth", ResourceID: "login"},
{Action: "missing", ResourceType: "domain", ResourceID: "deleted"},
} {
entry.Status = "success"
if err := audit.CreateAuditLog(ctx, entry); err != nil {
t.Fatal(entry.Action, err)
}
}
for _, entry := range []AuditLog{
{Action: "forged-project", ResourceType: "domain", ResourceID: resource.ID, HistoryScope: HistoryScope{ProjectID: "history-b"}},
{Action: "wrong-resource", ResourceType: "domain", ResourceID: "different", TaskID: task.ID},
{Action: "missing-task", ResourceType: "domain", ResourceID: resource.ID, TaskID: "missing"},
{Action: "wrong-system", ResourceType: "domain", ResourceID: resource.ID, TaskID: management.ID},
{Action: "wrong-task", ResourceType: "task", ResourceID: task.ID, TaskID: management.ID},
{Action: "false-system", ResourceType: "management_certificate", ResourceID: ManagementResourceID, TaskID: task.ID},
} {
t.Run(entry.Action, func(t *testing.T) {
entry.Status = "success"
if err := audit.CreateAuditLog(ctx, entry); err == nil {
t.Fatal("无效审计关联未拒绝")
}
})
}
finished := time.Now().UTC()
if err := tasks.CancelTask(ctx, task.ID, "测试取消", &finished); err != nil {
t.Fatal(err)
}
if err := domains.Delete(ctx, resource.ID); err != nil {
t.Fatal(err)
}
if err := projects.DeleteProject(ctx, "history-a"); err != nil {
t.Fatal(err)
}
// 资源和项目删除不删除任务,也不能让收尾审计丢失原项目。
if err := audit.CreateAuditLog(ctx, AuditLog{Action: "after-delete", ResourceType: "domain", ResourceID: resource.ID, TaskID: task.ID, Status: "cancelled"}); err != nil {
t.Fatal(err)
}
items, err := tasks.ListTasks(ctx, resource.ID, 10)
if err != nil || len(items) != 1 || items[0].HistoryScope != expected || items[0].Status != "cancelled" {
t.Fatalf("历史任务丢失:%+v,%v", items, err)
}
attempts, err := tasks.ListAttempts(ctx, task.ID)
if err != nil || len(attempts) != 1 || attempts[0].HistoryScope != expected || attempts[0].Status != "cancelled" {
t.Fatalf("尝试未继承历史范围:%+v,%v", attempts, err)
}
logs, err := audit.ListAuditLogs(ctx, 50)
if err != nil || len(logs) != 7 {
t.Fatalf("审计数量错误:%d,%v", len(logs), err)
}
for _, entry := range logs {
want := expected
if entry.Action == "system" || entry.Action == "auth" {
want = HistoryScope{ScopeType: ScopeSystem}
}
if entry.Action == "missing" {
want = HistoryScope{ScopeType: ScopeUnknown}
}
if entry.HistoryScope != want {
t.Fatalf("审计快照错误:%+v", entry)
}
if entry.Action == "linked" && (entry.TaskID != task.ID || entry.OperatorID != "actor") {
t.Fatalf("审计任务或操作者丢失:%+v", entry)
}
}
cancelled, cancel := context.WithCancel(ctx)
cancel()
if err := tasks.CreateTask(cancelled, management); err == nil {
t.Fatal("已取消上下文未生效")
}
checkHistoryAttemptBoundaries(t, domains, tasks)
}
func checkHistoryAttemptBoundaries(t *testing.T, domains *SQLDomainRepository, tasks *SQLTaskRepository) {
t.Helper()
for _, name := range []string{"deleted-resource", "changed-project", "unknown-parent", "orphan-attempt"} {
t.Run(name, func(t *testing.T) {
ctx := t.Context()
resource, err := domain.NewDomain(name+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
resource.ProjectID = "history-b"
if err := domains.Create(ctx, resource); err != nil {
t.Fatal(err)
}
task := Task{ID: name, DomainID: resource.ID, TaskType: "certificate_issue", Status: "running", Stage: "issue"}
if err := tasks.CreateTask(ctx, task); err != nil {
t.Fatal(err)
}
attempt := TaskAttempt{ID: name, TaskID: task.ID, AttemptNumber: 1, Status: "running", Stage: "issue"}
if err := tasks.CreateAttempt(ctx, attempt); err != nil {
t.Fatal(err)
}
switch name {
case "deleted-resource":
err = domains.Delete(ctx, resource.ID)
case "changed-project":
_, err = tasks.db.ExecContext(ctx, tasks.query("UPDATE domains SET project_id = ? WHERE id = ?"), "default", resource.ID)
case "unknown-parent":
// 模拟保留下来的未知历史任务,不通过新建接口伪造范围。
_, err = tasks.db.ExecContext(ctx, tasks.query("UPDATE tasks SET scope_type = 'unknown', project_id = '' WHERE id = ?"), task.ID)
case "orphan-attempt":
_, err = tasks.db.ExecContext(ctx, tasks.query("DELETE FROM tasks WHERE id = ?"), task.ID)
}
if err != nil {
t.Fatal(err)
}
attempt.ID += "-retry"
attempt.AttemptNumber = 2
if err := tasks.CreateAttempt(ctx, attempt); err == nil {
t.Fatal("资源或历史范围失效后仍允许新增尝试")
}
stored, err := tasks.ListAttempts(ctx, task.ID)
if err != nil || len(stored) != 1 || stored[0].ID != name {
t.Fatalf("历史尝试丢失或新增拒绝后残留:%+v,%v", stored, err)
}
want := HistoryScope{ScopeType: ScopeProject, ProjectID: "history-b"}
if name == "unknown-parent" || name == "orphan-attempt" {
want = HistoryScope{ScopeType: ScopeUnknown}
}
if stored[0].HistoryScope != want {
t.Fatalf("历史尝试范围被当前资源覆盖:%+v", stored[0])
}
})
}
}
+46 -11
View File
@@ -11,6 +11,7 @@ import (
// Task 表示一项可持久化的证书或部署任务。
type Task struct {
HistoryScope
ID string `json:"id"`
DomainID string `json:"domain_id"`
TaskType string `json:"task_type"`
@@ -28,6 +29,7 @@ type Task struct {
// TaskAttempt 表示任务的一次执行尝试。
type TaskAttempt struct {
HistoryScope
ID string `json:"id"`
TaskID string `json:"task_id"`
AttemptNumber int `json:"attempt_number"`
@@ -82,14 +84,35 @@ func (r *SQLTaskRepository) CreateTask(ctx context.Context, item Task) error {
if updated.IsZero() {
updated = now
}
_, err := r.db.ExecContext(ctx, r.query(`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)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
args := []any{
item.ID, item.DomainID, item.TaskType, item.Status, item.Stage, item.Message, item.OperatorID,
item.CertificateVersionID, item.IdempotencyKey, nullableTime(item.StartedAt), nullableTime(item.FinishedAt), now, updated)
item.CertificateVersionID, item.IdempotencyKey, nullableTime(item.StartedAt), nullableTime(item.FinishedAt), now, updated,
}
query := `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}) {
return errors.New("管理证书任务范围无效")
}
query += `VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'system', '')`
} else {
if item.DomainID == ManagementResourceID || (item.ScopeType != "" && item.ScopeType != ScopeProject) {
return errors.New("业务任务必须归属于实际域名项目")
}
// 一条语句读取资源归属并写入快照,不能先检查再插入悬空任务。
query += `SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'project', d.project_id
FROM domains d JOIN projects p ON p.id = d.project_id WHERE d.id = ? AND (? = '' OR d.project_id = ?)`
args = append(args, item.DomainID, item.ProjectID, item.ProjectID)
}
result, err := r.db.ExecContext(ctx, r.query(query), args...)
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 errors.New("任务资源不存在或项目不匹配")
}
return nil
}
@@ -297,13 +320,23 @@ func (r *SQLTaskRepository) CreateAttempt(ctx context.Context, item TaskAttempt)
if item.CreatedAt.IsZero() {
item.CreatedAt = time.Now().UTC()
}
_, err := r.db.ExecContext(ctx, r.query(`INSERT INTO task_attempts
result, err := r.db.ExecContext(ctx, r.query(`INSERT INTO task_attempts
(id, task_id, attempt_number, stage, status, message, started_at, finished_at, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`), item.ID, item.TaskID, item.AttemptNumber, item.Stage, item.Status, item.Message,
nullableTime(item.StartedAt), nullableTime(item.FinishedAt), item.CreatedAt.UTC())
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 = '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,
item.ScopeType, item.ScopeType, item.ProjectID, item.ProjectID)
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 errors.New("任务尝试的父任务不存在或范围不匹配")
}
return nil
}
@@ -345,7 +378,9 @@ func (r *SQLTaskRepository) ListAttempts(ctx context.Context, taskID string) ([]
if taskID == "" {
return nil, errors.New("任务 ID 不能为空")
}
rows, err := r.db.QueryContext(ctx, r.query(`SELECT id, task_id, attempt_number, stage, status, message, started_at, finished_at, created_at FROM task_attempts WHERE task_id = ? ORDER BY attempt_number`), taskID)
rows, err := r.db.QueryContext(ctx, r.query(`SELECT a.id, a.task_id, a.attempt_number, a.stage, a.status, a.message,
a.started_at, a.finished_at, a.created_at, COALESCE(t.scope_type, 'unknown'), COALESCE(t.project_id, '')
FROM task_attempts a LEFT JOIN tasks t ON t.id = a.task_id WHERE a.task_id = ? ORDER BY a.attempt_number`), taskID)
if err != nil {
return nil, fmt.Errorf("查询任务尝试失败:%w", err)
}
@@ -364,12 +399,12 @@ func (r *SQLTaskRepository) ListAttempts(ctx context.Context, taskID string) ([]
return result, nil
}
const taskSelect = `SELECT id, domain_id, task_type, status, stage, message, operator_id, certificate_version_id, idempotency_key, started_at, finished_at, created_at, updated_at FROM tasks`
const taskSelect = `SELECT 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 FROM tasks`
func scanTask(row rowScanner) (Task, error) {
var item Task
var startedAt, finishedAt sql.NullTime
if err := row.Scan(&item.ID, &item.DomainID, &item.TaskType, &item.Status, &item.Stage, &item.Message, &item.OperatorID, &item.CertificateVersionID, &item.IdempotencyKey, &startedAt, &finishedAt, &item.CreatedAt, &item.UpdatedAt); err != nil {
if err := row.Scan(&item.ID, &item.DomainID, &item.TaskType, &item.Status, &item.Stage, &item.Message, &item.OperatorID, &item.CertificateVersionID, &item.IdempotencyKey, &startedAt, &finishedAt, &item.CreatedAt, &item.UpdatedAt, &item.ScopeType, &item.ProjectID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return Task{}, sql.ErrNoRows
}
@@ -383,7 +418,7 @@ func scanTask(row rowScanner) (Task, error) {
func scanAttempt(row rowScanner) (TaskAttempt, error) {
var item TaskAttempt
var startedAt, finishedAt sql.NullTime
if err := row.Scan(&item.ID, &item.TaskID, &item.AttemptNumber, &item.Stage, &item.Status, &item.Message, &startedAt, &finishedAt, &item.CreatedAt); err != nil {
if err := row.Scan(&item.ID, &item.TaskID, &item.AttemptNumber, &item.Stage, &item.Status, &item.Message, &startedAt, &finishedAt, &item.CreatedAt, &item.ScopeType, &item.ProjectID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return TaskAttempt{}, sql.ErrNoRows
}
@@ -24,6 +24,13 @@ func newTaskRepositoryTest(t *testing.T) (*SQLTaskRepository, *sql.DB) {
db.Close()
t.Fatalf("迁移测试数据库失败:%v", err)
}
for _, id := range []string{"domain-1", "domain-2", "domain-3"} {
if _, err := db.DB.ExecContext(t.Context(), `INSERT INTO domains (id, name, certificate_type, sans_json, status)
VALUES (?, ?, 'single', '[]', 'pending')`, id, id+".example.test"); err != nil {
db.Close()
t.Fatal(err)
}
}
return NewSQLTaskRepository(db.DB), db.DB
}