增加域名 DNS 账户绑定与引用保护并修复并发冲突分类

This commit is contained in:
xuans committed 2026-10-04 05:35:11 +08:00
1 parent 1dc72f2b44
commit 7a6da6b2c9
25 files changed
+966 -24

No files matched your search

@@ -222,6 +222,9 @@ func (r *SQLProjectMemberRepository) changeDNSAccount(ctx context.Context, actor
result, err := tx.ExecContext(ctx, Rebind(r.driver, `UPDATE dns_accounts SET name = ?, credential_ref = ?, status = ?, verification_state = ?, revision = ?, updated_at = ? WHERE id = ? AND revision = ?`),
item.Name, item.CredentialRef, item.Status, item.VerificationState, item.Revision, item.UpdatedAt, item.ID, revision)
if err != nil {
if r.driver == "sqlite" && isSQLiteWriteConflict(err) {
return domain.DNSAccount{}, ErrDNSAccountConflict
}
return domain.DNSAccount{}, errors.New("更新 DNS 账户失败,请检查凭据引用是否重复")
}
if count, err := result.RowsAffected(); err != nil || count != 1 {
@@ -236,6 +239,16 @@ func (r *SQLProjectMemberRepository) changeDNSAccount(ctx context.Context, actor
return publicDNSAccount(item), nil
}
// 使用驱动错误码识别忙与锁冲突,不依赖可能包含秘密或本地化文本的错误消息。
func isSQLiteWriteConflict(err error) bool {
var coded interface{ Code() int }
if !errors.As(err, &coded) {
return false
}
code := coded.Code() & 0xff
return code == 5 || code == 6
}
func writeDNSAccountAudit(ctx context.Context, tx *sql.Tx, driver, actorID string, item domain.DNSAccount, action string) error {
result, err := tx.ExecContext(ctx, Rebind(driver, `INSERT INTO audit_logs
(action, resource_type, resource_id, status, message, created_at, scope_type, project_id, task_id, operator_id)
@@ -0,0 +1,152 @@
package repository
import (
"context"
"database/sql"
"errors"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
var (
ErrDNSBindingConflict = errors.New("域名 DNS 账户绑定已变更,请刷新后重试")
ErrDNSBindingBusy = errors.New("域名存在未结束的任务,暂不能变更 DNS 账户")
ErrDNSBindingInvalid = errors.New("域名验证方式或 DNS 账户状态不允许绑定")
)
type DomainDNSAccountRepository interface {
GetDomainDNSAccountBinding(context.Context, string, string) (domain.DNSAccountBinding, error)
SetDomainDNSAccountBinding(context.Context, string, string, string, string, int64) (domain.DNSAccountBinding, error)
}
var _ DomainDNSAccountRepository = (*SQLProjectMemberRepository)(nil)
func (r *SQLProjectMemberRepository) GetDomainDNSAccountBinding(ctx context.Context, actorID, domainID string) (domain.DNSAccountBinding, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return domain.DNSAccountBinding{}, err
}
predicate, args := resourceReadPredicate("domains.project_id", actorID, domain.PermissionCertificateRead)
args = append(args, domainID)
var result domain.DNSAccountBinding
var id, accountID sql.NullString
var updated sql.NullTime
err := r.db.QueryRowContext(ctx, Rebind(r.driver, `SELECT domains.id, domains.project_id, binding.id, binding.dns_account_id, binding.updated_at
FROM domains LEFT JOIN domain_dns_accounts binding ON binding.domain_id = domains.id AND binding.project_id = domains.project_id
WHERE `+predicate+` AND domains.id = ?`), args...).Scan(&result.DomainID, &result.ProjectID, &id, &accountID, &updated)
if errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccountBinding{}, ErrProjectAccessDenied
}
if err != nil {
return domain.DNSAccountBinding{}, err
}
result.ID, result.DNSAccountID, result.UpdatedAt = id.String, accountID.String, updated.Time
return result, nil
}
// 空账户表示显式解除;expectedID 为空只允许首次绑定。凭据版本和旧绑定同时参与校验。
// 这里只变更配置,不授予签发权限;执行阶段必须再次获得实际凭据租约。
func (r *SQLProjectMemberRepository) SetDomainDNSAccountBinding(ctx context.Context, actorID, domainID, accountID, expectedID string, accountRevision int64) (domain.DNSAccountBinding, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return domain.DNSAccountBinding{}, err
}
if !domain.ValidProjectID(domainID) || (accountID != "" && (!domain.ValidProjectID(accountID) || accountRevision < 1)) || (expectedID != "" && !domain.ValidProjectID(expectedID)) {
return domain.DNSAccountBinding{}, ErrDNSBindingInvalid
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return domain.DNSAccountBinding{}, err
}
defer tx.Rollback()
var result domain.DNSAccountBinding
result.DomainID = domainID
var challengeType string
if err := tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT project_id, challenge_type FROM domains WHERE id = ?`+r.resourceWriteLock()), domainID).Scan(&result.ProjectID, &challengeType); err != nil {
return domain.DNSAccountBinding{}, projectBindingReadError(err)
}
permissions := []domain.ProjectPermission{domain.PermissionCertificateManage}
if accountID != "" {
permissions = append(permissions, domain.PermissionDNSCredentialUse)
}
if err := r.authorizeProjectTransaction(ctx, tx, actorID, result.ProjectID, permissions...); err != nil {
return domain.DNSAccountBinding{}, err
}
var currentID string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id FROM domain_dns_accounts WHERE domain_id = ?`+r.resourceWriteLock()), domainID).Scan(&currentID)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccountBinding{}, err
}
if currentID != expectedID {
return domain.DNSAccountBinding{}, ErrDNSBindingConflict
}
// 与任务创建持有同一域名行锁,避免检查后插入新任务并使用旧绑定。
var activeID string
err = tx.QueryRowContext(ctx, Rebind(r.driver, `SELECT id FROM tasks WHERE domain_id = ?
AND status IN ('queued', 'running', 'retry_wait', 'cancelling') LIMIT 1`+r.resourceWriteLock()), domainID).Scan(&activeID)
if err == nil {
return domain.DNSAccountBinding{}, ErrDNSBindingBusy
}
if !errors.Is(err, sql.ErrNoRows) {
return domain.DNSAccountBinding{}, err
}
provider := ""
if accountID != "" {
if challengeType != domain.ChallengeDNS01 {
return domain.DNSAccountBinding{}, ErrDNSBindingInvalid
}
var projectID, 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()), accountID).Scan(&projectID, &provider, &status, &verification, &revision); err != nil {
return domain.DNSAccountBinding{}, projectBindingReadError(err)
}
if projectID != result.ProjectID {
return domain.DNSAccountBinding{}, ErrProjectAccessDenied
}
if revision != accountRevision {
return domain.DNSAccountBinding{}, ErrDNSAccountConflict
}
if status != domain.DNSAccountActive || verification != domain.DNSAccountVerified {
return domain.DNSAccountBinding{}, ErrDNSBindingInvalid
}
result.ID, result.DNSAccountID = domain.NewID(), accountID
}
result.UpdatedAt = time.Now().UTC()
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domain_dns_accounts WHERE domain_id = ?`), domainID); err != nil {
return domain.DNSAccountBinding{}, err
}
if accountID != "" {
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `INSERT INTO domain_dns_accounts (domain_id, id, project_id, dns_account_id, updated_at)
VALUES (?, ?, ?, ?, ?)`), domainID, result.ID, result.ProjectID, accountID, result.UpdatedAt); err != nil {
return domain.DNSAccountBinding{}, err
}
}
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `UPDATE domains SET dns_provider = ?, updated_at = ?, updated_by = ? WHERE id = ?`), provider, result.UpdatedAt, actorID, domainID); err != nil {
return domain.DNSAccountBinding{}, err
}
if err := writeDomainAudit(ctx, tx, r.driver, "domain.dns_account", domainID, result.ProjectID, actorID, "更新域名 DNS 账户绑定"); err != nil {
return domain.DNSAccountBinding{}, err
}
if err := tx.Commit(); err != nil {
return domain.DNSAccountBinding{}, err
}
return result, nil
}
// 普通域名编辑不能绕过独立绑定修改服务商或切换验证方式;须先显式解除绑定。
func validateBoundDomainDNS(ctx context.Context, tx *sql.Tx, driver string, item domain.Domain, challengeType string) error {
var provider string
err := tx.QueryRowContext(ctx, Rebind(driver, `SELECT account.provider FROM domain_dns_accounts binding
JOIN dns_accounts account ON account.id = binding.dns_account_id AND account.project_id = binding.project_id
WHERE binding.domain_id = ?`), item.ID).Scan(&provider)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
return err
}
if challengeType != domain.ChallengeDNS01 || item.DNSProvider != provider {
return ErrDNSBindingInvalid
}
return nil
}
@@ -0,0 +1,252 @@
package repository
import (
"database/sql"
"errors"
"path/filepath"
"strings"
"sync"
"testing"
"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"
)
func TestDomainDNSAccountRepository(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(), "domain-dns.db")
var admin *sql.DB
if driver == "mysql" {
server := mysqltest.New(t)
cfg, admin = server.Database(t), server.Admin()
}
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)
}
checkDomainDNSAccountRepository(t, db.DB, admin, driver)
})
}
}
func checkDomainDNSAccountRepository(t *testing.T, db, admin *sql.DB, driver string) {
t.Helper()
repo := NewSQLProjectMemberRepository(db, driver)
domains := NewSQLDomainRepository(db, driver)
for _, actor := range []struct{ id, role string }{{"root", "super_admin"}, {"manager", "user"}, {"cert", "user"}, {"dns", "user"}, {"reader", "user"}, {"outsider", "admin"}} {
if _, err := db.ExecContext(t.Context(), Rebind(driver, `INSERT INTO users (id, username, password_hash, role, status) VALUES (?, ?, 'test-only', ?, 'active')`), actor.id, actor.id, actor.role); err != nil {
t.Fatal(err)
}
}
for _, id := range []string{"binding-a", "binding-b"} {
if err := NewSQLProjectRepository(db, driver).CreateProject(t.Context(), domain.Project{ID: id, Name: "绑定测试"}); err != nil {
t.Fatal(err)
}
}
for actor, role := range map[string]domain.ProjectRole{"manager": domain.ProjectRoleAdmin, "cert": domain.ProjectRoleCertificateAdmin, "dns": domain.ProjectRoleDNSAdmin, "reader": domain.ProjectRoleReadOnly} {
if err := repo.GrantProjectRole(t.Context(), "root", "binding-a", actor, role); err != nil {
t.Fatal(err)
}
}
makeDomain := func(id string) domain.Domain {
t.Helper()
item, err := domain.NewDomain(id+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ID, item.ProjectID = id, "binding-a"
if err := repo.CreateProjectDomain(t.Context(), "root", item); err != nil {
t.Fatal(err)
}
return item
}
item := makeDomain("bound-domain")
second := makeDomain("second-domain")
accounts := make(map[string]domain.DNSAccount)
for _, id := range []string{"account-a", "account-b", "foreign-account"} {
projectID := "binding-a"
if id == "foreign-account" {
projectID = "binding-b"
}
account, err := repo.CreateDNSAccount(t.Context(), "root", domain.DNSAccount{ID: id, Name: "测试账户", ProjectID: projectID, Provider: "cloudflare", CredentialRef: "secret://dns/" + id})
if err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, id, "", account.Revision); err == nil {
t.Fatal("未验证账户不应允许绑定")
}
account, err = repo.RecordDNSAccountVerification(t.Context(), "root", id, account.Revision, true)
if err != nil {
t.Fatal(err)
}
accounts[id] = account
}
a := accounts["account-a"]
httpItem := makeDomain("http-domain")
httpItem.ChallengeType = domain.ChallengeHTTP01
if err := repo.UpdateProjectDomain(t.Context(), "root", httpItem); err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", httpItem.ID, a.ID, "", a.Revision); !errors.Is(err, ErrDNSBindingInvalid) {
t.Fatal("HTTP 验证域名不应绑定 DNS 账户", err)
}
disabled, err := repo.SetDNSAccountEnabled(t.Context(), "root", "account-b", accounts["account-b"].Revision, false)
if err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, disabled.ID, "", disabled.Revision); !errors.Is(err, ErrDNSBindingInvalid) {
t.Fatal("禁用账户不应允许新绑定", err)
}
for _, actor := range []string{"", "missing", "cert", "dns", "reader", "outsider"} {
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), actor, item.ID, a.ID, "", a.Revision); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("角色 %s 越权绑定未拒绝:%v", actor, err)
}
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, "foreign-account", "", 2); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("超级管理员也不能跨项目绑定", err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "manager", item.ID, a.ID, "", a.Revision-1); !errors.Is(err, ErrDNSAccountConflict) {
t.Fatal("旧凭据版本未拒绝", err)
}
binding, err := repo.SetDomainDNSAccountBinding(t.Context(), "manager", item.ID, a.ID, "", a.Revision)
if err != nil || binding.ID == "" || binding.ProjectID != item.ProjectID || binding.DNSAccountID != a.ID {
t.Fatal("绑定失败", binding, err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", second.ID, a.ID, "", a.Revision); err != nil {
t.Fatal("同一账户应允许绑定多个域名", err)
}
for _, read := range []func() (domain.Domain, error){
func() (domain.Domain, error) { return domains.GetByID(t.Context(), item.ID) },
func() (domain.Domain, error) { return repo.GetVisibleDomain(t.Context(), "cert", item.ID) },
} {
stored, err := read()
if err != nil || stored.DNSAccountID != a.ID || stored.DNSBindingID != binding.ID || stored.DNSProvider != a.Provider {
t.Fatal("域名查询遗漏真实绑定", stored, err)
}
}
if read, err := repo.GetDomainDNSAccountBinding(t.Context(), "reader", item.ID); err != nil || read.ID != binding.ID {
t.Fatal("同项目只读账户应能查看绑定元数据", err)
}
if _, err := repo.GetDomainDNSAccountBinding(t.Context(), "outsider", item.ID); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("外项目不应查看绑定", err)
}
item.DNSProvider = a.Provider
item.ChallengeType = domain.ChallengeHTTP01
if err := repo.UpdateProjectDomain(t.Context(), "manager", item); !errors.Is(err, ErrDNSBindingInvalid) {
t.Fatal("普通编辑绕过绑定切换验证方式", err)
}
if err := domains.Update(t.Context(), item); !errors.Is(err, ErrDNSBindingInvalid) {
t.Fatal("基础仓储绕过绑定切换验证方式", err)
}
item.ChallengeType = domain.ChallengeDNS01
item.DNSProvider = "aliyun"
if err := repo.UpdateProjectDomain(t.Context(), "manager", item); !errors.Is(err, ErrDNSBindingInvalid) {
t.Fatal("普通编辑绕过绑定切换服务商", err)
}
item.DNSProvider = a.Provider
if err := repo.UpdateProjectDomain(t.Context(), "manager", item); err != nil {
t.Fatal("合法编辑不能破坏绑定", err)
}
for _, status := range []string{"queued", "running", "retry_wait", "cancelling"} {
if _, err := db.ExecContext(t.Context(), Rebind(driver, `INSERT INTO tasks (id,domain_id,task_type,status,message) VALUES ('binding-task',?,'certificate_issue',?,'')`), item.ID, status); err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, "", binding.ID, 0); !errors.Is(err, ErrDNSBindingBusy) {
t.Fatal("活动任务未阻止解除绑定", status, err)
}
if _, err := db.ExecContext(t.Context(), `DELETE FROM tasks WHERE id='binding-task'`); err != nil {
t.Fatal(err)
}
}
// 同一个旧绑定令牌只能有一个并发写入成功;数据库忙或冲突均不能绕过条件重试。
var wg sync.WaitGroup
results := make(chan error, 2)
for range 2 {
wg.Add(1)
go func() {
defer wg.Done()
_, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, a.ID, binding.ID, a.Revision)
results <- err
}()
}
wg.Wait()
close(results)
winners := 0
for err := range results {
if err == nil {
winners++
}
}
if winners != 1 {
t.Fatal("同一绑定条件应只有一个成功者", winners)
}
current, err := repo.GetDomainDNSAccountBinding(t.Context(), "root", item.ID)
if err != nil || current.ID == binding.ID {
t.Fatal("绑定令牌未变化", err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, "", binding.ID, 0); !errors.Is(err, ErrDNSBindingConflict) {
t.Fatal("旧绑定仍可解除", err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "cert", item.ID, "", current.ID, 0); err != nil {
t.Fatal("证书管理员无法显式解除绑定", err)
}
rebound, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, a.ID, "", a.Revision)
if err != nil || rebound.ID == current.ID || rebound.ID == binding.ID {
t.Fatal("解除后重绑重复使用旧令牌", err)
}
if _, err := db.ExecContext(t.Context(), Rebind(driver, `DELETE FROM dns_accounts WHERE id=?`), a.ID); err == nil {
t.Fatal("引用账户被直接删除")
}
if err := repo.DeleteProjectDomain(t.Context(), "root", second.ID); err != nil {
t.Fatal("删除域名没有同时解除引用", err)
}
if _, err := repo.GetVisibleDNSAccount(t.Context(), "root", a.ID); err != nil {
t.Fatal("删除域名误删账户", err)
}
if err := repo.RevokeProjectRole(t.Context(), "root", "binding-a", "manager", domain.ProjectRoleAdmin); err != nil {
t.Fatal(err)
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "manager", item.ID, "", rebound.ID, 0); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatal("撤权后仍可修改绑定", err)
}
// 故障注入只对隔离库使用管理连接,不扩大应用账户权限。
executor := db
statements := []string{`CREATE TRIGGER reject_binding_audit BEFORE INSERT ON audit_logs BEGIN SELECT RAISE(ABORT, 'blocked'); END`}
if driver == "mysql" {
var schema string
if err := db.QueryRowContext(t.Context(), "SELECT DATABASE()").Scan(&schema); err != nil {
t.Fatal(err)
}
schema = "`" + strings.ReplaceAll(schema, "`", "``") + "`"
executor = admin
statements = []string{`CREATE TRIGGER ` + schema + `.reject_binding_audit BEFORE INSERT ON ` + schema + `.audit_logs FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='blocked'`}
} else if driver == "postgres" {
statements = []string{`CREATE FUNCTION reject_binding_audit() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'blocked'; END $$`, `CREATE TRIGGER reject_binding_audit BEFORE INSERT ON audit_logs FOR EACH ROW EXECUTE FUNCTION reject_binding_audit()`}
}
for _, statement := range statements {
if _, err := executor.ExecContext(t.Context(), statement); err != nil {
t.Fatal(err)
}
}
if _, err := repo.SetDomainDNSAccountBinding(t.Context(), "root", item.ID, "", rebound.ID, 0); err == nil {
t.Fatal("审计失败仍修改绑定")
}
if err := repo.DeleteProjectDomain(t.Context(), "root", item.ID); err == nil {
t.Fatal("审计失败仍删除域名")
}
if stored, err := repo.GetDomainDNSAccountBinding(t.Context(), "root", item.ID); err != nil || stored.ID != rebound.ID {
t.Fatal("审计失败未恢复绑定", err)
}
}
@@ -84,6 +84,9 @@ func (r *SQLProjectMemberRepository) UpdateProjectDomain(ctx context.Context, ac
if err != nil {
return err
}
if err := validateBoundDomainDNS(ctx, tx, r.driver, item, challengeType); err != nil {
return err
}
result, err := tx.ExecContext(ctx, Rebind(r.driver, `UPDATE domains SET
name = ?, certificate_type = ?, sans_json = ?, auto_renew = ?, acme_environment = ?, dns_provider = ?, updated_at = ?, updated_by = ?, challenge_type = ?
WHERE id = ? AND project_id = ?`), item.Name, item.CertificateType, string(payload), item.AutoRenew, item.ACMEEnvironment,
@@ -133,6 +136,9 @@ func (r *SQLProjectMemberRepository) DeleteProjectDomain(ctx context.Context, ac
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domain_servers WHERE domain_id = ?`), domainID); err != nil {
return fmt.Errorf("删除域名服务器关联失败:%w", err)
}
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domain_dns_accounts WHERE domain_id = ?`), domainID); err != nil {
return err
}
result, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domains WHERE id = ? AND project_id = ?`), domainID, projectID)
if err != nil {
return fmt.Errorf("删除域名失败:%w", err)
@@ -26,7 +26,9 @@ var _ ProjectResourceReader = (*SQLProjectMemberRepository)(nil)
const visibleDomainSelect = `SELECT domains.id, domains.name, domains.certificate_type,
domains.sans_json, domains.auto_renew, domains.acme_environment, domains.dns_provider,
domains.status, domains.expires_at, domains.created_at, domains.updated_at,
domains.project_id, domains.owner_id, domains.created_by, domains.updated_by, domains.challenge_type FROM domains`
domains.project_id, domains.owner_id, domains.created_by, domains.updated_by, domains.challenge_type,
COALESCE((SELECT dns_account_id FROM domain_dns_accounts WHERE domain_id = domains.id AND project_id = domains.project_id), ''),
COALESCE((SELECT id FROM domain_dns_accounts WHERE domain_id = domains.id AND project_id = domains.project_id), '') FROM domains`
// 列名只接受内部固定值,角色能力复用领域模型;所有身份和角色值均使用绑定参数。
// EXISTS 避免多角色账户重复返回资源,不按用户分组或全局普通管理员身份放行。
@@ -60,35 +60,33 @@ func (r *SQLDomainRepository) Update(ctx context.Context, item domain.Domain) er
if err != nil {
return err
}
result, err := r.db.ExecContext(ctx, r.query(`UPDATE domains SET
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
var storedID string
if err := tx.QueryRowContext(ctx, r.query(`SELECT id FROM domains WHERE id = ? AND project_id = ?`+taskResourceWriteLock(r.driver)), item.ID, item.ResourceScope.Normalize().ProjectID).Scan(&storedID); err != nil {
return err
}
if err := validateBoundDomainDNS(ctx, tx, r.driver, item, challengeType); err != nil {
return err
}
_, err = tx.ExecContext(ctx, r.query(`UPDATE domains SET
name = ?, certificate_type = ?, sans_json = ?, auto_renew = ?, acme_environment = ?, dns_provider = ?, updated_at = ?, updated_by = ?, challenge_type = ?
WHERE id = ? AND project_id = ?`), item.Name, item.CertificateType, string(payload), item.AutoRenew, item.ACMEEnvironment,
item.DNSProvider, item.UpdatedAt, item.UpdatedBy, challengeType, item.ID, item.ResourceScope.Normalize().ProjectID)
if err != nil {
return fmt.Errorf("更新域名失败:%w", err)
}
count, err := result.RowsAffected()
if err != nil {
return fmt.Errorf("读取更新结果失败:%w", err)
}
if count == 0 {
stored, err := r.GetByID(ctx, item.ID)
if err != nil {
return err
}
if stored.ProjectID != item.ResourceScope.Normalize().ProjectID {
return sql.ErrNoRows
}
}
return nil
return tx.Commit()
}
func (r *SQLDomainRepository) GetByID(ctx context.Context, id string) (domain.Domain, error) {
if r == nil || r.db == nil {
return domain.Domain{}, errors.New("数据库连接不能为空")
}
row := r.db.QueryRowContext(ctx, r.query(`SELECT 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
FROM domains WHERE id = ?`), id)
row := r.db.QueryRowContext(ctx, r.query(visibleDomainSelect+` WHERE domains.id = ?`), id)
return scanDomain(row)
}
@@ -96,8 +94,7 @@ func (r *SQLDomainRepository) List(ctx context.Context) ([]domain.Domain, error)
if r == nil || r.db == nil {
return nil, errors.New("数据库连接不能为空")
}
rows, err := r.db.QueryContext(ctx, r.query(`SELECT 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
FROM domains ORDER BY name`))
rows, err := r.db.QueryContext(ctx, r.query(visibleDomainSelect+` ORDER BY domains.name`))
if err != nil {
return nil, fmt.Errorf("查询域名失败:%w", err)
}
@@ -131,6 +128,9 @@ func (r *SQLDomainRepository) Delete(ctx context.Context, id string) error {
if _, err := tx.ExecContext(ctx, r.query("DELETE FROM domain_servers WHERE domain_id = ?"), id); err != nil {
return rollback(fmt.Errorf("删除域名服务器关联失败:%w", err))
}
if _, err := tx.ExecContext(ctx, r.query("DELETE FROM domain_dns_accounts WHERE domain_id = ?"), id); err != nil {
return rollback(err)
}
result, err := tx.ExecContext(ctx, r.query("DELETE FROM domains WHERE id = ?"), id)
if err != nil {
return rollback(fmt.Errorf("删除域名失败:%w", err))
@@ -183,7 +183,7 @@ func scanDomain(row scanner) (domain.Domain, error) {
var acmeEnvironment string
var dnsProvider string
var expiresAt sql.NullTime
if err := row.Scan(&item.ID, &item.Name, &certificateType, &sansJSON, &autoRenew, &acmeEnvironment, &dnsProvider, &item.Status, &expiresAt, &item.CreatedAt, &item.UpdatedAt, &item.ProjectID, &item.OwnerID, &item.CreatedBy, &item.UpdatedBy, &item.ChallengeType); err != nil {
if err := row.Scan(&item.ID, &item.Name, &certificateType, &sansJSON, &autoRenew, &acmeEnvironment, &dnsProvider, &item.Status, &expiresAt, &item.CreatedAt, &item.UpdatedAt, &item.ProjectID, &item.OwnerID, &item.CreatedBy, &item.UpdatedBy, &item.ChallengeType, &item.DNSAccountID, &item.DNSBindingID); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return domain.Domain{}, sql.ErrNoRows
}
@@ -0,0 +1,25 @@
package repository
import (
"errors"
"fmt"
"testing"
)
type sqliteCodeFixture int
func (e sqliteCodeFixture) Error() string { return "测试驱动错误,不依赖文本识别" }
func (e sqliteCodeFixture) Code() int { return int(e) }
func TestSQLiteWriteConflictClassification(t *testing.T) {
for _, code := range []int{5, 6, 261, 517, 773, 262} {
if !isSQLiteWriteConflict(fmt.Errorf("外层错误:%w", sqliteCodeFixture(code))) {
t.Fatal("忙或锁扩展错误码未被识别", code)
}
}
for _, err := range []error{nil, errors.New("database is locked"), sqliteCodeFixture(19), sqliteCodeFixture(2067), sqliteCodeFixture(10)} {
if isSQLiteWriteConflict(err) {
t.Fatal("非锁冲突不能伪装成可重试版本冲突", err)
}
}
}