保存执行租约与原子绑定复核前检查点

This commit is contained in:
xuans committed 2026-10-04 07:31:40 +08:00
1 parent 73dba287d9
commit 7a3b78daa3
28 files changed
+1236 -48

No files matched your search

@@ -211,6 +211,9 @@ func (r *SQLProjectMemberRepository) changeDNSAccount(ctx context.Context, actor
if item.Revision != revision {
return domain.DNSAccount{}, ErrDNSAccountConflict
}
if err := r.rejectActiveDNSLease(ctx, tx, "account_id", id); err != nil {
return domain.DNSAccount{}, err
}
if err := change(&item); err != nil {
return domain.DNSAccount{}, err
}
@@ -0,0 +1,185 @@
package repository
import (
"context"
"database/sql"
"errors"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
var (
ErrDNSExecutionInvalid = errors.New("DNS 执行租约或任务授权已失效")
ErrDNSAccountBusy = errors.New("DNS 账户仍有执行租约,需等待任务及挑战清理完成")
)
// 租约不设置自动到期:外部调用或清理结果不确定时必须保留秘密引用。
func (r *SQLProjectMemberRepository) AcquireDNSExecutionLease(ctx context.Context, item domain.Domain, identity domain.DNSExecutionIdentity) (domain.DNSExecutionLease, error) {
if err := r.ensureDB(); err != nil {
return domain.DNSExecutionLease{}, err
}
if item.DNSAccountID == "" || item.DNSBindingID == "" || !domain.ValidProjectID(identity.TaskID) || !domain.ValidProjectID(identity.AttemptID) || identity.AttemptNumber < 1 {
return domain.DNSExecutionLease{}, ErrDNSExecutionInvalid
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return domain.DNSExecutionLease{}, err
}
defer tx.Rollback()
lease := domain.DNSExecutionLease{ID: domain.NewID(), DomainID: item.ID, ProjectID: item.ResourceScope.Normalize().ProjectID,
BindingID: item.DNSBindingID, AccountID: item.DNSAccountID, Identity: identity}
account, err := r.authorizeDNSExecution(ctx, tx, lease)
if err != nil {
return domain.DNSExecutionLease{}, err
}
if err := r.rejectActiveDNSLease(ctx, tx, "domain_id", item.ID); err != nil {
return domain.DNSExecutionLease{}, err
}
// 域名行锁与资料更新共用,拒绝授权前后被换掉的签发快照。
var updated time.Time
if err := tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT updated_at FROM domains WHERE id = ?`), item.ID).Scan(&updated); err != nil {
return domain.DNSExecutionLease{}, err
}
if !updated.Equal(item.UpdatedAt) {
return domain.DNSExecutionLease{}, ErrDNSExecutionInvalid
}
lease.Revision, lease.Provider, lease.CredentialRef = account.Revision, account.Provider, account.CredentialRef
now := time.Now().UTC()
scheduled := 0
if identity.Scheduled {
scheduled = 1
}
_, err = tx.ExecContext(ctx, Rebind(r.driver, `INSERT INTO dns_execution_leases
(id, domain_id, binding_id, project_id, account_id, account_revision, provider, credential_ref,
task_id, attempt_id, attempt_number, scheduled, status, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)`), lease.ID, lease.DomainID, lease.BindingID,
lease.ProjectID, lease.AccountID, lease.Revision, lease.Provider, lease.CredentialRef,
identity.TaskID, identity.AttemptID, identity.AttemptNumber, scheduled, now, now)
if err != nil {
return domain.DNSExecutionLease{}, ErrDNSExecutionInvalid
}
if err := tx.Commit(); err != nil {
return domain.DNSExecutionLease{}, ErrDNSExecutionInvalid
}
return lease, nil
}
// 所有校验在短事务内完成;网络调用期间不占用数据库事务。
// 加锁顺序为域名、任务、尝试、账户,账户变更在同一账户行上串行化。
func (r *SQLProjectMemberRepository) authorizeDNSExecution(ctx context.Context, tx *sql.Tx, lease domain.DNSExecutionLease) (domain.DNSAccount, error) {
var projectID, challengeType string
var autoRenew bool
err := tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT project_id, challenge_type, auto_renew FROM domains WHERE id = ?`+r.resourceWriteLock()), lease.DomainID).Scan(&projectID, &challengeType, &autoRenew)
if err != nil || projectID != lease.ProjectID || challengeType != domain.ChallengeDNS01 {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
var bindingID, accountID string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id, dns_account_id FROM domain_dns_accounts WHERE domain_id = ? AND project_id = ?`+r.resourceWriteLock()), lease.DomainID, projectID).Scan(&bindingID, &accountID)
if err != nil || bindingID != lease.BindingID || accountID != lease.AccountID {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
var taskType, actorID, taskDomain, taskProject, taskStatus, taskScope string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT task_type, operator_id, domain_id, project_id, status, scope_type FROM tasks WHERE id = ?`+r.resourceWriteLock()), lease.Identity.TaskID).
Scan(&taskType, &actorID, &taskDomain, &taskProject, &taskStatus, &taskScope)
if err != nil || taskDomain != lease.DomainID || taskProject != projectID || taskStatus != "running" || taskScope != ScopeProject {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
var number int
var attemptTask, attemptStatus string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT task_id, attempt_number, status FROM task_attempts WHERE id = ?`+r.resourceWriteLock()), lease.Identity.AttemptID).
Scan(&attemptTask, &number, &attemptStatus)
if err != nil || attemptTask != lease.Identity.TaskID || number != lease.Identity.AttemptNumber || attemptStatus != "running" {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
if lease.Identity.Scheduled {
if taskType != "renewal_run" || actorID != "" || !autoRenew {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
} else {
if actorID == "" || (taskType != "certificate_issue" && taskType != "renewal_run") {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
permissions := []domain.ProjectPermission{domain.PermissionCertificateManage, domain.PermissionDeploymentExecute, domain.PermissionDNSCredentialUse}
if number > 1 {
permissions = append(permissions, domain.PermissionTaskRetry)
}
if err := r.authorizeProjectTransaction(ctx, tx, actorID, projectID, permissions...); err != nil {
return domain.DNSAccount{}, err
}
}
account, err := scanDNSAccount(tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT `+dnsAccountColumns+` FROM dns_accounts WHERE id = ?`+r.resourceWriteLock()), accountID))
if err != nil || account.ProjectID != projectID || account.Status != domain.DNSAccountActive || account.VerificationState != domain.DNSAccountVerified {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
if err := account.Validate(); err != nil {
return domain.DNSAccount{}, ErrDNSExecutionInvalid
}
return account, nil
}
func (r *SQLProjectMemberRepository) ValidateDNSExecutionLease(ctx context.Context, lease domain.DNSExecutionLease) error {
if err := r.ensureDB(); err != nil {
return err
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
account, err := r.authorizeDNSExecution(ctx, tx, lease)
if err != nil {
return err
}
if account.Revision != lease.Revision || account.Provider != lease.Provider || account.CredentialRef != lease.CredentialRef {
return ErrDNSExecutionInvalid
}
var id string
scheduled := 0
if lease.Identity.Scheduled {
scheduled = 1
}
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id FROM dns_execution_leases WHERE id = ? AND domain_id = ?
AND binding_id = ? AND project_id = ? AND account_id = ? AND account_revision = ? AND provider = ? AND credential_ref = ?
AND task_id = ? AND attempt_id = ? AND attempt_number = ? AND scheduled = ? AND status = 'active'`+r.resourceWriteLock()),
lease.ID, lease.DomainID, lease.BindingID, lease.ProjectID, lease.AccountID, lease.Revision, lease.Provider, lease.CredentialRef,
lease.Identity.TaskID, lease.Identity.AttemptID, lease.Identity.AttemptNumber, scheduled).Scan(&id)
if err != nil {
return ErrDNSExecutionInvalid
}
return tx.Commit()
}
// 释放只接受持有方随机能力标识,取消和撤权不能妨碍原凭据的清理收尾。
func (r *SQLProjectMemberRepository) ReleaseDNSExecutionLease(ctx context.Context, id string) error {
if err := r.ensureDB(); err != nil {
return err
}
if !domain.ValidProjectID(id) {
return ErrDNSExecutionInvalid
}
_, err := r.db.ExecContext(ctx, Rebind(r.driver, `UPDATE dns_execution_leases SET status = 'released', updated_at = ? WHERE id = ? AND status = 'active'`), time.Now().UTC(), id)
if err != nil {
return ErrDNSExecutionInvalid
}
var status string
if err := r.db.QueryRowContext(ctx, Rebind(r.driver, `SELECT status FROM dns_execution_leases WHERE id = ?`), id).Scan(&status); err != nil || status != "released" {
return ErrDNSExecutionInvalid
}
return nil
}
func (r *SQLProjectMemberRepository) rejectActiveDNSLease(ctx context.Context, tx *sql.Tx, column, id string) error {
if column != "account_id" && column != "domain_id" {
return ErrDNSExecutionInvalid
}
var active string
err := tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id FROM dns_execution_leases WHERE `+column+` = ? AND status = 'active' LIMIT 1`+r.resourceWriteLock()), id).Scan(&active)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
return err
}
return ErrDNSAccountBusy
}
@@ -0,0 +1,325 @@
package repository
import (
"context"
"database/sql"
"errors"
"path/filepath"
"sync"
"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"
"git.pcux.cn/xuans/Scert/backend/internal/testsupport/postgrestest"
)
type dnsLeaseFixture struct {
repo *SQLProjectMemberRepository
db *sql.DB
driver string
item domain.Domain
account domain.DNSAccount
identity domain.DNSExecutionIdentity
}
func (f dnsLeaseFixture) exec(t *testing.T, query string, args ...any) {
t.Helper()
if _, err := f.db.ExecContext(t.Context(), Rebind(f.driver, query), args...); err != nil {
t.Fatal(err)
}
}
func newDNSLeaseFixture(t *testing.T, db *sql.DB, driver string) dnsLeaseFixture {
t.Helper()
repo := NewSQLProjectMemberRepository(db, driver)
item, err := domain.NewDomain(domain.NewID()+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ProjectID = domain.NewID()
if err := NewSQLProjectRepository(db, driver).CreateProject(t.Context(), domain.Project{ID: item.ProjectID, Name: "租约测试"}); err != nil {
t.Fatal(err)
}
if err := repo.GrantProjectRole(t.Context(), "lease-root", item.ProjectID, "lease-manager", domain.ProjectRoleAdmin); err != nil {
t.Fatal(err)
}
if err := repo.CreateProjectDomain(t.Context(), "lease-root", item); err != nil {
t.Fatal(err)
}
account, err := repo.CreateDNSAccount(t.Context(), "lease-root", domain.DNSAccount{ID: domain.NewID(), Name: "租约账户", ProjectID: item.ProjectID, Provider: "cloudflare", CredentialRef: "secret://dns/" + domain.NewID()})
if err != nil {
t.Fatal(err)
}
account, err = repo.RecordDNSAccountVerification(t.Context(), "lease-root", account.ID, account.Revision, true)
if err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "lease-root", item.ID, account.ID, "", account.Revision); err != nil {
t.Fatal(err)
}
item, err = NewSQLDomainRepository(db, driver).GetByID(t.Context(), item.ID)
if err != nil {
t.Fatal(err)
}
identity := domain.DNSExecutionIdentity{TaskID: domain.NewID(), AttemptID: domain.NewID(), AttemptNumber: 1}
tasks := NewSQLTaskRepository(db, driver)
if err := tasks.CreateTask(t.Context(), Task{ID: identity.TaskID, DomainID: item.ID, TaskType: "certificate_issue", Status: "running", Stage: "certificate_issue", OperatorID: "lease-manager"}); err != nil {
t.Fatal(err)
}
if err := tasks.CreateAttempt(t.Context(), TaskAttempt{ID: identity.AttemptID, TaskID: identity.TaskID, AttemptNumber: 1, Status: "running", Stage: "certificate_issue"}); err != nil {
t.Fatal(err)
}
return dnsLeaseFixture{repo: repo, db: db, driver: driver, item: item, account: account, identity: identity}
}
func TestDNSExecutionLeaseRepository(t *testing.T) {
for _, driver := range []string{"sqlite", "mysql", "postgres"} {
t.Run(driver, func(t *testing.T) {
cfg := config.Default(t.TempDir()).Database
cfg.DSN = filepath.Join(t.TempDir(), "dns-leases.db")
if driver == "mysql" {
cfg = mysqltest.New(t).Database(t)
}
if driver == "postgres" {
cfg = postgrestest.New(t).Database(t)
}
db, err := database.Open(t.Context(), cfg)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if err := database.Migrate(t.Context(), db.DB, driver); err != nil {
t.Fatal(err)
}
for id, role := range map[string]string{"lease-root": "super_admin", "lease-manager": "user"} {
if _, err := db.DB.ExecContext(t.Context(), Rebind(driver, `INSERT INTO users (id, username, password_hash, role, status) VALUES (?, ?, 'test-only', ?, 'active')`), id, id, role); err != nil {
t.Fatal(err)
}
}
t.Run("lifecycle", func(t *testing.T) {
f := newDNSLeaseFixture(t, db.DB, driver)
lease, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity)
if err != nil {
t.Fatal(err)
}
if lease.Provider != "cloudflare" || lease.AccountID != f.account.ID || lease.CredentialRef == "" || lease.Revision != f.account.Revision {
t.Fatal("租约未固定实际账户")
}
if err := f.repo.ValidateDNSExecutionLease(t.Context(), lease); err != nil {
t.Fatal(err)
}
if _, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity); err == nil {
t.Fatal("重复获取未拒绝")
}
for _, mutate := range []func() error{
func() error {
_, err := f.repo.RotateDNSAccountCredential(t.Context(), "lease-root", f.account.ID, f.account.Revision, "secret://dns/rotated")
return err
},
func() error {
_, err := f.repo.SetDNSAccountEnabled(t.Context(), "lease-root", f.account.ID, f.account.Revision, false)
return err
},
func() error {
_, err := f.repo.SetDomainDNSAccountBinding(t.Context(), "lease-root", f.item.ID, "", f.item.DNSBindingID, 0)
return err
},
func() error { return f.repo.UpdateProjectDomain(t.Context(), "lease-root", f.item) },
} {
if err := mutate(); !errors.Is(err, ErrDNSAccountBusy) {
t.Fatal("活动租约未阻止变更", err)
}
}
f.exec(t, `UPDATE tasks SET status = 'failed' WHERE id = ?`, f.identity.TaskID)
if err := f.repo.DeleteProjectDomain(t.Context(), "lease-root", f.item.ID); !errors.Is(err, ErrDNSAccountBusy) {
t.Fatal("终态任务仍有租约,不能删除域名", err)
}
if err := f.repo.ValidateDNSExecutionLease(t.Context(), lease); err == nil {
t.Fatal("终态任务仍允许发起 DNS 操作")
}
cancelled, cancel := context.WithCancel(t.Context())
cancel()
if err := f.repo.ReleaseDNSExecutionLease(cancelled, lease.ID); err == nil {
t.Fatal("取消的释放应失败")
}
if _, err := f.repo.SetDNSAccountEnabled(t.Context(), "lease-root", f.account.ID, f.account.Revision, false); !errors.Is(err, ErrDNSAccountBusy) {
t.Fatal("释放失败不能丢失引用", err)
}
if err := f.repo.ReleaseDNSExecutionLease(t.Context(), lease.ID); err != nil {
t.Fatal(err)
}
if err := f.repo.ReleaseDNSExecutionLease(t.Context(), lease.ID); err != nil {
t.Fatal("释放应幂等", err)
}
if _, err := f.repo.SetDNSAccountEnabled(t.Context(), "lease-root", f.account.ID, f.account.Revision, false); err != nil {
t.Fatal("正常释放后应允许禁用", err)
}
})
t.Run("atomic-initial-binding", func(t *testing.T) {
f := newDNSLeaseFixture(t, db.DB, driver)
for _, scenario := range []string{"success", "old-revision", "wrong-provider", "duplicate-binding", "foreign-project", "http-challenge", "missing-account"} {
t.Run(scenario, func(t *testing.T) {
item, err := domain.NewDomain(domain.NewID()+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ProjectID, item.DNSProvider = f.item.ProjectID, "cloudflare"
item.DNSAccountID, item.DNSBindingID, item.InitialDNSRevision = f.account.ID, domain.NewID(), f.account.Revision
switch scenario {
case "old-revision":
item.InitialDNSRevision--
case "wrong-provider":
item.DNSProvider = "aliyun"
case "duplicate-binding":
item.DNSBindingID = f.item.DNSBindingID
case "foreign-project":
item.ProjectID = domain.DefaultProjectID
case "http-challenge":
item.ChallengeType = domain.ChallengeHTTP01
case "missing-account":
item.DNSAccountID = "missing"
}
err = f.repo.CreateProjectDomain(t.Context(), "lease-root", item)
if (err == nil) != (scenario == "success") {
t.Fatal("原子创建结果不符", err)
}
var count int
if err := db.DB.QueryRowContext(t.Context(), Rebind(driver, `SELECT COUNT(*) FROM domains WHERE id = ?`), item.ID).Scan(&count); err != nil {
t.Fatal(err)
}
if scenario != "success" && count != 0 {
t.Fatal("绑定失败遗留未绑定域名")
}
if scenario == "success" {
loaded, err := NewSQLDomainRepository(db.DB, driver).GetByID(t.Context(), item.ID)
if err != nil || loaded.DNSAccountID != item.DNSAccountID || loaded.DNSBindingID != item.DNSBindingID {
t.Fatal("创建后绑定不可见", err)
}
} else {
if err := db.DB.QueryRowContext(t.Context(), Rebind(driver, `SELECT COUNT(*) FROM audit_logs WHERE resource_id = ?`), item.ID).Scan(&count); err != nil || count != 0 {
t.Fatal("失败创建遗留成功审计", err)
}
}
})
}
})
for _, scenario := range []string{"missing-task", "wrong-attempt", "wrong-number", "cancelled-task", "finished-attempt", "wrong-project", "revoked", "anonymous", "fake-scheduler", "disabled", "unverified", "stale-binding", "stale-snapshot", "retry-without-permission"} {
t.Run(scenario, func(t *testing.T) {
f := newDNSLeaseFixture(t, db.DB, driver)
switch scenario {
case "missing-task":
f.identity.TaskID = "missing"
case "wrong-attempt":
f.identity.AttemptID = "missing"
case "wrong-number":
f.identity.AttemptNumber = 2
case "cancelled-task":
f.exec(t, `UPDATE tasks SET status = 'cancelling' WHERE id = ?`, f.identity.TaskID)
case "finished-attempt":
f.exec(t, `UPDATE task_attempts SET status = 'failed' WHERE id = ?`, f.identity.AttemptID)
case "wrong-project":
f.item.ProjectID = domain.DefaultProjectID
case "revoked":
f.exec(t, `DELETE FROM project_members WHERE project_id = ?`, f.item.ProjectID)
case "anonymous":
f.exec(t, `UPDATE tasks SET operator_id = '' WHERE id = ?`, f.identity.TaskID)
case "fake-scheduler":
f.identity.Scheduled = true
case "disabled":
_, err = f.repo.SetDNSAccountEnabled(t.Context(), "lease-root", f.account.ID, f.account.Revision, false)
case "unverified":
_, err = f.repo.RecordDNSAccountVerification(t.Context(), "lease-root", f.account.ID, f.account.Revision, false)
case "stale-binding":
f.item.DNSBindingID = "old-binding"
case "stale-snapshot":
f.item.UpdatedAt = f.item.UpdatedAt.Add(-time.Hour)
case "retry-without-permission":
f.identity.AttemptNumber = 2
f.exec(t, `UPDATE task_attempts SET attempt_number = 2 WHERE id = ?`, f.identity.AttemptID)
f.exec(t, `DELETE FROM project_members WHERE project_id = ?`, f.item.ProjectID)
}
if err != nil {
t.Fatal(err)
}
if _, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity); err == nil {
t.Fatal("无效身份或状态获得租约")
}
})
}
t.Run("scheduled-and-revalidation", func(t *testing.T) {
f := newDNSLeaseFixture(t, db.DB, driver)
f.exec(t, `UPDATE tasks SET operator_id = '', task_type = 'renewal_run' WHERE id = ?`, f.identity.TaskID)
if _, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity); err == nil {
t.Fatal("空操作者不能隐式成为调度器")
}
f.identity.Scheduled = true
lease, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity)
if err != nil {
t.Fatal(err)
}
forged := lease
forged.CredentialRef = "secret://dns/other"
if err := f.repo.ValidateDNSExecutionLease(t.Context(), forged); err == nil {
t.Fatal("篡改租约未拒绝")
}
f.exec(t, `UPDATE domains SET auto_renew = ? WHERE id = ?`, false, f.item.ID)
if err := f.repo.ValidateDNSExecutionLease(t.Context(), lease); err == nil {
t.Fatal("关闭续期后仍允许 DNS 写入")
}
if err := f.repo.ReleaseDNSExecutionLease(t.Context(), lease.ID); err != nil {
t.Fatal(err)
}
})
t.Run("revocation-after-acquire", func(t *testing.T) {
f := newDNSLeaseFixture(t, db.DB, driver)
lease, err := f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity)
if err != nil {
t.Fatal(err)
}
f.exec(t, `DELETE FROM project_members WHERE project_id = ?`, f.item.ProjectID)
if err := f.repo.ValidateDNSExecutionLease(t.Context(), lease); err == nil {
t.Fatal("撤权后仍允许 DNS 写入")
}
if err := f.repo.ReleaseDNSExecutionLease(t.Context(), lease.ID); err != nil {
t.Fatal("撤权不应阻止清理收尾", err)
}
})
t.Run("rotation-race", func(t *testing.T) {
for round := 0; round < 5; round++ {
f := newDNSLeaseFixture(t, db.DB, driver)
start := make(chan struct{})
var wg sync.WaitGroup
wg.Add(2)
var lease domain.DNSExecutionLease
var acquireErr, rotateErr error
go func() {
defer wg.Done()
<-start
lease, acquireErr = f.repo.AcquireDNSExecutionLease(t.Context(), f.item, f.identity)
}()
go func() {
defer wg.Done()
<-start
_, rotateErr = f.repo.RotateDNSAccountCredential(t.Context(), "lease-root", f.account.ID, f.account.Revision, "secret://dns/"+domain.NewID())
}()
close(start)
wg.Wait()
if acquireErr == nil && rotateErr == nil {
t.Fatal("获取租约与轮换不能同时成功")
}
if acquireErr == nil {
if err := f.repo.ValidateDNSExecutionLease(t.Context(), lease); err != nil {
t.Fatal("获胜租约失效", err)
}
if err := f.repo.ReleaseDNSExecutionLease(t.Context(), lease.ID); err != nil {
t.Fatal(err)
}
}
}
})
})
}
}
@@ -79,6 +79,9 @@ func (r *SQLProjectMemberRepository) SetDomainDNSAccountBinding(ctx context.Cont
if currentID != expectedID {
return domain.DNSAccountBinding{}, ErrDNSBindingConflict
}
if err := r.rejectActiveDNSLease(ctx, tx, "domain_id", domainID); err != nil {
return domain.DNSAccountBinding{}, err
}
// 与任务创建持有同一域名行锁,避免检查后插入新任务并使用旧绑定。
var activeID string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id FROM tasks WHERE domain_id = ?
@@ -0,0 +1,40 @@
package repository
import (
"context"
"database/sql"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
// 创建域名与初始 DNS 绑定共用一个事务,自动续期看不到未绑定的中间状态。
func (r *SQLProjectMemberRepository) validateInitialDNSBinding(ctx context.Context, tx *sql.Tx, actorID string, item domain.Domain, challengeType string) error {
if item.DNSAccountID == "" {
if item.DNSBindingID != "" || item.InitialDNSRevision != 0 {
return ErrDNSBindingInvalid
}
return nil
}
if !domain.ValidProjectID(item.DNSAccountID) || !domain.ValidProjectID(item.DNSBindingID) || item.InitialDNSRevision < 1 || challengeType != domain.ChallengeDNS01 {
return ErrDNSBindingInvalid
}
if err := r.authorizeProjectTransaction(ctx, tx, actorID, item.ProjectID, domain.PermissionDNSCredentialUse); err != nil {
return err
}
var projectID, provider, status, verification string
var revision int64
if err := tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT project_id, provider, status, verification_state, revision FROM dns_accounts WHERE id = ?`+r.resourceWriteLock()), item.DNSAccountID).
Scan(&projectID, &provider, &status, &verification, &revision); err != nil {
return ErrDNSBindingInvalid
}
if projectID != item.ProjectID {
return ErrProjectAccessDenied
}
if revision != item.InitialDNSRevision {
return ErrDNSAccountConflict
}
if provider != item.DNSProvider || status != domain.DNSAccountActive || verification != domain.DNSAccountVerified {
return ErrDNSBindingInvalid
}
return nil
}
@@ -36,6 +36,9 @@ func (r *SQLProjectMemberRepository) CreateProjectDomain(ctx context.Context, ac
if err := r.authorizeProjectTransaction(ctx, tx, actorID, item.ProjectID, domain.PermissionCertificateManage); err != nil {
return err
}
if err := r.validateInitialDNSBinding(ctx, tx, actorID, item, challengeType); err != nil {
return err
}
_, err = tx.ExecContext(ctx, Rebind(r.driver, `INSERT INTO domains
(id, name, certificate_type, sans_json, auto_renew, acme_environment, dns_provider, status, expires_at, created_at, updated_at, project_id, owner_id, created_by, updated_by, challenge_type)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), item.ID, item.Name, item.CertificateType, string(payload), item.AutoRenew,
@@ -47,6 +50,15 @@ func (r *SQLProjectMemberRepository) CreateProjectDomain(ctx context.Context, ac
if err := writeDomainAudit(ctx, tx, r.driver, "domain.create", item.ID, item.ProjectID, actorID, "创建域名"); err != nil {
return err
}
if item.DNSAccountID != "" {
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `INSERT INTO domain_dns_accounts (domain_id, id, project_id, dns_account_id, updated_at) VALUES (?, ?, ?, ?, ?)`),
item.ID, item.DNSBindingID, item.ProjectID, item.DNSAccountID, item.UpdatedAt); err != nil {
return err
}
if err := writeDomainAudit(ctx, tx, r.driver, "domain.dns_account", item.ID, item.ProjectID, actorID, "创建域名时绑定 DNS 账户"); err != nil {
return err
}
}
return commitProjectDomain(tx, "提交域名创建事务失败")
}
@@ -77,6 +89,9 @@ func (r *SQLProjectMemberRepository) UpdateProjectDomain(ctx context.Context, ac
return err
}
item.ProjectID = stored.ProjectID
if err := r.rejectActiveDNSLease(ctx, tx, "domain_id", item.ID); err != nil {
return err
}
if err := r.validateDomainPathsInTransaction(ctx, tx, item); err != nil {
return err
}
@@ -133,6 +148,9 @@ func (r *SQLProjectMemberRepository) DeleteProjectDomain(ctx context.Context, ac
if busy {
return ErrProjectDomainBusy
}
if err := r.rejectActiveDNSLease(ctx, tx, "domain_id", domainID); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domain_servers WHERE domain_id = ?`), domainID); err != nil {
return fmt.Errorf("删除域名服务器关联失败:%w", err)
}