Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(store)!: refuse a create-database upsert that rebinds an existing database (#21557)
Vincent Huanga3e3f4e43f02
diff --git a/backend/store/database.go b/backend/store/database.goindex 991392dc60..dc28e1e7b2 100644--- a/backend/store/database.go+++ b/backend/store/database.go@@ -318,17 +318,31 @@ func (s *Store) UpsertDatabase(ctx context.Context, create *DatabaseMessage) (*Dif err != nil {return err}+ // The SET overwrites project, environment and metadata; the WHERE keeps+ // a row in its own project and must stay in the statement so the refusal+ // is atomic with the write. A soft-deleted row is held too, not exempted:+ // `deleted` also marks a live database the instance's sync allowlist+ // excluded, which the store cannot tell from a freed name. The only+ // caller is the create-database task.query, args, err := qb.Q().Space(`INSERT INTO db (instance, project, environment, name, deleted, metadata)VALUES (?, ?, ?, ?, ?, ?)ON CONFLICT (instance, name) DO UPDATE SETproject = EXCLUDED.project, environment = EXCLUDED.environment,- name = EXCLUDED.name, metadata = EXCLUDED.metadata`,+ name = EXCLUDED.name, metadata = EXCLUDED.metadata+ WHERE db.project = EXCLUDED.project+ RETURNING name`,create.InstanceID, projectID, environment, create.DatabaseName, create.Deleted, metadata).ToSQL()if err != nil {return errors.Wrap(err, "failed to build sql")}- _, err = tx.ExecContext(ctx, query, args...)- return err+ var name string+ if err := tx.QueryRowContext(ctx, query, args...).Scan(&name); err != nil {+ if errors.Is(err, sql.ErrNoRows) {+ return common.Errorf(common.Invalid, "a database with this name already belongs to another project on this instance")+ }+ return err+ }+ return nil})if err != nil {return nil, errdiff --git a/backend/store/database_ownership_test.go b/backend/store/database_ownership_test.goindex 9168f9b24c..a08fb650be 100644--- a/backend/store/database_ownership_test.go+++ b/backend/store/database_ownership_test.go@@ -2,10 +2,12 @@ package store_testimport ("context"+ "sync""testing""github.com/stretchr/testify/require"+ "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/store")@@ -19,7 +21,8 @@ func TestDatabaseWritersRespectProjectInstanceOwnership(t *testing.T) {('project-c', 'default', 'Project C');INSERT INTO instance (resource_id, workspace, project) VALUES('project-instance', 'default', 'project-b'),- ('workspace-instance', 'default', NULL);+ ('workspace-instance', 'default', NULL),+ ('workspace-instance-2', 'default', NULL);`)ctx, s := fixture.ctx, fixture.store@@ -115,6 +118,121 @@ func TestDatabaseWritersRespectProjectInstanceOwnership(t *testing.T) {}}, &store.BatchUpdateDatabases{ProjectID: &projectB})require.NoError(t, err)require.Equal(t, projectB, getDatabaseProject(ctx, t, s, "workspace-instance", "independent"))++ // A create-database upsert cannot rebind a live database across projects; a+ // real move uses UpdateDatabase, allowed above.+ _, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance",+ DatabaseName: "independent",+ ProjectID: projectC,+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.Error(t, err)+ require.Equal(t, common.Invalid, common.ErrorCode(err))+ require.Equal(t, projectB, getDatabaseProject(ctx, t, s, "workspace-instance", "independent"))++ // A create-database task that re-runs against its own database must not be+ // refused, so the same-project upsert still succeeds.+ database, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance",+ DatabaseName: "independent",+ ProjectID: projectB,+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ require.Equal(t, projectB, database.ProjectID)++ // The guard keys on (instance, name): the same name on another instance is+ // a different database, so project C may create it there.+ database, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance-2",+ DatabaseName: "independent",+ ProjectID: projectC,+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ require.Equal(t, projectC, database.ProjectID)+ require.Equal(t, projectB, getDatabaseProject(ctx, t, s, "workspace-instance", "independent"))+}++// workspaceInstanceSeed seeds two projects and one workspace-level instance.+const workspaceInstanceSeed = `+ ALTER TABLE instance ADD COLUMN IF NOT EXISTS project TEXT REFERENCES project(resource_id);+ INSERT INTO project (resource_id, workspace, name) VALUES+ ('project-b', 'default', 'Project B'),+ ('project-c', 'default', 'Project C');+ INSERT INTO instance (resource_id, workspace, project) VALUES+ ('workspace-instance', 'default', NULL);+`++// TestWorkspaceInstanceUpsertDroppedNameStaysWithItsProject: a dropped name+// cannot be taken by another project, but the owning project may reuse it.+func TestWorkspaceInstanceUpsertDroppedNameStaysWithItsProject(t *testing.T) {+ t.Parallel()+ fixture := newStorePostgresFixture(t, workspaceInstanceSeed)+ ctx, s := fixture.ctx, fixture.store++ _, err := s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance", DatabaseName: "freed", ProjectID: "project-b",+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ deleted := true+ _, err = s.UpdateDatabase(ctx, &store.UpdateDatabaseMessage{+ InstanceID: "workspace-instance", DatabaseName: "freed", Deleted: &deleted,+ })+ require.NoError(t, err)++ // Another project cannot take the dropped name.+ _, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance", DatabaseName: "freed", ProjectID: "project-c",+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.Error(t, err)+ require.Equal(t, common.Invalid, common.ErrorCode(err))+ require.Equal(t, "project-b", getDatabaseProject(ctx, t, s, "workspace-instance", "freed"))++ // The owning project may re-create it.+ database, err := s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance", DatabaseName: "freed", ProjectID: "project-b",+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ require.Equal(t, "project-b", database.ProjectID)+}++// TestWorkspaceInstanceUpsertRaceKeepsOneOwner pins that the guard lives in the+// write, not in a prior read: two concurrent first-creates of one name from+// different projects cannot both win. Exactly one succeeds; the other is refused.+func TestWorkspaceInstanceUpsertRaceKeepsOneOwner(t *testing.T) {+ t.Parallel()+ fixture := newStorePostgresFixture(t, workspaceInstanceSeed)+ ctx, s := fixture.ctx, fixture.store++ upsert := func(project string) error {+ _, err := s.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "workspace-instance", DatabaseName: "racer", ProjectID: project,+ Metadata: &storepb.DatabaseMetadata{},+ })+ return err+ }+ var wg sync.WaitGroup+ errs := make([]error, 2)+ wg.Go(func() { errs[0] = upsert("project-b") })+ wg.Go(func() { errs[1] = upsert("project-c") })+ wg.Wait()++ winners := 0+ for _, err := range errs {+ if err == nil {+ winners+++ continue+ }+ require.Equal(t, common.Invalid, common.ErrorCode(err))+ }+ require.Equal(t, 1, winners, "exactly one create must win; errs: %v", errs)+ require.Contains(t, []string{"project-b", "project-c"},+ getDatabaseProject(ctx, t, s, "workspace-instance", "racer"))}func TestListDatabasesIncludesInstanceProject(t *testing.T) {diff --git a/backend/tests/create_database_takeover_test.go b/backend/tests/create_database_takeover_test.gonew file mode 100644index 0000000000..7d89a1b2e6--- /dev/null+++ b/backend/tests/create_database_takeover_test.go@@ -0,0 +1,103 @@+package tests++import (+ "context"+ "fmt"+ "testing"+ "time"++ "connectrpc.com/connect"+ "github.com/google/uuid"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/types/known/fieldmaskpb"++ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"+)++// TestCreateDatabasePlanCannotTakeOverAnotherProjectsDatabase drives a+// create-database plan that names a database already live in another project,+// as a Project Owner of the plan's project only. The task fails and the+// existing database keeps its project, environment and labels.+func TestCreateDatabasePlanCannotTakeOverAnotherProjectsDatabase(t *testing.T) {+ t.Parallel()+ ctl, ctx := startWorkspace(context.Background(), t)++ instance := createPgInstance(ctx, t, ctl, "takeover")+ victim := uniqueDB("victim")+ require.NoError(t, ctl.createDatabase(ctx, ctl.project, instance, nil, victim, ""))+ victimName := fmt.Sprintf("%s/databases/%s", instance.Name, victim)+ prod := "environments/prod"+ _, err := ctl.databaseServiceClient.UpdateDatabase(ctx, connect.NewRequest(&v1pb.UpdateDatabaseRequest{+ Database: &v1pb.Database{Name: victimName, Labels: map[string]string{"tier": "pci"}, Environment: &prod},+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"labels", "environment"}},+ }))+ require.NoError(t, err)+ before, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{Name: victimName}))+ require.NoError(t, err)++ // A sandbox project whose owner holds no role on the victim's project.+ sandbox, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: "sandbox",+ Project: &v1pb.Project{Title: "sandbox"},+ }))+ require.NoError(t, err)+ token := bot35CreateProjectUser(ctx, t, ctl, sandbox.Msg.Name, "roles/projectOwner", "owner")+ auth := connect.WithInterceptors(&authInterceptor{token: token})+ ownerDatabases := v1connect.NewDatabaseServiceClient(ctl.client, ctl.rootURL, auth)+ ownerPlans := v1connect.NewPlanServiceClient(ctl.client, ctl.rootURL, auth)+ ownerRollouts := v1connect.NewRolloutServiceClient(ctl.client, ctl.rootURL, auth)++ _, err = ownerDatabases.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{Name: victimName}))+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err), "the sandbox owner holds no role on the victim's project")++ // The owner drives the whole change: plan, rollout and task run.+ plan, err := ownerPlans.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{+ Parent: sandbox.Msg.Name,+ Plan: &v1pb.Plan{Title: "create", Specs: []*v1pb.Plan_Spec{{+ Id: uuid.NewString(),+ Config: &v1pb.Plan_Spec_CreateDatabaseConfig{CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{+ Target: instance.Name,+ Database: victim,+ CharacterSet: "UTF8",+ Collation: "en_US.UTF-8",+ Owner: "postgres",+ Environment: "environments/test",+ }},+ }}},+ }))+ require.NoError(t, err)+ rollout, err := ownerRollouts.CreateRollout(ctx, connect.NewRequest(&v1pb.CreateRolloutRequest{Parent: plan.Msg.Name}))+ require.NoError(t, err)+ task := rollout.Msg.Stages[0].Tasks[0]+ _, err = ownerRollouts.BatchRunTasks(ctx, connect.NewRequest(&v1pb.BatchRunTasksRequest{+ Parent: rollout.Msg.Name + "/stages/-", Tasks: []string{task.Name},+ }))+ require.NoError(t, err)++ var status v1pb.Task_Status+ var detail string+ deadline := time.Now().Add(time.Minute)+ for time.Now().Before(deadline) {+ got, err := ownerRollouts.GetRollout(ctx, connect.NewRequest(&v1pb.GetRolloutRequest{Name: rollout.Msg.Name}))+ require.NoError(t, err)+ status = got.Msg.Stages[0].Tasks[0].Status+ if status == v1pb.Task_DONE || status == v1pb.Task_FAILED {+ runs, err := ownerRollouts.ListTaskRuns(ctx, connect.NewRequest(&v1pb.ListTaskRunsRequest{Parent: got.Msg.Stages[0].Tasks[0].Name}))+ require.NoError(t, err)+ if len(runs.Msg.TaskRuns) > 0 {+ detail = runs.Msg.TaskRuns[0].Detail+ }+ break+ }+ time.Sleep(pollInterval)+ }+ require.Equal(t, v1pb.Task_FAILED, status, "the create-database task must fail rather than take over the existing database")+ require.Contains(t, detail, "already belongs to another project")++ after, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{Name: victimName}))+ require.NoError(t, err)+ require.Equal(t, before.Msg.Project, after.Msg.Project, "the existing database must keep its project")+ require.Equal(t, before.Msg.GetEnvironment(), after.Msg.GetEnvironment(), "the existing database must keep its environment")+ require.Equal(t, before.Msg.Labels, after.Msg.Labels, "the existing database must keep its labels")+}