完善域名服务器多对多关联与共享路径预检,补齐回归源码及进度文档

支持同项目内域名与服务器双向复用,局部修改和清空不影响其他域名;在绑定保存、服务器编辑和部署前拒绝已知共享路径冲突。

新增仓储、接口、工作流与页面回归源码,同步任务状态和第三版接口交接。按要求先开发后统一测试,本批未运行测试、构建或部署,保留在途任务与主机别名等待办。
This commit is contained in:
xuans committed 2026-09-28 21:51:05 +08:00
1 parent f38e290b22
commit e2200534d3
25 files changed
+740 -41

No files matched your search

+2 -2
View File
@@ -38,7 +38,7 @@ type certificateService interface {
}
type serverLister interface {
ListServersByDomainID(context.Context, string) ([]deployment.Server, error)
ListDeploymentServersByDomainID(context.Context, string) ([]deployment.Server, error)
}
type savedDeployer interface {
@@ -191,7 +191,7 @@ func (w *CertificateWorkflow) deploy(ctx context.Context, result certificate.Iss
if err != nil {
return deployment.Report{}, fmt.Errorf("查询域名配置失败:%w", err)
}
servers, err := w.Servers.ListServersByDomainID(ctx, result.DomainID)
servers, err := w.Servers.ListDeploymentServersByDomainID(ctx, result.DomainID)
if err != nil {
return deployment.Report{}, fmt.Errorf("查询域名部署服务器失败:%w", err)
}
@@ -29,10 +29,24 @@ func (s *workflowCertificateService) Import(context.Context, certificate.ImportR
type workflowServerLister struct {
servers []deployment.Server
err error
}
func (s workflowServerLister) ListServersByDomainID(context.Context, string) ([]deployment.Server, error) {
return s.servers, nil
func (s workflowServerLister) ListDeploymentServersByDomainID(context.Context, string) ([]deployment.Server, error) {
return s.servers, s.err
}
func TestCertificateWorkflowStopsBeforeRemoteWriteOnSharedPathConflict(t *testing.T) {
deployer := &workflowDeployer{}
workflow := &CertificateWorkflow{
Domains: &workflowDomainState{},
Servers: workflowServerLister{err: deployment.ErrSharedPathConflict},
Deployment: deployer,
}
_, err := workflow.deploy(t.Context(), certificate.IssueResult{DomainID: "shared-domain"})
if !errors.Is(err, deployment.ErrSharedPathConflict) || deployer.targets != nil {
t.Fatalf("路径冲突后仍尝试远端部署:%v,%+v", err, deployer.targets)
}
}
type workflowDeployer struct {
@@ -0,0 +1,33 @@
package deployment
import (
"errors"
"fmt"
"strings"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
var ErrSharedPathConflict = errors.New("多个域名的远程证书路径冲突,请使用按域名区分的证书、证书链和私钥路径")
// 比较实际展开并规范化后的全部文件路径,不仅检查模板是否含有域名占位符。
// 错误不携带其他域名名称、资源标识或远程私钥路径。
func ValidateServerDomainPaths(server Server, domains []domain.Domain) error {
paths := make([]string, 0, len(domains)*3)
for _, item := range domains {
resolved, err := ResolveServerPaths(server, item.Name, string(item.CertificateType))
if err != nil {
return fmt.Errorf("关联域名的远程证书路径无效:%w", err)
}
current := []string{resolved.CertificatePath, resolved.CertificateChainPath, resolved.PrivateKeyPath}
for _, candidate := range current {
for _, existing := range paths {
if candidate == existing || strings.HasPrefix(candidate, existing+"/") || strings.HasPrefix(existing, candidate+"/") {
return ErrSharedPathConflict
}
}
}
paths = append(paths, current...)
}
return nil
}
@@ -0,0 +1,51 @@
package deployment
import (
"errors"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
func TestSharedServerDomainPaths(t *testing.T) {
domains := []domain.Domain{
{ID: "a", Name: "a.example.test", CertificateType: domain.CertificateSingle},
{ID: "b", Name: "b.example.test", CertificateType: domain.CertificateSingle},
}
for _, tc := range []struct {
name string
server Server
conflict bool
}{
{name: "default_templates"},
{name: "english_templates", server: Server{CertificatePath: "/ssl/{domain}/cert.pem", CertificateChainPath: "/ssl/{domain}/chain.pem", PrivateKeyPath: "/ssl/{domain}/key.pem"}},
{name: "fixed_certificate", server: Server{CertificatePath: "/ssl/cert.pem"}, conflict: true},
{name: "fixed_chain", server: Server{CertificateChainPath: "/ssl/chain.pem"}, conflict: true},
{name: "fixed_key", server: Server{PrivateKeyPath: "/ssl/key.pem"}, conflict: true},
{name: "collapsed_placeholder", server: Server{CertificatePath: "/ssl/{domain}/../cert.pem"}, conflict: true},
{name: "cross_file_collision", server: Server{CertificatePath: "/ssl/{domain}/b.example.test", PrivateKeyPath: "/ssl/a.example.test/{domain}"}, conflict: true},
{name: "file_directory_collision", server: Server{CertificatePath: "/ssl/{domain}/b.example.test", PrivateKeyPath: "/ssl/a.example.test/{domain}/key.pem"}, conflict: true},
} {
t.Run(tc.name, func(t *testing.T) {
err := ValidateServerDomainPaths(tc.server, domains)
if tc.conflict {
if !errors.Is(err, ErrSharedPathConflict) {
t.Fatalf("共享路径冲突未拒绝:%v", err)
}
} else if err != nil {
t.Fatal(err)
}
})
}
if err := ValidateServerDomainPaths(Server{CertificatePath: "/ssl/cert.pem"}, domains[:1]); err != nil {
t.Fatalf("单域名固定路径应保持兼容:%v", err)
}
for _, item := range []domain.Domain{
{ID: "other", Name: "a.example.test", CertificateType: domain.CertificateSingle},
{ID: "wildcard", Name: "*.a.example.test", CertificateType: domain.CertificateSingle},
} {
if err := ValidateServerDomainPaths(Server{}, []domain.Domain{domains[0], item}); !errors.Is(err, ErrSharedPathConflict) {
t.Fatalf("规范化后同路径的资源未拒绝:%v", err)
}
}
}
@@ -8,6 +8,7 @@ import (
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
@@ -41,6 +42,8 @@ func (s *Server) replaceProjectDomainServers(c *gin.Context) {
s.writeError(c, http.StatusForbidden, "无权修改此项目的服务器绑定", nil)
case errors.Is(err, repository.ErrProjectBindingInput):
s.writeError(c, http.StatusBadRequest, err.Error(), nil)
case errors.Is(err, deployment.ErrSharedPathConflict):
s.writeError(c, http.StatusConflict, deployment.ErrSharedPathConflict.Error(), nil)
case err != nil:
s.writeError(c, http.StatusInternalServerError, "保存项目服务器绑定失败,请刷新后核对", nil)
default:
@@ -0,0 +1,90 @@
package httpapi
import (
"encoding/json"
"net/http"
"slices"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
func TestProjectBindingAPIManyToManyAndPathConflict(t *testing.T) {
f, _ := newProjectResourceAPIFixture(t)
server, err := f.server.servers.GetServerByID(t.Context(), "server-a")
if err != nil {
t.Fatal(err)
}
server.CertificatePath, server.CertificateChainPath, server.PrivateKeyPath = "", "", ""
if err := f.server.servers.UpdateServer(t.Context(), server); err != nil {
t.Fatal(err)
}
server.ID, server.Name = "server-c", "第二台共享服务器"
if err := f.server.servers.CreateServer(t.Context(), server); err != nil {
t.Fatal(err)
}
item, err := domain.NewDomain("second.example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ID, item.ProjectID = "domain-c", "project-a"
if err := repository.NewSQLDomainRepository(f.db).Create(t.Context(), item); err != nil {
t.Fatal(err)
}
put := func(id, body string, expected int) {
t.Helper()
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodPut, "/api/v1/domains/"+id+"/servers", body)
if response.Code != expected {
t.Fatalf("多对多保存响应错误:%s,%d,%s", id, response.Code, response.Body.String())
}
if expected == http.StatusConflict && (!strings.Contains(response.Body.String(), "路径冲突") || strings.Contains(response.Body.String(), "second.example.test")) {
t.Fatalf("冲突提示不明确或泄露其他域名:%s", response.Body.String())
}
}
assertBindings := func(id string, expected []string) {
t.Helper()
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodGet, "/api/v1/domains/"+id+"/servers", "")
var result struct {
Items []deployment.Server `json:"items"`
}
if response.Code != http.StatusOK || json.Unmarshal(response.Body.Bytes(), &result) != nil || result.Items == nil {
t.Fatalf("多对多读取响应错误:%d,%s", response.Code, response.Body.String())
}
ids := make([]string, 0, len(result.Items))
for _, item := range result.Items {
ids = append(ids, item.ID)
}
slices.Sort(ids)
if !slices.Equal(ids, expected) {
t.Fatalf("改变一个域名后关联不正确:%s,%v,期望 %v", id, ids, expected)
}
}
both := []string{"server-a", "server-c"}
put("domain-a", `{"server_ids":["server-c","server-a","server-a"]}`, http.StatusOK)
put("domain-c", `{"server_ids":["server-a","server-c"]}`, http.StatusOK)
assertBindings("domain-a", both)
assertBindings("domain-c", both)
put("domain-a", `{"server_ids":["server-c"]}`, http.StatusOK)
assertBindings("domain-a", both[1:])
assertBindings("domain-c", both)
put("domain-a", `{"server_ids":[]}`, http.StatusOK)
assertBindings("domain-a", []string{})
assertBindings("domain-c", both)
put("domain-a", `{"server_ids":["server-a","server-c"]}`, http.StatusOK)
put("domain-a", `{"server_ids":["server-b"]}`, http.StatusForbidden)
assertBindings("domain-a", both)
assertBindings("domain-c", both)
if _, err := f.db.ExecContext(t.Context(), `UPDATE servers SET certificate_path='/ssl/fixed/cert.pem' WHERE id='server-a'`); err != nil {
t.Fatal(err)
}
put("domain-a", `{"server_ids":["server-a","server-c"]}`, http.StatusConflict)
assertBindings("domain-a", both)
assertBindings("domain-c", both)
entry := f.lastAudit(t)
if entry.Action != "domain.servers.replace" || entry.ProjectID != "project-a" || entry.Status != "failed" {
t.Fatalf("路径冲突缺少项目失败审计:%+v", entry)
}
}
+7
View File
@@ -768,6 +768,10 @@ func (s *Server) updateServer(c *gin.Context) {
}
if err := s.servers.UpdateServer(c.Request.Context(), item); err != nil {
cleanup()
if errors.Is(err, deployment.ErrSharedPathConflict) {
s.writeError(c, http.StatusConflict, deployment.ErrSharedPathConflict.Error(), nil)
return
}
s.writeError(c, serverErrorStatus(err), "更新服务器失败", err)
return
}
@@ -974,6 +978,9 @@ func serverFromRequest(request serverRequest) deployment.Server {
}
func serverErrorStatus(err error) int {
if errors.Is(err, deployment.ErrSharedPathConflict) {
return http.StatusConflict
}
if repository.IsConflict(err) {
return http.StatusConflict
}
+8 -3
View File
@@ -312,10 +312,15 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB),
Servers: repository.NewSQLServerRepository(db.DB), SSHKeys: sshKeys,
ProjectResources: projectResourceReaderStub{
domains: repository.NewSQLDomainRepository(db.DB), servers: repository.NewSQLServerRepository(db.DB),
},
Users: repository.NewSQLUserRepository(db.DB),
ProjectResources: repository.NewSQLProjectMemberRepository(db.DB),
ProjectBindings: repository.NewSQLProjectMemberRepository(db.DB),
})
// 此旧格式用例同样使用真实账户与项目成员,不能依赖全局管理员绕过绑定权限。
_ = httpUserSessionCookie(server, "test-admin", repository.UserRoleAdmin)
if _, err := db.DB.ExecContext(t.Context(), `INSERT INTO project_members (project_id, user_id, role) VALUES ('default', 'test-admin', 'project_admin')`); err != nil {
t.Fatal(err)
}
domainRequest := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"single"}`))
domainRequest.Header.Set("Content-Type", "application/json")
@@ -72,11 +72,12 @@ func (r *SQLProjectMemberRepository) ReplaceProjectDomainServers(ctx context.Con
return nil, errors.New("项目绑定及授权审计相关表必须使用 InnoDB")
}
}
var projectID string
var candidate domain.Domain
if err := tx.QueryRowContext(ctx, Rebind(r.driver,
`SELECT project_id FROM domains WHERE id = ?`+r.resourceWriteLock()), domainID).Scan(&projectID); err != nil {
`SELECT id, project_id, name, certificate_type FROM domains WHERE id = ?`+r.resourceWriteLock()), domainID).Scan(&candidate.ID, &candidate.ProjectID, &candidate.Name, &candidate.CertificateType); err != nil {
return nil, projectBindingReadError(err)
}
projectID := candidate.ProjectID
if err := r.authorizeBindingTransaction(ctx, tx, actorID, projectID); err != nil {
return nil, err
}
@@ -92,6 +93,11 @@ func (r *SQLProjectMemberRepository) ReplaceProjectDomainServers(ctx context.Con
}
items = append(items, item)
}
for _, item := range items {
if err := validateServerDomainPaths(ctx, tx, r.driver, item, &candidate); err != nil {
return nil, err
}
}
if _, err := tx.ExecContext(ctx, Rebind(r.driver, `DELETE FROM domain_servers WHERE domain_id = ?`), domainID); err != nil {
return nil, fmt.Errorf("清理项目绑定失败:%w", err)
}
@@ -166,8 +172,8 @@ func (r *SQLProjectMemberRepository) authorizeBindingTransaction(ctx context.Con
}
defer rows.Close()
permissions := map[domain.ProjectPermission]bool{
domain.PermissionCertificateRead: false,
domain.PermissionServerRead: false,
domain.PermissionCertificateRead: false,
domain.PermissionServerRead: false,
domain.PermissionDeploymentExecute: false,
}
for rows.Next() {
@@ -137,6 +137,9 @@ func checkProjectResources(t *testing.T, cfg config.DatabaseConfig, admin *sql.D
}
})
checkProjectBindings(t, db.DB, admin, repo, cfg.Driver)
t.Run("many_to_many_bindings", func(t *testing.T) {
checkManyToManyBindings(t, db.DB, admin, repo, cfg.Driver)
})
t.Run("revocation_and_disabled_account_are_not_cached", func(t *testing.T) {
if err := repo.RevokeProjectRole(t.Context(), "root", "project-a", "reader", domain.ProjectRoleReadOnly); err != nil {
t.Fatal(err)
@@ -0,0 +1,98 @@
package repository
import (
"context"
"database/sql"
"fmt"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
func serverResourceLock(driver string) string {
if driver == "mysql" || driver == "postgres" {
return " FOR UPDATE"
}
return ""
}
// 调用者须在同一事务先锁定服务器行;候选域名用于校验尚未落库的新关联。
func validateServerDomainPaths(ctx context.Context, tx *sql.Tx, driver string, server deployment.Server, candidate *domain.Domain) error {
excludeID := ""
items := make([]domain.Domain, 0)
if candidate != nil {
excludeID = candidate.ID
items = append(items, *candidate)
}
rows, err := tx.QueryContext(ctx, Rebind(driver, `SELECT d.id, d.name, d.certificate_type
FROM domains d INNER JOIN domain_servers ds ON ds.domain_id = d.id
WHERE ds.server_id = ? AND d.id <> ? ORDER BY d.id`+serverResourceLock(driver)), server.ID, excludeID)
if err != nil {
return fmt.Errorf("查询共享服务器的域名路径失败:%w", err)
}
defer rows.Close()
for rows.Next() {
var item domain.Domain
if err := rows.Scan(&item.ID, &item.Name, &item.CertificateType); err != nil {
return err
}
items = append(items, item)
}
if err := rows.Err(); err != nil {
return err
}
return deployment.ValidateServerDomainPaths(server, items)
}
// 部署入口重新读取关联及路径;不能把保存关联时的校验当成永久有效。
// 返回的服务器配置与路径检查使用同一事务快照,事务完成后才允许进行远端操作。
func (r *SQLServerRepository) ListDeploymentServersByDomainID(ctx context.Context, domainID string) ([]deployment.Server, error) {
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return nil, err
}
defer tx.Rollback()
var candidate domain.Domain
if err := tx.QueryRowContext(ctx, r.query(`SELECT id, project_id, name, certificate_type FROM domains WHERE id = ?`+serverResourceLock(r.driver)), domainID).Scan(&candidate.ID, &candidate.ProjectID, &candidate.Name, &candidate.CertificateType); err != nil {
return nil, err
}
rows, err := tx.QueryContext(ctx, r.query(serverSelectQualified+` INNER JOIN domain_servers ds
ON ds.server_id = servers.id WHERE ds.domain_id = ? ORDER BY servers.id`+serverResourceLock(r.driver)), domainID)
if err != nil {
return nil, err
}
items := make([]deployment.Server, 0)
for rows.Next() {
item, err := scanServer(rows)
if err != nil {
rows.Close()
return nil, err
}
items = append(items, item)
}
readErr := rows.Err()
closeErr := rows.Close()
if readErr != nil {
return nil, readErr
}
if closeErr != nil {
return nil, closeErr
}
for index, item := range items {
if item.ProjectID != candidate.ProjectID {
return nil, ErrProjectAccessDenied
}
if err := validateServerDomainPaths(ctx, tx, r.driver, item, nil); err != nil {
return nil, err
}
resolved, err := deployment.ResolveServerPaths(item, candidate.Name, string(candidate.CertificateType))
if err != nil {
return nil, err
}
items[index] = resolved
}
if err := tx.Commit(); err != nil {
return nil, err
}
return items, nil
}
@@ -6,10 +6,12 @@ import (
"encoding/json"
"errors"
"fmt"
"sort"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
type ServerRepository interface {
@@ -85,25 +87,27 @@ func (r *SQLServerRepository) UpdateServer(ctx context.Context, server deploymen
if updatedAt.IsZero() {
updatedAt = time.Now().UTC()
}
result, err := r.db.ExecContext(ctx, r.query(`UPDATE servers SET name = ?, address = ?, port = ?, username = ?, auth_method = ?, private_key_ref = ?, password_ref = ?, host_key_fingerprint = ?, ssh_key_status = ?, ssh_key_fingerprint = ?, ssh_key_deployed_at = ?, ssh_key_tested_at = ?, ssh_key_error = ?, certificate_path = ?, private_key_path = ?, certificate_chain_path = ?, web_server = ?, validation_command_json = ?, reload_command_json = ?, updated_at = ?, updated_by = ? WHERE id = ? AND project_id = ?`),
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
var projectID string
if err := tx.QueryRowContext(ctx, r.query(`SELECT project_id FROM servers WHERE id = ?`+serverResourceLock(r.driver)), server.ID).Scan(&projectID); err != nil {
return err
}
if projectID != server.ProjectID {
return sql.ErrNoRows
}
if err := validateServerDomainPaths(ctx, tx, r.driver, server, nil); err != nil {
return err
}
_, err = tx.ExecContext(ctx, r.query(`UPDATE servers SET name = ?, address = ?, port = ?, username = ?, auth_method = ?, private_key_ref = ?, password_ref = ?, host_key_fingerprint = ?, ssh_key_status = ?, ssh_key_fingerprint = ?, ssh_key_deployed_at = ?, ssh_key_tested_at = ?, ssh_key_error = ?, certificate_path = ?, private_key_path = ?, certificate_chain_path = ?, web_server = ?, validation_command_json = ?, reload_command_json = ?, updated_at = ?, updated_by = ? WHERE id = ? AND project_id = ?`),
server.Name, server.Address, server.Port, server.Username, server.AuthMethod, server.PrivateKeyRef, server.PasswordRef, server.HostKeyFingerprint, server.SSHKeyStatus, server.SSHKeyFingerprint, server.SSHKeyDeployedAt, server.SSHKeyTestedAt, server.SSHKeyError, server.CertificatePath, server.PrivateKeyPath, server.CertificateChainPath, server.WebServer, string(validationCommand), string(command), updatedAt, server.UpdatedBy, server.ID, server.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.GetServerByID(ctx, server.ID)
if err != nil {
return err
}
if stored.ProjectID != server.ProjectID {
return sql.ErrNoRows
}
}
return nil
return tx.Commit()
}
func (r *SQLServerRepository) GetServerByID(ctx context.Context, id string) (deployment.Server, error) {
@@ -214,28 +218,31 @@ func (r *SQLServerRepository) ReplaceDomainServers(ctx context.Context, domainID
seen[id] = struct{}{}
cleaned = append(cleaned, id)
}
sort.Strings(cleaned)
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("开始更新域名服务器关联失败:%w", err)
}
defer tx.Rollback()
rollback := func(cause error) error {
_ = tx.Rollback()
return cause
}
var projectID string
if err := tx.QueryRowContext(ctx, r.query("SELECT project_id FROM domains WHERE id = ?"), domainID).Scan(&projectID); err != nil {
var candidate domain.Domain
if err := tx.QueryRowContext(ctx, r.query(`SELECT id, project_id, name, certificate_type FROM domains WHERE id = ?`+serverResourceLock(r.driver)), domainID).Scan(&candidate.ID, &candidate.ProjectID, &candidate.Name, &candidate.CertificateType); err != nil {
return rollback(fmt.Errorf("读取绑定域名项目失败:%w", err))
}
projectID := candidate.ProjectID
if _, err := tx.ExecContext(ctx, r.query("DELETE FROM domain_servers WHERE domain_id = ?"), domainID); err != nil {
return rollback(fmt.Errorf("清理域名服务器关联失败:%w", err))
}
for _, serverID := range cleaned {
var exists int
if err := tx.QueryRowContext(ctx, r.query("SELECT COUNT(*) FROM servers WHERE id = ? AND project_id = ?"), serverID, projectID).Scan(&exists); err != nil {
server, err := scanServer(tx.QueryRowContext(ctx, r.query(serverSelectQualified+` WHERE servers.id = ? AND servers.project_id = ?`+serverResourceLock(r.driver)), serverID, projectID))
if err != nil {
return rollback(fmt.Errorf("校验部署服务器失败:%w", err))
}
if exists == 0 {
return rollback(fmt.Errorf("部署服务器不存在或不属于域名项目:%s", serverID))
if err := validateServerDomainPaths(ctx, tx, r.driver, server, &candidate); err != nil {
return rollback(err)
}
if _, err := tx.ExecContext(ctx, r.query("INSERT INTO domain_servers (domain_id, server_id, project_id) VALUES (?, ?, ?)"), domainID, serverID, projectID); err != nil {
return rollback(fmt.Errorf("保存域名服务器关联失败:%w", err))
@@ -0,0 +1,148 @@
package repository
import (
"context"
"database/sql"
"errors"
"slices"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
// 由已有 SQLite 和隔离 MySQL 真实仓储入口调用,不使用业务库或额外验收脚本。
func checkManyToManyBindings(t *testing.T, db, admin *sql.DB, members *SQLProjectMemberRepository, driver string) {
t.Helper()
domains := NewSQLDomainRepository(db, driver)
servers := NewSQLServerRepository(db, driver)
for _, suffix := range []string{"one", "two"} {
item, err := domain.NewDomain(suffix+".shared.example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ID, item.ProjectID = "shared-domain-"+suffix, "project-a"
if err := domains.Create(t.Context(), item); err != nil {
t.Fatal(err)
}
server := deployment.Server{
ResourceScope: domain.ResourceScope{ProjectID: "project-a"},
ID: "shared-server-" + suffix, Name: suffix, Address: "192.0.2.20", Port: 22, Username: "deploy",
PrivateKeyRef: "secret://ssh/fixture", HostKeyFingerprint: "SHA256:test", WebServer: deployment.WebServerNginx,
}
if err := servers.CreateServer(t.Context(), server); err != nil {
t.Fatal(err)
}
}
both := []string{"shared-server-one", "shared-server-two"}
assertBindings := func(id string, expected []string) {
t.Helper()
items, err := members.ListVisibleDomainServers(t.Context(), "manager", id)
if err != nil {
t.Fatal(err)
}
actual := make([]string, 0, len(items))
for _, item := range items {
actual = append(actual, item.ID)
}
slices.Sort(actual)
if !slices.Equal(actual, expected) {
t.Fatalf("域名关联错误:%s,实际 %v,期望 %v", id, actual, expected)
}
}
bind := func(id string, ids []string) {
t.Helper()
if _, err := members.ReplaceProjectDomainServers(t.Context(), "manager", id, ids); err != nil {
t.Fatal(err)
}
}
bind("shared-domain-one", append(slices.Clone(both), both[0]))
bind("shared-domain-two", both)
assertBindings("shared-domain-one", both)
assertBindings("shared-domain-two", both)
bind("shared-domain-one", both[:1])
assertBindings("shared-domain-one", both[:1])
assertBindings("shared-domain-two", both)
bind("shared-domain-one", []string{})
assertBindings("shared-domain-one", []string{})
assertBindings("shared-domain-two", both)
bind("shared-domain-one", both)
if _, err := members.ReplaceProjectDomainServers(t.Context(), "manager", "shared-domain-one", []string{"server-b"}); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("跨项目绑定未拒绝:%v", err)
}
assertBindings("shared-domain-one", both)
assertBindings("shared-domain-two", both)
first, err := servers.ListDeploymentServersByDomainID(t.Context(), "shared-domain-one")
if err != nil || len(first) != 2 {
t.Fatalf("一个域名未取得两台部署服务器:%v,%v", first, err)
}
second, err := servers.ListDeploymentServersByDomainID(t.Context(), "shared-domain-two")
if err != nil || len(second) != 2 {
t.Fatalf("共享服务器读取失败:%v,%v", second, err)
}
for i := range first {
if first[i].ID != second[i].ID || first[i].CertificatePath == second[i].CertificatePath || first[i].PrivateKeyPath == second[i].PrivateKeyPath {
t.Fatal("同一服务器的不同域名未分离文件路径")
}
}
server, err := servers.GetServerByID(t.Context(), both[0])
if err != nil {
t.Fatal(err)
}
server.PrivateKeyPath = "/ssl/shared/key.pem"
if err := servers.UpdateServer(t.Context(), server); !errors.Is(err, deployment.ErrSharedPathConflict) {
t.Fatalf("共享服务器改为固定私钥路径未拒绝:%v", err)
}
stored, err := servers.GetServerByID(t.Context(), both[0])
if err != nil || stored.PrivateKeyPath != deployment.DefaultPrivateKeyPath {
t.Fatalf("被拒绝的配置仍写入:%+v,%v", stored, err)
}
// 模拟旧数据库已有的危险配置,部署前和新关联写入必须再次拒绝。
if _, err := db.ExecContext(t.Context(), Rebind(driver, `UPDATE servers SET private_key_path='/ssl/shared/key.pem' WHERE id=?`), both[0]); err != nil {
t.Fatal(err)
}
for _, id := range []string{"shared-domain-one", "shared-domain-two"} {
if _, err := servers.ListDeploymentServersByDomainID(t.Context(), id); !errors.Is(err, deployment.ErrSharedPathConflict) {
t.Fatalf("历史冲突仍允许部署:%s,%v", id, err)
}
}
if _, err := members.ReplaceProjectDomainServers(t.Context(), "manager", "shared-domain-one", both); !errors.Is(err, deployment.ErrSharedPathConflict) {
t.Fatalf("危险路径仍可写入关联:%v", err)
}
if err := servers.ReplaceDomainServers(t.Context(), "shared-domain-one", both); !errors.Is(err, deployment.ErrSharedPathConflict) {
t.Fatalf("旧仓储入口绕过路径保护:%v", err)
}
assertBindings("shared-domain-one", both)
assertBindings("shared-domain-two", both)
if err := servers.UpdateServer(t.Context(), stored); err != nil {
t.Fatal(err)
}
// 两个域名均保留绑定时,审计故障不得仅回滚其中一部分。
executor := db
triggerName := "reject_shared_binding_audit"
trigger := `CREATE TRIGGER reject_shared_binding_audit BEFORE INSERT ON audit_logs BEGIN SELECT RAISE(ABORT, 'audit-failure'); 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, "`", "``") + "`"
triggerName = schema + ".reject_shared_binding_audit"
trigger = "CREATE TRIGGER " + triggerName + " BEFORE INSERT ON " + schema + ".audit_logs FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='audit-failure'"
executor = admin
}
if _, err := executor.ExecContext(t.Context(), trigger); err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if _, err := executor.ExecContext(context.Background(), "DROP TRIGGER "+triggerName); err != nil {
t.Error(err)
}
})
if _, err := members.ReplaceProjectDomainServers(t.Context(), "manager", "shared-domain-one", []string{}); err == nil {
t.Fatal("审计失败仍清空了共享关联")
}
assertBindings("shared-domain-one", both)
assertBindings("shared-domain-two", both)
}