实现项目成员与实时权限判定并同步整改验证进度
This commit is contained in:
1 parent
4f1900dbbe
commit
b3909d83f0
20 files changed
+1130
-5
No files matched your search
@@ -3,6 +3,7 @@ package cli
|
||||
import (
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"errors"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
@@ -129,6 +130,7 @@ func TestSQLiteBusinessUpgradeStandaloneCLI(t *testing.T) {
|
||||
// 从旧备份恢复后再次走正式应用入口升级,不由测试直接调用 Migrate。
|
||||
runSQLiteProductCLI(t, binary, fixture, "certificate", "list")
|
||||
assertSQLiteCLIUpgradeUsable(t, fixture)
|
||||
assertSQLiteCLIMembersRestored(t, fixture, scenario.name == "upgraded_backup")
|
||||
if err := validateBackupManifest(scenario.archive); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -136,6 +138,36 @@ func TestSQLiteBusinessUpgradeStandaloneCLI(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func assertSQLiteCLIMembersRestored(t *testing.T, fixture sqliteBusinessFixture, present bool) {
|
||||
t.Helper()
|
||||
db, err := database.Open(t.Context(), fixture.config.Database)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer db.Close()
|
||||
var count int
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT COUNT(*) FROM project_members").Scan(&count); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := 0
|
||||
if present {
|
||||
want = 2
|
||||
}
|
||||
if count != want {
|
||||
t.Fatalf("恢复后的成员数量错误:%d,期望 %d", count, want)
|
||||
}
|
||||
members := repository.NewSQLProjectMemberRepository(db.DB)
|
||||
for _, permission := range []domain.ProjectPermission{domain.PermissionCertificateRead, domain.PermissionDNSCredentialUse} {
|
||||
err := members.AuthorizeProject(t.Context(), "backup-member", "backup-project", permission)
|
||||
if (present && err != nil) || (!present && !errors.Is(err, repository.ErrProjectAccessDenied)) {
|
||||
t.Fatalf("恢复后的成员权限错误:%s,%v", permission, err)
|
||||
}
|
||||
}
|
||||
if err := members.AuthorizeProject(t.Context(), "backup-member", domain.DefaultProjectID, domain.PermissionCertificateRead); !errors.Is(err, repository.ErrProjectAccessDenied) {
|
||||
t.Fatalf("恢复后出现跨项目访问:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func createSQLiteProjectForBackup(t *testing.T, fixture sqliteBusinessFixture) {
|
||||
t.Helper()
|
||||
db, err := database.Open(t.Context(), fixture.config.Database)
|
||||
@@ -170,6 +202,22 @@ func createSQLiteProjectForBackup(t *testing.T, fixture sqliteBusinessFixture) {
|
||||
if err := servers.ReplaceDomainServers(t.Context(), resource.ID, []string{server.ID}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB)
|
||||
owner, err := users.FindByIdentifier(t.Context(), "upgrade-owner")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
member := repository.User{ID: "backup-member", Username: "backup-member", Email: "member@example.test",
|
||||
PasswordHash: owner.PasswordHash, Role: repository.UserRoleUser, Status: repository.UserStatusActive}
|
||||
if err := users.CreateUser(t.Context(), member); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
members := repository.NewSQLProjectMemberRepository(db.DB)
|
||||
for _, role := range []domain.ProjectRole{domain.ProjectRoleReadOnly, domain.ProjectRoleDNSAdmin} {
|
||||
if err := members.GrantProjectRole(t.Context(), owner.ID, item.ID, member.ID, role); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func runSQLiteProductCLI(t *testing.T, binary string, fixture sqliteBusinessFixture, args ...string) {
|
||||
@@ -241,7 +289,7 @@ func assertSQLiteCLIUpgradeUsable(t *testing.T, fixture sqliteBusinessFixture) {
|
||||
}
|
||||
defer db.Close()
|
||||
var version, bindings int
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT MAX(version) FROM schema_migrations").Scan(&version); err != nil || version != 13 {
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT MAX(version) FROM schema_migrations").Scan(&version); err != nil || version != 14 {
|
||||
t.Fatalf("正式应用入口未完成历史升级:%d,%v", version, err)
|
||||
}
|
||||
project, err := repository.NewSQLProjectRepository(db.DB).GetProject(t.Context(), domain.DefaultProjectID)
|
||||
|
||||
@@ -215,7 +215,7 @@ func TestHistoryScopeMySQLMigrationRetry(t *testing.T) {
|
||||
}
|
||||
}
|
||||
assertHistoryScope(t, db.DB)
|
||||
if version, err := currentMigrationVersion(ctx, db.DB); err != nil || version != 13 {
|
||||
if version, err := currentMigrationVersion(ctx, db.DB); err != nil || version != latestMigrationVersion {
|
||||
t.Fatalf("重试版本错误:%d,%v", version, err)
|
||||
}
|
||||
})
|
||||
|
||||
@@ -15,6 +15,7 @@ import (
|
||||
//go:embed migrations/sqlite/0011_resource_projects.sql migrations/mysql/0011_resource_projects.sql migrations/postgres/0011_resource_projects.sql
|
||||
//go:embed migrations/sqlite/0012_resource_replacement.sql migrations/mysql/0012_resource_replacement.sql migrations/postgres/0012_resource_replacement.sql
|
||||
//go:embed migrations/sqlite/0013_history_scope.sql migrations/mysql/0013_history_scope.sql migrations/postgres/0013_history_scope.sql
|
||||
//go:embed migrations/sqlite/0014_project_members.sql migrations/mysql/0014_project_members.sql migrations/postgres/0014_project_members.sql
|
||||
var migrationFiles embed.FS
|
||||
|
||||
func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
@@ -39,7 +40,7 @@ func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
const latestMigrationVersion = 13
|
||||
const latestMigrationVersion = 14
|
||||
|
||||
// currentMigrationVersion 在执行业务迁移前拒绝新版数据库及不连续的迁移历史。
|
||||
func currentMigrationVersion(ctx context.Context, db *sql.DB) (int, error) {
|
||||
@@ -79,6 +80,11 @@ func applyMigration(ctx context.Context, db *sql.DB, driver string, version int)
|
||||
return applySQLiteTaskMigration(ctx, db, statements, version)
|
||||
}
|
||||
if driver == "mysql" {
|
||||
if version == 14 {
|
||||
if err := installMySQLProjectMembers(ctx, db); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, statement := range statements {
|
||||
skip, err := shouldSkipMySQLStatement(ctx, db, statement)
|
||||
if err != nil {
|
||||
@@ -129,6 +135,12 @@ func applyMigration(ctx context.Context, db *sql.DB, driver string, version int)
|
||||
return err
|
||||
}
|
||||
}
|
||||
if driver == "sqlite" && version == 14 {
|
||||
if err := installSQLiteProjectMemberGuards(ctx, tx); err != nil {
|
||||
_ = tx.Rollback()
|
||||
return err
|
||||
}
|
||||
}
|
||||
migrationVersionInsert := "INSERT INTO schema_migrations (version) VALUES (?)"
|
||||
if driver == "postgres" {
|
||||
migrationVersionInsert = "INSERT INTO schema_migrations (version) VALUES ($1)"
|
||||
@@ -206,6 +218,8 @@ func migrationName(version int) string {
|
||||
return "resource_replacement"
|
||||
case 13:
|
||||
return "history_scope"
|
||||
case 14:
|
||||
return "project_members"
|
||||
default:
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
-- Go 迁移读取历史用户主键的实际字符集,建立兼容外键;不修改原用户表。
|
||||
SELECT 1;
|
||||
@@ -0,0 +1,8 @@
|
||||
CREATE TABLE project_members (
|
||||
project_id VARCHAR(36) NOT NULL REFERENCES projects(id),
|
||||
user_id VARCHAR(36) NOT NULL REFERENCES users(id),
|
||||
role VARCHAR(32) NOT NULL CHECK (role IN ('project_admin', 'certificate_admin', 'deployment_admin', 'dns_admin', 'audit_viewer', 'read_only')),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
PRIMARY KEY (project_id, user_id, role)
|
||||
);
|
||||
CREATE INDEX idx_project_members_user ON project_members(user_id, project_id);
|
||||
@@ -0,0 +1,8 @@
|
||||
CREATE TABLE project_members (
|
||||
project_id TEXT NOT NULL REFERENCES projects(id),
|
||||
user_id TEXT NOT NULL REFERENCES users(id),
|
||||
role TEXT NOT NULL CHECK (role IN ('project_admin', 'certificate_admin', 'deployment_admin', 'dns_admin', 'audit_viewer', 'read_only')),
|
||||
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
PRIMARY KEY (project_id, user_id, role)
|
||||
);
|
||||
CREATE INDEX idx_project_members_user ON project_members(user_id, project_id);
|
||||
@@ -0,0 +1,112 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
var mysqlMetadataIdentifier = regexp.MustCompile(`^[a-zA-Z0-9_]+$`)
|
||||
|
||||
func installMySQLProjectMembers(ctx context.Context, db *sql.DB) error {
|
||||
var charset, collation, dataType string
|
||||
var length int
|
||||
if err := db.QueryRowContext(ctx, `SELECT CHARACTER_SET_NAME, COLLATION_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH
|
||||
FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'users' AND column_name = 'id'`).
|
||||
Scan(&charset, &collation, &dataType, &length); err != nil {
|
||||
return fmt.Errorf("读取用户主键类型失败:%w", err)
|
||||
}
|
||||
if dataType != "varchar" || length != 36 || !mysqlMetadataIdentifier.MatchString(charset) || !mysqlMetadataIdentifier.MatchString(collation) {
|
||||
return fmt.Errorf("用户主键类型不兼容,拒绝建立项目成员关系")
|
||||
}
|
||||
// MySQL 历史库的默认字符集可能改变,不能用当前默认值猜测用户主键类型。
|
||||
statement := fmt.Sprintf(`CREATE TABLE IF NOT EXISTS project_members (
|
||||
project_id VARCHAR(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
|
||||
user_id VARCHAR(36) CHARACTER SET %s COLLATE %s NOT NULL,
|
||||
role ENUM('project_admin', 'certificate_admin', 'deployment_admin', 'dns_admin', 'audit_viewer', 'read_only') NOT NULL,
|
||||
created_at DATETIME(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
|
||||
PRIMARY KEY (project_id, user_id, role),
|
||||
KEY idx_project_members_user (user_id, project_id),
|
||||
CONSTRAINT fk_project_members_project FOREIGN KEY (project_id) REFERENCES projects(id),
|
||||
CONSTRAINT fk_project_members_user FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin`, charset, collation)
|
||||
if _, err := db.ExecContext(ctx, statement); err != nil {
|
||||
return fmt.Errorf("建立项目成员关系失败:%w", err)
|
||||
}
|
||||
// 重试只接受完整的既有表;不能把同名残缺表当作迁移成功。
|
||||
var userCharset, userCollation, roleType string
|
||||
if err := db.QueryRowContext(ctx, `SELECT CHARACTER_SET_NAME, COLLATION_NAME FROM information_schema.columns
|
||||
WHERE table_schema=DATABASE() AND table_name='project_members' AND column_name='user_id'`).Scan(&userCharset, &userCollation); err != nil {
|
||||
return fmt.Errorf("检查成员用户字段失败:%w", err)
|
||||
}
|
||||
if err := db.QueryRowContext(ctx, `SELECT COLUMN_TYPE FROM information_schema.columns
|
||||
WHERE table_schema=DATABASE() AND table_name='project_members' AND column_name='role'`).Scan(&roleType); err != nil {
|
||||
return fmt.Errorf("检查成员角色字段失败:%w", err)
|
||||
}
|
||||
var references, primaryColumns int
|
||||
if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM information_schema.key_column_usage
|
||||
WHERE table_schema=DATABASE() AND table_name='project_members' AND referenced_table_schema=DATABASE()
|
||||
AND ((column_name='project_id' AND referenced_table_name='projects' AND referenced_column_name='id')
|
||||
OR (column_name='user_id' AND referenced_table_name='users' AND referenced_column_name='id'))`).Scan(&references); err != nil {
|
||||
return fmt.Errorf("检查成员外键失败:%w", err)
|
||||
}
|
||||
if err := db.QueryRowContext(ctx, `SELECT COUNT(*) FROM information_schema.key_column_usage
|
||||
WHERE table_schema=DATABASE() AND table_name='project_members' AND constraint_name='PRIMARY'
|
||||
AND ((ordinal_position=1 AND column_name='project_id') OR (ordinal_position=2 AND column_name='user_id')
|
||||
OR (ordinal_position=3 AND column_name='role'))`).Scan(&primaryColumns); err != nil {
|
||||
return fmt.Errorf("检查成员主键失败:%w", err)
|
||||
}
|
||||
if userCharset != charset || userCollation != collation || references != 2 || primaryColumns != 3 ||
|
||||
roleType != "enum('project_admin','certificate_admin','deployment_admin','dns_admin','audit_viewer','read_only')" {
|
||||
return fmt.Errorf("既有项目成员表结构不兼容,拒绝登记迁移版本")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func installSQLiteProjectMemberGuards(ctx context.Context, tx *sql.Tx) error {
|
||||
// 与既有资源约束一致,不依赖连接级外键和递归触发器开关。
|
||||
for _, event := range []string{"INSERT", "UPDATE"} {
|
||||
statement := fmt.Sprintf(`CREATE TRIGGER scert_members_reference_%s BEFORE %s ON project_members
|
||||
WHEN NOT EXISTS (SELECT 1 FROM projects WHERE id = NEW.project_id)
|
||||
OR NOT EXISTS (SELECT 1 FROM users WHERE id = NEW.user_id)
|
||||
BEGIN SELECT RAISE(ABORT, '项目或用户不存在'); END`, event, event)
|
||||
if _, err := tx.ExecContext(ctx, statement); err != nil {
|
||||
return fmt.Errorf("建立成员引用检查失败:%w", err)
|
||||
}
|
||||
}
|
||||
for _, parent := range []struct{ table, column string }{{"projects", "project_id"}, {"users", "user_id"}} {
|
||||
// 用户名、邮箱等唯一键替换也可能隐式删除另一个账户;成员仍在时禁止该替换。
|
||||
conflict := "p.id = NEW.id OR p.rowid = NEW.rowid"
|
||||
// 未显式指定行号时,插入前 NEW.rowid 可为 -1;不能误拒绝正常新增。
|
||||
insertConflict := "p.id = NEW.id OR (NEW.rowid != -1 AND p.rowid = NEW.rowid)"
|
||||
if parent.table == "users" {
|
||||
conflict += " OR p.username = NEW.username OR (NEW.email != '' AND p.email = NEW.email)"
|
||||
insertConflict += " OR p.username = NEW.username OR (NEW.email != '' AND p.email = NEW.email)"
|
||||
}
|
||||
statements := []string{
|
||||
fmt.Sprintf(`CREATE TRIGGER scert_members_%s_delete BEFORE DELETE ON %s
|
||||
WHEN EXISTS (SELECT 1 FROM project_members WHERE %s = OLD.id)
|
||||
BEGIN SELECT RAISE(ABORT, '请先撤销项目成员关系'); END`, parent.table, parent.table, parent.column),
|
||||
fmt.Sprintf(`CREATE TRIGGER scert_members_%s_insert BEFORE INSERT ON %s
|
||||
WHEN EXISTS (SELECT 1 FROM %s p JOIN project_members m ON m.%s = p.id WHERE %s)
|
||||
BEGIN SELECT RAISE(ABORT, '不能替换已有项目成员关联的记录'); END`, parent.table, parent.table, parent.table, parent.column, insertConflict),
|
||||
fmt.Sprintf(`CREATE TRIGGER scert_members_%s_update BEFORE UPDATE ON %s
|
||||
WHEN (NEW.id != OLD.id AND EXISTS (SELECT 1 FROM project_members WHERE %s = OLD.id))
|
||||
OR EXISTS (SELECT 1 FROM %s p JOIN project_members m ON m.%s = p.id WHERE p.id != OLD.id AND (%s))
|
||||
BEGIN SELECT RAISE(ABORT, '不能改变项目成员关联的记录标识'); END`, parent.table, parent.table, parent.column, parent.table, parent.column, conflict),
|
||||
fmt.Sprintf(`CREATE TRIGGER scert_members_%s_after_insert AFTER INSERT ON %s
|
||||
WHEN EXISTS (SELECT 1 FROM project_members m LEFT JOIN %s p ON p.id = m.%s WHERE p.id IS NULL)
|
||||
BEGIN SELECT RAISE(ABORT, '替换操作破坏项目成员关系'); END`, parent.table, parent.table, parent.table, parent.column),
|
||||
fmt.Sprintf(`CREATE TRIGGER scert_members_%s_after_update AFTER UPDATE ON %s
|
||||
WHEN EXISTS (SELECT 1 FROM project_members m LEFT JOIN %s p ON p.id = m.%s WHERE p.id IS NULL)
|
||||
BEGIN SELECT RAISE(ABORT, '替换操作破坏项目成员关系'); END`, parent.table, parent.table, parent.table, parent.column),
|
||||
}
|
||||
for _, statement := range statements {
|
||||
if _, err := tx.ExecContext(ctx, statement); err != nil {
|
||||
return fmt.Errorf("建立成员父记录保护失败:%w", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,295 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func prepareProjectMemberMigration(t *testing.T, db *sql.DB, driver string) {
|
||||
t.Helper()
|
||||
if _, err := db.ExecContext(t.Context(), migrationTableSQL(driver)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for version := 1; version <= 13; version++ {
|
||||
if err := applyMigration(t.Context(), db, driver, version); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
for _, query := range []string{
|
||||
`INSERT INTO projects (id,name,description) VALUES ('member-project','成员项目','保留资料'),('other-project','其他项目','')`,
|
||||
`INSERT INTO users (id,username,email,password_hash,role,status) VALUES
|
||||
('member-user','member-user','member@example.invalid','test-only','user','active'),
|
||||
('other-user','other-user','other@example.invalid','test-only','admin','active')`,
|
||||
`INSERT INTO tasks (id,domain_id,task_type,status,message) VALUES ('historical-task','deleted-domain','deploy','success','保留历史')`,
|
||||
} {
|
||||
if _, err := db.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func assertProjectMemberMigration(t *testing.T, db *sql.DB) {
|
||||
t.Helper()
|
||||
for _, tc := range []struct{ query, want string }{
|
||||
{`SELECT description FROM projects WHERE id='member-project'`, "保留资料"},
|
||||
{`SELECT message FROM tasks WHERE id='historical-task'`, "保留历史"},
|
||||
{`SELECT role FROM users WHERE id='other-user'`, "admin"},
|
||||
} {
|
||||
var actual string
|
||||
if err := db.QueryRowContext(t.Context(), tc.query).Scan(&actual); err != nil || actual != tc.want {
|
||||
t.Fatalf("迁移改变历史数据:%q,%v", actual, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteProjectMembersMigration(t *testing.T) {
|
||||
for _, foreignKeys := range []int{0, 1} {
|
||||
for _, recursive := range []int{0, 1} {
|
||||
t.Run(fmt.Sprintf("foreign_keys_%d_recursive_%d", foreignKeys, recursive), func(t *testing.T) {
|
||||
db, err := Open(t.Context(), sqliteBusinessUpgradeConfig(t))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer db.Close()
|
||||
db.DB.SetMaxOpenConns(1)
|
||||
prepareProjectMemberMigration(t, db.DB, "sqlite")
|
||||
for _, query := range []string{fmt.Sprintf("PRAGMA foreign_keys=%d", foreignKeys), fmt.Sprintf("PRAGMA recursive_triggers=%d", recursive)} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var count int
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT COUNT(*) FROM project_members").Scan(&count); err != nil || count != 0 {
|
||||
t.Fatalf("迁移自动授权:%d,%v", count, err)
|
||||
}
|
||||
if _, err := db.DB.ExecContext(t.Context(), `INSERT INTO project_members(project_id,user_id,role) VALUES ('member-project','member-user','read_only')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, query := range []string{
|
||||
`DELETE FROM projects WHERE id='member-project'`,
|
||||
`DELETE FROM users WHERE id='member-user'`,
|
||||
`UPDATE projects SET id='renamed' WHERE id='member-project'`,
|
||||
`UPDATE users SET id='renamed' WHERE id='member-user'`,
|
||||
`INSERT OR REPLACE INTO projects(id,name,description) VALUES ('member-project','替换','')`,
|
||||
`INSERT OR REPLACE INTO projects(rowid,id,name,description) SELECT rowid,'replacement','替换','' FROM projects WHERE id='member-project'`,
|
||||
`UPDATE OR REPLACE projects SET id='member-project' WHERE id='other-project'`,
|
||||
`UPDATE OR REPLACE projects SET rowid=(SELECT rowid FROM projects WHERE id='member-project') WHERE id='other-project'`,
|
||||
`INSERT OR REPLACE INTO users(id,username,email,password_hash,role) VALUES ('replacement','member-user','new@example.invalid','test-only','user')`,
|
||||
`INSERT OR REPLACE INTO users(id,username,email,password_hash,role) VALUES ('replacement','new-user','member@example.invalid','test-only','user')`,
|
||||
`INSERT OR REPLACE INTO users(id,username,email,password_hash,role) VALUES ('member-user','new-user','new@example.invalid','test-only','user')`,
|
||||
`INSERT OR REPLACE INTO users(rowid,id,username,email,password_hash,role) SELECT rowid,'replacement','new-user','new@example.invalid','test-only','user' FROM users WHERE id='member-user'`,
|
||||
`UPDATE OR REPLACE users SET id='member-user' WHERE id='other-user'`,
|
||||
`UPDATE OR REPLACE users SET username='member-user' WHERE id='other-user'`,
|
||||
`UPDATE OR REPLACE users SET email='member@example.invalid' WHERE id='other-user'`,
|
||||
`UPDATE OR REPLACE users SET rowid=(SELECT rowid FROM users WHERE id='member-user') WHERE id='other-user'`,
|
||||
`UPDATE project_members SET project_id='missing'`,
|
||||
`UPDATE project_members SET user_id='missing'`,
|
||||
`UPDATE project_members SET role='super_admin'`,
|
||||
`INSERT INTO project_members(project_id,user_id,role) VALUES ('missing','member-user','read_only')`,
|
||||
`INSERT INTO project_members(project_id,user_id,role) VALUES ('member-project','missing','read_only')`,
|
||||
} {
|
||||
t.Run(fmt.Sprintf("reject_%02d", count), func(t *testing.T) {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err == nil {
|
||||
t.Fatalf("危险写入未拒绝:%s", query)
|
||||
}
|
||||
assertProjectMemberMigration(t, db.DB)
|
||||
})
|
||||
count++
|
||||
}
|
||||
for _, query := range []string{
|
||||
`UPDATE users SET username='renamed-user', email='renamed@example.invalid',status='disabled' WHERE id='member-user'`,
|
||||
`UPDATE projects SET name='更名' WHERE id='member-project'`,
|
||||
`UPDATE project_members SET role='audit_viewer'`,
|
||||
} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if err := Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var role string
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT role FROM project_members").Scan(&role); err != nil || role != "audit_viewer" {
|
||||
t.Fatalf("重试改变角色:%q,%v", role, err)
|
||||
}
|
||||
for _, query := range []string{`DELETE FROM project_members`, `DELETE FROM users WHERE id='member-user'`, `DELETE FROM projects WHERE id='member-project'`} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteProjectMembersMigrationFailure(t *testing.T) {
|
||||
for _, fault := range []string{"version", "trigger_collision"} {
|
||||
t.Run(fault, func(t *testing.T) {
|
||||
db, err := Open(t.Context(), sqliteBusinessUpgradeConfig(t))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer db.Close()
|
||||
prepareProjectMemberMigration(t, db.DB, "sqlite")
|
||||
query := `CREATE TRIGGER fail_member_version BEFORE INSERT ON schema_migrations WHEN NEW.version=14 BEGIN SELECT RAISE(ABORT,'test-only'); END`
|
||||
drop := "DROP TRIGGER fail_member_version"
|
||||
if fault == "trigger_collision" {
|
||||
query = `CREATE TRIGGER scert_members_users_delete BEFORE DELETE ON users BEGIN SELECT 1; END`
|
||||
drop = "DROP TRIGGER scert_members_users_delete"
|
||||
}
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Migrate(t.Context(), db.DB, "sqlite"); err == nil {
|
||||
t.Fatal("故障未阻断迁移")
|
||||
}
|
||||
var count int
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT COUNT(*) FROM sqlite_master WHERE name='project_members'").Scan(&count); err != nil || count != 0 {
|
||||
t.Fatalf("成员表未回滚:%d,%v", count, err)
|
||||
}
|
||||
if version, err := currentMigrationVersion(t.Context(), db.DB); err != nil || version != 13 {
|
||||
t.Fatalf("错误登记版本:%d,%v", version, err)
|
||||
}
|
||||
assertProjectMemberMigration(t, db.DB)
|
||||
if _, err := db.DB.ExecContext(t.Context(), drop); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertProjectMemberMigration(t, db.DB)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSQLiteProjectMembersReplacementEdges(t *testing.T) {
|
||||
for _, scenario := range []string{"negative_rowid", "empty_email", "custom_unique_update"} {
|
||||
t.Run(scenario, func(t *testing.T) {
|
||||
db, err := Open(t.Context(), sqliteBusinessUpgradeConfig(t))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer db.Close()
|
||||
db.DB.SetMaxOpenConns(1)
|
||||
prepareProjectMemberMigration(t, db.DB, "sqlite")
|
||||
if err := Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, query := range []string{"PRAGMA foreign_keys=0", "PRAGMA recursive_triggers=0",
|
||||
`INSERT INTO project_members(project_id,user_id,role) VALUES ('member-project','member-user','read_only')`} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if scenario == "negative_rowid" {
|
||||
for _, query := range []string{
|
||||
`UPDATE users SET rowid=-1 WHERE id='member-user'`,
|
||||
`UPDATE projects SET rowid=-1 WHERE id='member-project'`,
|
||||
`INSERT INTO users(id,username,email,password_hash,role) VALUES ('new-user','new-user','new@example.invalid','test-only','user')`,
|
||||
`INSERT INTO projects(id,name,description) VALUES ('new-project','正常新增','')`,
|
||||
} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatalf("正常写入被错误阻止:%s,%v", query, err)
|
||||
}
|
||||
}
|
||||
for _, query := range []string{
|
||||
`INSERT OR REPLACE INTO users(rowid,id,username,email,password_hash,role) VALUES (-1,'replacement','replacement','replacement@example.invalid','test-only','user')`,
|
||||
`INSERT OR REPLACE INTO projects(rowid,id,name,description) VALUES (-1,'replacement','替换','')`,
|
||||
} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err == nil {
|
||||
t.Fatalf("负行号替换未拒绝:%s", query)
|
||||
}
|
||||
}
|
||||
} else if scenario == "empty_email" {
|
||||
// 既有邮箱索引只约束非空值;有项目角色的无邮箱账户不能阻止新增其他无邮箱账户。
|
||||
for _, query := range []string{
|
||||
`UPDATE users SET email='' WHERE id='member-user'`,
|
||||
`INSERT INTO users(id,username,email,password_hash,role) VALUES ('new-user','new-user','','test-only','user')`,
|
||||
`UPDATE users SET email='' WHERE id='other-user'`,
|
||||
} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatalf("正常无邮箱账户写入被拒绝:%s,%v", query, err)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for _, query := range []string{
|
||||
`ALTER TABLE users ADD COLUMN extra_tag TEXT`,
|
||||
`CREATE UNIQUE INDEX idx_users_extra_tag ON users(extra_tag)`,
|
||||
`UPDATE users SET extra_tag='held' WHERE id='member-user'`,
|
||||
} {
|
||||
if _, err := db.DB.ExecContext(t.Context(), query); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if _, err := db.DB.ExecContext(t.Context(), `UPDATE OR REPLACE users SET extra_tag='held' WHERE id='other-user'`); err == nil {
|
||||
t.Fatal("扩展唯一索引替换绕过了项目成员引用保护")
|
||||
}
|
||||
}
|
||||
assertProjectMemberMigration(t, db.DB)
|
||||
var username string
|
||||
if err := db.DB.QueryRowContext(t.Context(), "SELECT username FROM users WHERE id='member-user'").Scan(&username); err != nil || username != "member-user" {
|
||||
t.Fatalf("关联用户被替换或丢失:%q,%v", username, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestMySQLRealProjectMembersMigrationRetry(t *testing.T) {
|
||||
fixture := startRealMySQL(t)
|
||||
db := fixture.database(t)
|
||||
ctx := t.Context()
|
||||
prepareProjectMemberMigration(t, db.DB, "mysql")
|
||||
var schema string
|
||||
if err := db.DB.QueryRowContext(ctx, "SELECT DATABASE()").Scan(&schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
schema = "`" + strings.ReplaceAll(schema, "`", "``") + "`"
|
||||
// 特意改变当前库默认字符集,成员外键仍必须匹配历史 users.id 的实际类型。
|
||||
if _, err := fixture.admin.ExecContext(ctx, "ALTER DATABASE "+schema+" CHARACTER SET latin1 COLLATE latin1_bin"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := fixture.admin.ExecContext(ctx, `CREATE TRIGGER `+schema+`.fail_member_version BEFORE INSERT ON `+schema+`.schema_migrations
|
||||
FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT='test-only'`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Migrate(ctx, db.DB, "mysql"); err == nil {
|
||||
t.Fatal("版本登记失败未阻断迁移")
|
||||
}
|
||||
if version, err := currentMigrationVersion(ctx, db.DB); err != nil || version != 13 {
|
||||
t.Fatalf("错误登记版本:%d,%v", version, err)
|
||||
}
|
||||
if _, err := db.DB.ExecContext(ctx, `INSERT INTO project_members(project_id,user_id,role) VALUES ('member-project','member-user','dns_admin')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := fixture.admin.ExecContext(ctx, "DROP TRIGGER "+schema+".fail_member_version"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// 残缺同名表不能被 IF NOT EXISTS 静默接受;恢复约束后才允许重试。
|
||||
if _, err := db.DB.ExecContext(ctx, "ALTER TABLE project_members DROP FOREIGN KEY fk_project_members_user"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := Migrate(ctx, db.DB, "mysql"); err == nil {
|
||||
t.Fatal("残缺成员表被当作迁移成功")
|
||||
}
|
||||
if version, err := currentMigrationVersion(ctx, db.DB); err != nil || version != 13 {
|
||||
t.Fatalf("残缺结构错误登记版本:%d,%v", version, err)
|
||||
}
|
||||
if _, err := db.DB.ExecContext(ctx, "ALTER TABLE project_members ADD CONSTRAINT fk_project_members_user FOREIGN KEY (user_id) REFERENCES users(id)"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for round := 0; round < 2; round++ {
|
||||
if err := Migrate(ctx, db.DB, "mysql"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
var role string
|
||||
if err := db.DB.QueryRowContext(ctx, "SELECT role FROM project_members").Scan(&role); err != nil || role != "dns_admin" {
|
||||
t.Fatalf("重试覆盖成员:%q,%v", role, err)
|
||||
}
|
||||
assertProjectMemberMigration(t, db.DB)
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package domain
|
||||
|
||||
// ProjectRole 是项目内的能力集合,与登录角色和用户分组相互独立。
|
||||
type ProjectRole string
|
||||
|
||||
const (
|
||||
ProjectRoleAdmin ProjectRole = "project_admin"
|
||||
ProjectRoleCertificateAdmin ProjectRole = "certificate_admin"
|
||||
ProjectRoleDeploymentAdmin ProjectRole = "deployment_admin"
|
||||
ProjectRoleDNSAdmin ProjectRole = "dns_admin"
|
||||
ProjectRoleAuditViewer ProjectRole = "audit_viewer"
|
||||
ProjectRoleReadOnly ProjectRole = "read_only"
|
||||
)
|
||||
|
||||
type ProjectPermission string
|
||||
|
||||
const (
|
||||
PermissionProjectRead ProjectPermission = "project.read"
|
||||
PermissionProjectManage ProjectPermission = "project.manage"
|
||||
PermissionMembersManage ProjectPermission = "members.manage"
|
||||
PermissionCertificateRead ProjectPermission = "certificate.read"
|
||||
PermissionCertificateManage ProjectPermission = "certificate.manage"
|
||||
PermissionPrivateKeyRead ProjectPermission = "certificate.private_key.read"
|
||||
PermissionServerRead ProjectPermission = "server.read"
|
||||
PermissionServerManage ProjectPermission = "server.manage"
|
||||
PermissionDeploymentRead ProjectPermission = "deployment.read"
|
||||
PermissionDeploymentExecute ProjectPermission = "deployment.execute"
|
||||
PermissionDeploymentRollback ProjectPermission = "deployment.rollback"
|
||||
PermissionDNSRead ProjectPermission = "dns.read"
|
||||
PermissionDNSManage ProjectPermission = "dns.manage"
|
||||
PermissionDNSCredentialUse ProjectPermission = "dns.credential.use"
|
||||
PermissionAuditRead ProjectPermission = "audit.read"
|
||||
PermissionTaskRead ProjectPermission = "task.read"
|
||||
PermissionTaskCancel ProjectPermission = "task.cancel"
|
||||
)
|
||||
|
||||
func (r ProjectRole) Valid() bool {
|
||||
switch r {
|
||||
case ProjectRoleAdmin, ProjectRoleCertificateAdmin, ProjectRoleDeploymentAdmin,
|
||||
ProjectRoleDNSAdmin, ProjectRoleAuditViewer, ProjectRoleReadOnly:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (p ProjectPermission) Valid() bool {
|
||||
switch p {
|
||||
case PermissionProjectRead, PermissionProjectManage, PermissionMembersManage,
|
||||
PermissionCertificateRead, PermissionCertificateManage, PermissionPrivateKeyRead,
|
||||
PermissionServerRead, PermissionServerManage, PermissionDeploymentRead,
|
||||
PermissionDeploymentExecute, PermissionDeploymentRollback, PermissionDNSRead,
|
||||
PermissionDNSManage, PermissionDNSCredentialUse, PermissionAuditRead,
|
||||
PermissionTaskRead, PermissionTaskCancel:
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Allows 只计算项目角色能力;调用方还必须核对实时账户状态和资源归属。
|
||||
func (r ProjectRole) Allows(p ProjectPermission) bool {
|
||||
if !r.Valid() || !p.Valid() {
|
||||
return false
|
||||
}
|
||||
if r == ProjectRoleAdmin || p == PermissionProjectRead {
|
||||
return true
|
||||
}
|
||||
switch r {
|
||||
case ProjectRoleCertificateAdmin:
|
||||
return p == PermissionCertificateRead || p == PermissionCertificateManage || p == PermissionPrivateKeyRead
|
||||
case ProjectRoleDeploymentAdmin:
|
||||
return p == PermissionCertificateRead || p == PermissionServerRead || p == PermissionServerManage ||
|
||||
p == PermissionDeploymentRead || p == PermissionDeploymentExecute || p == PermissionDeploymentRollback
|
||||
case ProjectRoleDNSAdmin:
|
||||
return p == PermissionDNSRead || p == PermissionDNSManage || p == PermissionDNSCredentialUse
|
||||
case ProjectRoleAuditViewer:
|
||||
return p == PermissionAuditRead || p == PermissionTaskRead
|
||||
case ProjectRoleReadOnly:
|
||||
return p == PermissionCertificateRead || p == PermissionServerRead ||
|
||||
p == PermissionDeploymentRead || p == PermissionDNSRead || p == PermissionTaskRead
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package domain
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestProjectRolePermissionMatrix(t *testing.T) {
|
||||
permissions := []ProjectPermission{PermissionProjectRead, PermissionProjectManage, PermissionMembersManage,
|
||||
PermissionCertificateRead, PermissionCertificateManage, PermissionPrivateKeyRead, PermissionServerRead,
|
||||
PermissionServerManage, PermissionDeploymentRead, PermissionDeploymentExecute, PermissionDeploymentRollback,
|
||||
PermissionDNSRead, PermissionDNSManage, PermissionDNSCredentialUse, PermissionAuditRead, PermissionTaskRead,
|
||||
PermissionTaskCancel, "", "system.manage", "certificate.private_key.export"}
|
||||
cases := []struct {
|
||||
role ProjectRole
|
||||
allowed []ProjectPermission
|
||||
}{
|
||||
{ProjectRoleAdmin, permissions[:17]},
|
||||
{ProjectRoleCertificateAdmin, []ProjectPermission{PermissionProjectRead, PermissionCertificateRead, PermissionCertificateManage, PermissionPrivateKeyRead}},
|
||||
{ProjectRoleDeploymentAdmin, []ProjectPermission{PermissionProjectRead, PermissionCertificateRead, PermissionServerRead, PermissionServerManage, PermissionDeploymentRead, PermissionDeploymentExecute, PermissionDeploymentRollback}},
|
||||
{ProjectRoleDNSAdmin, []ProjectPermission{PermissionProjectRead, PermissionDNSRead, PermissionDNSManage, PermissionDNSCredentialUse}},
|
||||
{ProjectRoleAuditViewer, []ProjectPermission{PermissionProjectRead, PermissionAuditRead, PermissionTaskRead}},
|
||||
{ProjectRoleReadOnly, []ProjectPermission{PermissionProjectRead, PermissionCertificateRead, PermissionServerRead, PermissionDeploymentRead, PermissionDNSRead, PermissionTaskRead}},
|
||||
{"", nil}, {"super_admin", nil}, {"PROJECT_ADMIN", nil},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(string(tc.role), func(t *testing.T) {
|
||||
for _, p := range permissions {
|
||||
want := false
|
||||
for _, granted := range tc.allowed {
|
||||
want = want || granted == p
|
||||
}
|
||||
if got := tc.role.Allows(p); got != want {
|
||||
t.Errorf("角色 %q 操作 %q 判定为 %t,期望 %t", tc.role, p, got, want)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
var ErrProjectAccessDenied = errors.New("无权访问项目或执行此操作")
|
||||
|
||||
type ProjectAuthorizer interface {
|
||||
AuthorizeProject(context.Context, string, string, domain.ProjectPermission) error
|
||||
}
|
||||
|
||||
type SQLProjectMemberRepository struct {
|
||||
db *sql.DB
|
||||
driver string
|
||||
}
|
||||
|
||||
var _ ProjectAuthorizer = (*SQLProjectMemberRepository)(nil)
|
||||
|
||||
func NewSQLProjectMemberRepository(db *sql.DB, driver ...string) *SQLProjectMemberRepository {
|
||||
return &SQLProjectMemberRepository{db: db, driver: repositoryDriver(driver)}
|
||||
}
|
||||
|
||||
func (r *SQLProjectMemberRepository) ensureDB() error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("数据库连接不能为空")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AuthorizeProject 每次从数据库读取账户、项目和成员关系,不信任请求中的角色或用户分组。
|
||||
// 这里只判定指定项目,业务入口仍须从真实资源取得项目,并在执行副作用前重新判权。
|
||||
func (r *SQLProjectMemberRepository) AuthorizeProject(ctx context.Context, userID, projectID string, permission domain.ProjectPermission) error {
|
||||
if err := r.ensureDB(); err != nil {
|
||||
return err
|
||||
}
|
||||
if !permission.Valid() || strings.TrimSpace(userID) == "" || strings.TrimSpace(projectID) == "" {
|
||||
return ErrProjectAccessDenied
|
||||
}
|
||||
rows, err := r.db.QueryContext(ctx, Rebind(r.driver, `SELECT u.role, u.status, COALESCE(m.role, '')
|
||||
FROM users u JOIN projects p ON p.id = ?
|
||||
LEFT JOIN project_members m ON m.project_id = p.id AND m.user_id = u.id
|
||||
WHERE u.id = ?`), strings.TrimSpace(projectID), strings.TrimSpace(userID))
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取项目权限失败:%w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
allowed := false
|
||||
for rows.Next() {
|
||||
var userRole, status string
|
||||
var role domain.ProjectRole
|
||||
if err := rows.Scan(&userRole, &status, &role); err != nil {
|
||||
return fmt.Errorf("读取项目成员失败:%w", err)
|
||||
}
|
||||
if status != UserStatusActive {
|
||||
continue
|
||||
}
|
||||
switch userRole {
|
||||
case UserRoleSuperAdmin:
|
||||
allowed = true
|
||||
case UserRoleAdmin, UserRoleUser:
|
||||
// 普通账户即使具有项目管理角色,也不能直接读取完整证书私钥。
|
||||
if permission == domain.PermissionPrivateKeyRead && userRole == UserRoleUser {
|
||||
continue
|
||||
}
|
||||
allowed = allowed || role.Allows(permission)
|
||||
}
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return fmt.Errorf("读取项目权限结果失败:%w", err)
|
||||
}
|
||||
if !allowed {
|
||||
return ErrProjectAccessDenied
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// 授权与写入在同一条语句内判定,避免先检查再写入之间撤权导致越权。
|
||||
// 系统管理员必须是当前有效超级管理员;普通管理员不会因用户组或全局角色自动获得项目权限。
|
||||
const projectManagerPredicate = `EXISTS (SELECT 1 FROM users a WHERE a.id = ? AND a.status = 'active'
|
||||
AND (a.role = 'super_admin' OR (a.role IN ('admin', 'user') AND EXISTS
|
||||
(SELECT 1 FROM project_members manager WHERE manager.project_id = ?
|
||||
AND manager.user_id = a.id AND manager.role = 'project_admin'))))`
|
||||
|
||||
func (r *SQLProjectMemberRepository) GrantProjectRole(ctx context.Context, actorID, projectID, userID string, role domain.ProjectRole) error {
|
||||
if err := r.ensureDB(); err != nil {
|
||||
return err
|
||||
}
|
||||
actorID, projectID, userID = strings.TrimSpace(actorID), strings.TrimSpace(projectID), strings.TrimSpace(userID)
|
||||
if actorID == "" || projectID == "" || userID == "" || !role.Valid() {
|
||||
return ErrProjectAccessDenied
|
||||
}
|
||||
result, err := r.db.ExecContext(ctx, Rebind(r.driver, `INSERT INTO project_members (project_id, user_id, role, created_at)
|
||||
SELECT p.id, u.id, ?, ? FROM projects p JOIN users u ON u.id = ? AND u.status = 'active'
|
||||
WHERE p.id = ? AND `+projectManagerPredicate), role, time.Now().UTC(), userID, projectID, actorID, projectID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("授予项目角色失败:%w", err)
|
||||
}
|
||||
return projectMemberWriteResult(result)
|
||||
}
|
||||
|
||||
func (r *SQLProjectMemberRepository) RevokeProjectRole(ctx context.Context, actorID, projectID, userID string, role domain.ProjectRole) error {
|
||||
if err := r.ensureDB(); err != nil {
|
||||
return err
|
||||
}
|
||||
actorID, projectID, userID = strings.TrimSpace(actorID), strings.TrimSpace(projectID), strings.TrimSpace(userID)
|
||||
if actorID == "" || projectID == "" || userID == "" || !role.Valid() {
|
||||
return ErrProjectAccessDenied
|
||||
}
|
||||
query := `DELETE FROM project_members WHERE project_id = ? AND user_id = ? AND role = ? AND ` + projectManagerPredicate
|
||||
if r.driver == "mysql" {
|
||||
// MySQL 不允许普通子查询读取正在删除的表,使用自连接完成同一语句内的判权。
|
||||
query = `DELETE target FROM project_members target
|
||||
JOIN users a ON a.id = ? AND a.status = 'active'
|
||||
LEFT JOIN project_members manager ON manager.project_id = target.project_id
|
||||
AND manager.user_id = a.id AND manager.role = 'project_admin'
|
||||
WHERE target.project_id = ? AND target.user_id = ? AND target.role = ?
|
||||
AND (a.role = 'super_admin' OR (a.role IN ('admin', 'user') AND manager.user_id IS NOT NULL))`
|
||||
result, err := r.db.ExecContext(ctx, query, actorID, projectID, userID, role)
|
||||
if err != nil {
|
||||
return fmt.Errorf("撤销项目角色失败:%w", err)
|
||||
}
|
||||
return projectMemberWriteResult(result)
|
||||
}
|
||||
result, err := r.db.ExecContext(ctx, Rebind(r.driver, query), projectID, userID, role, actorID, projectID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("撤销项目角色失败:%w", err)
|
||||
}
|
||||
return projectMemberWriteResult(result)
|
||||
}
|
||||
|
||||
func projectMemberWriteResult(result sql.Result) error {
|
||||
count, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取项目成员变更结果失败:%w", err)
|
||||
}
|
||||
if count != 1 {
|
||||
return ErrProjectAccessDenied
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"path/filepath"
|
||||
"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"
|
||||
)
|
||||
|
||||
func TestProjectMembersSQLite(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir()).Database
|
||||
cfg.DSN = filepath.Join(t.TempDir(), "members.db")
|
||||
db, err := database.Open(t.Context(), cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
if err := database.Migrate(t.Context(), db.DB, cfg.Driver); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
checkProjectMembers(t, db.DB, cfg.Driver)
|
||||
}
|
||||
|
||||
func TestProjectMembersMySQLReal(t *testing.T) {
|
||||
server := mysqltest.New(t)
|
||||
cfg := server.Database(t)
|
||||
db, err := database.Open(t.Context(), cfg)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
if err := database.Migrate(t.Context(), db.DB, cfg.Driver); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
checkProjectMembers(t, db.DB, cfg.Driver)
|
||||
}
|
||||
|
||||
func checkProjectMembers(t *testing.T, db *sql.DB, driver string) {
|
||||
t.Helper()
|
||||
ctx := t.Context()
|
||||
repo := NewSQLProjectMemberRepository(db, driver)
|
||||
projects := NewSQLProjectRepository(db, driver)
|
||||
for _, id := range []string{"project-a", "project-b"} {
|
||||
if err := projects.CreateProject(ctx, domain.Project{ID: id, Name: id}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
for _, u := range []struct{ id, role, status string }{
|
||||
{"root-test", UserRoleSuperAdmin, UserStatusActive},
|
||||
{"manager", UserRoleUser, UserStatusActive},
|
||||
{"viewer", UserRoleUser, UserStatusActive},
|
||||
{"global-admin", UserRoleAdmin, UserStatusActive},
|
||||
{"outsider", UserRoleUser, UserStatusActive},
|
||||
{"disabled", UserRoleUser, UserStatusDisabled},
|
||||
} {
|
||||
_, err := db.ExecContext(ctx, Rebind(driver, `INSERT INTO users (id, username, email, password_hash, role, status, groups_json)
|
||||
VALUES (?, ?, ?, 'test-only-no-login', ?, ?, '["same-group"]')`), u.id, u.id, u.id+"@example.invalid", u.role, u.status)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
grant := func(actor, project, user string, role domain.ProjectRole) {
|
||||
t.Helper()
|
||||
if err := repo.GrantProjectRole(ctx, actor, project, user, role); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
check := func(user, project string, permission domain.ProjectPermission, allowed bool) {
|
||||
t.Helper()
|
||||
err := repo.AuthorizeProject(ctx, user, project, permission)
|
||||
if allowed && err != nil {
|
||||
t.Fatalf("预期允许 %s/%s/%s:%v", user, project, permission, err)
|
||||
}
|
||||
if !allowed && !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("预期拒绝 %s/%s/%s:%v", user, project, permission, err)
|
||||
}
|
||||
}
|
||||
t.Run("no_implicit_membership", func(t *testing.T) {
|
||||
var count int
|
||||
if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM project_members").Scan(&count); err != nil || count != 0 {
|
||||
t.Fatalf("迁移自动授予了权限:%d,%v", count, err)
|
||||
}
|
||||
for _, user := range []string{"manager", "global-admin", "outsider", "missing", "disabled"} {
|
||||
check(user, "default", domain.PermissionProjectRead, false)
|
||||
check(user, "project-a", domain.PermissionProjectRead, false)
|
||||
}
|
||||
check("root-test", "project-a", domain.PermissionProjectManage, true)
|
||||
check("root-test", "missing", domain.PermissionProjectRead, false)
|
||||
check("root-test", "project-a", "unknown", false)
|
||||
})
|
||||
grant("root-test", "project-a", "manager", domain.ProjectRoleAdmin)
|
||||
t.Run("project_admin_and_private_key_boundary", func(t *testing.T) {
|
||||
check("manager", "project-a", domain.PermissionMembersManage, true)
|
||||
check("manager", "project-a", domain.PermissionPrivateKeyRead, false)
|
||||
check("manager", "project-b", domain.PermissionProjectRead, false)
|
||||
grant("manager", "project-a", "viewer", domain.ProjectRoleReadOnly)
|
||||
check("viewer", "project-a", domain.PermissionCertificateRead, true)
|
||||
check("viewer", "project-a", domain.PermissionCertificateManage, false)
|
||||
check("outsider", "project-a", domain.PermissionCertificateRead, false)
|
||||
})
|
||||
t.Run("unauthorized_grants_and_invalid_targets", func(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
actor, project, user string
|
||||
role domain.ProjectRole
|
||||
}{
|
||||
{"viewer", "project-a", "viewer", domain.ProjectRoleAdmin},
|
||||
{"global-admin", "project-a", "viewer", domain.ProjectRoleAdmin},
|
||||
{"manager", "project-b", "viewer", domain.ProjectRoleAdmin},
|
||||
{"root-test", "missing", "viewer", domain.ProjectRoleAdmin},
|
||||
{"root-test", "project-a", "missing", domain.ProjectRoleAdmin},
|
||||
{"root-test", "project-a", "disabled", domain.ProjectRoleAdmin},
|
||||
{"root-test", "project-a", "viewer", "super_admin"},
|
||||
} {
|
||||
if err := repo.GrantProjectRole(ctx, tc.actor, tc.project, tc.user, tc.role); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("非法授予未拒绝:%+v,%v", tc, err)
|
||||
}
|
||||
}
|
||||
if err := repo.GrantProjectRole(ctx, "root-test", "project-a", "viewer", domain.ProjectRoleReadOnly); err == nil {
|
||||
t.Fatal("重复角色未拒绝")
|
||||
}
|
||||
check("viewer", "project-a", domain.PermissionMembersManage, false)
|
||||
})
|
||||
t.Run("multiple_roles_and_projects", func(t *testing.T) {
|
||||
grant("manager", "project-a", "viewer", domain.ProjectRoleDNSAdmin)
|
||||
grant("root-test", "project-b", "viewer", domain.ProjectRoleAuditViewer)
|
||||
check("viewer", "project-a", domain.PermissionDNSCredentialUse, true)
|
||||
check("viewer", "project-a", domain.PermissionCertificateRead, true)
|
||||
check("viewer", "project-a", domain.PermissionAuditRead, false)
|
||||
check("viewer", "project-b", domain.PermissionAuditRead, true)
|
||||
check("viewer", "project-b", domain.PermissionDNSCredentialUse, false)
|
||||
})
|
||||
t.Run("revocation_is_immediate_and_scoped", func(t *testing.T) {
|
||||
if err := repo.RevokeProjectRole(ctx, "viewer", "project-a", "manager", domain.ProjectRoleAdmin); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("越权撤销未拒绝:%v", err)
|
||||
}
|
||||
if err := repo.RevokeProjectRole(ctx, "manager", "project-b", "viewer", domain.ProjectRoleAuditViewer); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("跨项目撤销未拒绝:%v", err)
|
||||
}
|
||||
if err := repo.RevokeProjectRole(ctx, "manager", "project-a", "viewer", domain.ProjectRoleDNSAdmin); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("viewer", "project-a", domain.PermissionDNSCredentialUse, false)
|
||||
check("viewer", "project-a", domain.PermissionCertificateRead, true)
|
||||
check("viewer", "project-b", domain.PermissionAuditRead, true)
|
||||
if err := repo.RevokeProjectRole(ctx, "manager", "project-a", "manager", domain.ProjectRoleAdmin); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("manager", "project-a", domain.PermissionMembersManage, false)
|
||||
if err := repo.GrantProjectRole(ctx, "manager", "project-a", "manager", domain.ProjectRoleAdmin); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("撤权后可自行恢复:%v", err)
|
||||
}
|
||||
grant("root-test", "project-a", "manager", domain.ProjectRoleAdmin)
|
||||
})
|
||||
t.Run("disabled_and_demoted_accounts", func(t *testing.T) {
|
||||
grant("root-test", "project-a", "global-admin", domain.ProjectRoleCertificateAdmin)
|
||||
check("global-admin", "project-a", domain.PermissionPrivateKeyRead, true)
|
||||
if _, err := db.ExecContext(ctx, "UPDATE users SET role = 'user' WHERE id = 'global-admin'"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("global-admin", "project-a", domain.PermissionPrivateKeyRead, false)
|
||||
check("global-admin", "project-a", domain.PermissionCertificateManage, true)
|
||||
if _, err := db.ExecContext(ctx, "UPDATE users SET status = 'disabled' WHERE id = 'manager'"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("manager", "project-a", domain.PermissionProjectRead, false)
|
||||
if err := repo.GrantProjectRole(ctx, "manager", "project-a", "outsider", domain.ProjectRoleReadOnly); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("禁用账户仍可授予:%v", err)
|
||||
}
|
||||
if err := repo.RevokeProjectRole(ctx, "manager", "project-a", "viewer", domain.ProjectRoleReadOnly); !errors.Is(err, ErrProjectAccessDenied) {
|
||||
t.Fatalf("禁用账户仍可撤销:%v", err)
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, "UPDATE users SET status = 'active' WHERE id = 'manager'"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, "UPDATE users SET status = 'disabled' WHERE id = 'root-test'"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("root-test", "project-a", domain.PermissionMembersManage, false)
|
||||
if _, err := db.ExecContext(ctx, "UPDATE users SET status = 'active' WHERE id = 'root-test'"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
})
|
||||
t.Run("parent_references", func(t *testing.T) {
|
||||
if err := projects.DeleteProject(ctx, "project-b"); err == nil {
|
||||
t.Fatal("删除了仍有成员的项目")
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, "DELETE FROM users WHERE id = 'viewer'"); err == nil {
|
||||
t.Fatal("删除了仍有项目角色的用户")
|
||||
}
|
||||
for _, query := range []string{
|
||||
"INSERT INTO project_members(project_id,user_id,role) VALUES ('missing','viewer','read_only')",
|
||||
"INSERT INTO project_members(project_id,user_id,role) VALUES ('project-a','missing','read_only')",
|
||||
"UPDATE project_members SET user_id='missing' WHERE user_id='viewer'",
|
||||
"UPDATE project_members SET project_id='missing' WHERE user_id='viewer'",
|
||||
} {
|
||||
if _, err := db.ExecContext(ctx, query); err == nil {
|
||||
t.Fatalf("无效引用未拒绝:%s", query)
|
||||
}
|
||||
}
|
||||
if err := repo.RevokeProjectRole(ctx, "root-test", "project-b", "viewer", domain.ProjectRoleAuditViewer); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := projects.DeleteProject(ctx, "project-b"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
check("viewer", "project-b", domain.PermissionAuditRead, false)
|
||||
})
|
||||
t.Run("canceled_context", func(t *testing.T) {
|
||||
canceled, cancel := context.WithCancel(ctx)
|
||||
cancel()
|
||||
if err := repo.AuthorizeProject(canceled, "root-test", "project-a", domain.PermissionProjectRead); err == nil {
|
||||
t.Fatal("取消请求意外授权")
|
||||
}
|
||||
if err := repo.GrantProjectRole(canceled, "root-test", "project-a", "outsider", domain.ProjectRoleReadOnly); err == nil {
|
||||
t.Fatal("取消请求意外写入")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestProjectMembersNilDatabase(t *testing.T) {
|
||||
for _, repo := range []*SQLProjectMemberRepository{nil, NewSQLProjectMemberRepository(nil)} {
|
||||
if err := repo.AuthorizeProject(t.Context(), "user", "project", domain.PermissionProjectRead); err == nil {
|
||||
t.Fatal("空连接未拒绝")
|
||||
}
|
||||
if err := repo.GrantProjectRole(t.Context(), "actor", "project", "user", domain.ProjectRoleReadOnly); err == nil {
|
||||
t.Fatal("空连接未拒绝")
|
||||
}
|
||||
if err := repo.RevokeProjectRole(t.Context(), "actor", "project", "user", domain.ProjectRoleReadOnly); err == nil {
|
||||
t.Fatal("空连接未拒绝")
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user