Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

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.go
index 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) (*D
if 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 SET
project = 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, err
diff --git a/backend/store/database_ownership_test.go b/backend/store/database_ownership_test.go
index 9168f9b24c..a08fb650be 100644
--- a/backend/store/database_ownership_test.go
+++ b/backend/store/database_ownership_test.go
@@ -2,10 +2,12 @@ package store_test
import (
"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.go
new file mode 100644
index 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")
+}