Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(instance): add Sample Project Instance lifecycle (#21188)
p0nyf4f714f51228
diff --git a/CONTEXT.md b/CONTEXT.mdindex 415468733d..9f4c6d5632 100644--- a/CONTEXT.md+++ b/CONTEXT.md@@ -28,6 +28,10 @@ _Avoid_: Project instance, unassigned instanceAn instance owned by exactly one project. Every database it contains belongs to that same project._Avoid_: Workspace instance, shared instance+**Sample Project Instance**:+A Project Instance provided by Bytebase Cloud for temporary evaluation. It is an aggregate comprising one Project Instance and its one dedicated database and login role on Bytebase's shared, dedicated Cloud SQL PostgreSQL instance. Each Workspace has one lifetime entitlement. Seven-day eligibility begins only when the aggregate is ready; physical cleanup removes the backing database and role while retaining Bytebase metadata.+_Avoid_: Sample instance, sample database, shared instance+**Database**:A named database inside an instance that Bytebase tracks and assigns to a project. In a project instance, it belongs to the instance's project; in a workspace instance, it may be assigned independently._Avoid_: Instance, schemadiff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 359b532e87..8af4aebba7 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -2511,6 +2511,44 @@ paths:application/json:schema:$ref: '#/components/schemas/bytebase.v1.ListInstancesResponse'+ /bytebase.v1.InstanceService/PrepareSampleProjectInstance:+ post:+ tags:+ - bytebase.v1.InstanceService+ summary: PrepareSampleProjectInstance+ description: |-+ Prepares a Sample Project Instance for a project.+ Permissions required: bb.instances.create+ operationId: bytebase.v1.InstanceService.PrepareSampleProjectInstance+ parameters:+ - name: Connect-Protocol-Version+ in: header+ required: true+ schema:+ $ref: '#/components/schemas/connect-protocol-version'+ - name: Connect-Timeout-Ms+ in: header+ schema:+ $ref: '#/components/schemas/connect-timeout-header'+ requestBody:+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/bytebase.v1.PrepareSampleProjectInstanceRequest'+ required: true+ responses:+ default:+ description: Error+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/connect.error'+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/bytebase.v1.Instance'/bytebase.v1.InstanceService/RemoveDataSource:post:tags:@@ -16137,6 +16175,17 @@ components:- If only line is known, set line and leave column as 0 (e.g., line=5, column=0)- If only column is known (rare), set column and leave line as 0Frontends should check for nil/undefined/zero values and handle them appropriately.+ bytebase.v1.PrepareSampleProjectInstanceRequest:+ type: object+ properties:+ parent:+ type: string+ title: parent+ description: |-+ The project that owns the sample instance.+ Format: projects/{project}+ title: PrepareSampleProjectInstanceRequest+ additionalProperties: falsebytebase.v1.PreviewTaskRunRollbackRequest:type: objectproperties:diff --git a/backend/api/v1/acl.go b/backend/api/v1/acl.goindex e611ccbd61..c6dd605fe6 100644--- a/backend/api/v1/acl.go+++ b/backend/api/v1/acl.go@@ -364,10 +364,18 @@ func resolveRawResourceWithArchivedProject(ctx context.Context, stores *store.St}parts := strings.Split(name, "/")- if allowArchivedProject && getResourceRoute(parts) == (resourceRoute{projectCollection, instanceCollection}) {+ route := getResourceRoute(parts)+ if allowArchivedProject && route == (resourceRoute{projectCollection}) {+ projectID, err := requiredResourceIdentifier(parts, 1, projectCollection)+ if err != nil {+ return nil, err+ }+ return &common.Resource{Type: common.ResourceTypeProject, ID: projectID}, nil+ }+ if allowArchivedProject && route == (resourceRoute{projectCollection, instanceCollection}) {return resolveProjectInstanceResourceForLifecycle(ctx, stores, parts)}- _, resolver, ok := findResourceResolver(getResourceRoute(parts))+ _, resolver, ok := findResourceResolver(route)if !ok {return workspaceFallback(ctx), nil}@@ -579,7 +587,9 @@ func resolveProjectInstanceResourceForLifecycle(ctx context.Context, stores *sto}func allowsArchivedProjectResourceResolution(method string) bool {- return method == v1connect.InstanceServiceDeleteInstanceProcedure || method == v1connect.InstanceServiceUndeleteInstanceProcedure+ return method == v1connect.InstanceServiceDeleteInstanceProcedure ||+ method == v1connect.InstanceServiceUndeleteInstanceProcedure ||+ method == v1connect.InstanceServicePrepareSampleProjectInstanceProcedure}func getResourceFromRequest(ctx context.Context, request any, method string) ([]string, error) {@@ -597,13 +607,25 @@ func getResourceFromRequest(ctx context.Context, request any, method string) ([]var resources []string- if r, ok := request.(*v1pb.CreateInstanceRequest); ok && r.Parent != nil {+ switch r := request.(type) {+ case *v1pb.CreateInstanceRequest:+ if r.Parent == nil {+ break+ }projectID, err := common.GetProjectID(*r.Parent)if err == nil && common.IsDefaultProject(common.GetWorkspaceIDFromContext(ctx), projectID) {// Default projects cannot own instances. Authorize at workspace scope so// InstanceService can return its canonical invalid-argument response.return []string{""}, nil}+ case *v1pb.PrepareSampleProjectInstanceRequest:+ projectID, err := common.GetProjectID(r.GetParent())+ if err == nil && common.IsDefaultProject(common.GetWorkspaceIDFromContext(ctx), projectID) {+ // Keep the default-project rejection in InstanceService, consistent+ // with ordinary project instance creation.+ return []string{""}, nil+ }+ default:}if r, ok := request.(*v1pb.UpdateInstanceRequest); ok && r.AllowMissing && r.Instance != nil {if projectID, _, err := common.GetProjectIDInstanceID(r.Instance.Name); err == nil {diff --git a/backend/api/v1/acl_test.go b/backend/api/v1/acl_test.goindex 6741f20fa1..37ffe945a4 100644--- a/backend/api/v1/acl_test.go+++ b/backend/api/v1/acl_test.go@@ -276,6 +276,26 @@ func TestPopulateRawResourcesUsesWorkspaceFallback(t *testing.T) {require.Empty(t, resources)}+func TestPopulateRawResourcesAllowsDeletedSampleProjectInstanceProject(t *testing.T) {+ ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)+ workspaceID := common.GetWorkspaceIDFromContext(ctx)+ _, err := stores.GetDB().ExecContext(ctx, `+ UPDATE project+ SET deleted = TRUE+ WHERE workspace = $1 AND resource_id = $2+ `, workspaceID, projectID)+ require.NoError(t, err)++ resources, err := populateRawResources(+ ctx,+ stores,+ &v1pb.PrepareSampleProjectInstanceRequest{Parent: common.FormatProject(projectID)},+ v1connect.InstanceServicePrepareSampleProjectInstanceProcedure,+ )+ require.NoError(t, err)+ require.Equal(t, []*common.Resource{{Type: common.ResourceTypeProject, ID: projectID}}, resources)+}+func TestGetResourceFromRequest(t *testing.T) {tests := []struct {request any@@ -342,6 +362,29 @@ func TestGetResourceFromRequest(t *testing.T) {method: "/bytebase.v1.InstanceService/CreateInstance",want: []string{"projects/hello"},},+ {+ request: &v1pb.PrepareSampleProjectInstanceRequest{+ Parent: "projects/hello",+ },+ method: "/bytebase.v1.InstanceService/PrepareSampleProjectInstance",+ want: []string{"projects/hello"},+ },+ {+ // The missing required parent is rejected by InstanceService, after+ // workspace-scope authorization, just like other invalid parents.+ request: &v1pb.PrepareSampleProjectInstanceRequest{},+ method: "/bytebase.v1.InstanceService/PrepareSampleProjectInstance",+ want: []string{""},+ },+ {+ // Default projects cannot own instances. The handler owns the+ // canonical validation error, so ACL resolves this at workspace scope.+ request: &v1pb.PrepareSampleProjectInstanceRequest{+ Parent: "projects/default",+ },+ method: "/bytebase.v1.InstanceService/PrepareSampleProjectInstance",+ want: []string{""},+ },{request: &v1pb.UpdateInstanceRequest{Instance: &v1pb.Instance{Name: "projects/hello/instances/new-instance"},diff --git a/backend/api/v1/audit.go b/backend/api/v1/audit.goindex a348a25453..f3bb93b7a4 100644--- a/backend/api/v1/audit.go+++ b/backend/api/v1/audit.go@@ -547,6 +547,8 @@ func getRequestResource(request any, method string) string {return common.FormatProjectInstance(projectID, r.GetInstanceId())}return ""+ case *v1pb.PrepareSampleProjectInstanceRequest:+ return r.GetParent()case *v1pb.CreateProjectRequest:return common.FormatProject(r.GetProjectId())case *v1pb.CreateReviewConfigRequest:diff --git a/backend/api/v1/audit_redaction_test.go b/backend/api/v1/audit_redaction_test.goindex b43625ba8c..d8ccf3cecd 100644--- a/backend/api/v1/audit_redaction_test.go+++ b/backend/api/v1/audit_redaction_test.go@@ -440,6 +440,20 @@ func TestAuditRedactionSurvivesAnIncompleteRequest(t *testing.T) {}}+func TestPrepareSampleProjectInstanceAuditRequestContainsOnlyParent(t *testing.T) {+ request := &v1pb.PrepareSampleProjectInstanceRequest{Parent: "projects/project-a"}++ got, err := getRequestString(request)+ require.NoError(t, err)+ require.Contains(t, got, "projects/project-a")+ require.NotContains(t, got, secretSentinel)+ require.Equal(+ t,+ "projects/project-a",+ getRequestResource(request, "/bytebase.v1.InstanceService/PrepareSampleProjectInstance"),+ )+}+func TestAuditRequestRedactsCredentials(t *testing.T) {batchParent := "projects/project-a"settingRequest := func(v *v1pb.SettingValue) *v1pb.UpdateSettingRequest {diff --git a/backend/api/v1/instance_service.go b/backend/api/v1/instance_service.goindex 9f8438d674..7652674a66 100644--- a/backend/api/v1/instance_service.go+++ b/backend/api/v1/instance_service.go@@ -27,6 +27,7 @@ import ("github.com/bytebase/bytebase/backend/component/dbfactory""github.com/bytebase/bytebase/backend/component/sampleinstance"+ "github.com/bytebase/bytebase/backend/component/sampleprojectinstance""github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"@@ -45,6 +46,7 @@ type InstanceService struct {dbFactory *dbfactory.DBFactoryschemaSyncer *schemasync.SyncersampleInstanceManager *sampleinstance.Manager+ sampleProjectManager *sampleprojectinstance.Manager}type instanceLicenseService interface {@@ -198,7 +200,7 @@ func (s *InstanceService) checkAndLogInstanceConnection(ctx context.Context, met}// NewInstanceService creates a new InstanceService.-func NewInstanceService(store *store.Store, profile *config.Profile, licenseService *enterprise.LicenseService, dbFactory *dbfactory.DBFactory, schemaSyncer *schemasync.Syncer, sampleInstanceManager *sampleinstance.Manager) *InstanceService {+func NewInstanceService(store *store.Store, profile *config.Profile, licenseService *enterprise.LicenseService, dbFactory *dbfactory.DBFactory, schemaSyncer *schemasync.Syncer, sampleInstanceManager *sampleinstance.Manager, sampleProjectManager *sampleprojectinstance.Manager) *InstanceService {return &InstanceService{store: store,profile: profile,@@ -206,6 +208,7 @@ func NewInstanceService(store *store.Store, profile *config.Profile, licenseServdbFactory: dbFactory,schemaSyncer: schemaSyncer,sampleInstanceManager: sampleInstanceManager,+ sampleProjectManager: sampleProjectManager,}}@@ -466,6 +469,99 @@ func (s *InstanceService) CreateInstance(ctx context.Context, req *connect.Requereturn connect.NewResponse(result), nil}+// PrepareSampleProjectInstance provisions a Cloud Sample Project Instance for+// the requested project. The lifetime entitlement itself is enforced by the+// lifecycle manager under a workspace row lock.+func (s *InstanceService) PrepareSampleProjectInstance(ctx context.Context, req *connect.Request[v1pb.PrepareSampleProjectInstanceRequest]) (*connect.Response[v1pb.Instance], error) {+ projectID, err := s.getSampleProjectInstanceParent(ctx, &req.Msg.Parent)+ if err != nil {+ return nil, err+ }+ if projectID == nil {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("Sample Project Instance parent is required"))+ }+ if s.profile == nil || !s.profile.SaaS || s.sampleProjectManager == nil {+ return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("Sample Project Instance is available only in SaaS deployments with a configured target"))+ }+ workspaceID := common.GetWorkspaceIDFromContext(ctx)+ result, err := s.sampleProjectManager.Prepare(ctx, sampleprojectinstance.PrepareRequest{+ WorkspaceID: workspaceID,+ ProjectID: *projectID,+ CheckCreatePolicy: func(ctx context.Context) (sampleprojectinstance.CreatePolicyResult, error) {+ return s.sampleProjectInstanceCreatePolicy(ctx, workspaceID)+ },+ })+ if err != nil {+ return nil, sampleProjectInstanceConnectError(err)+ }+ if result.PolicyDenied != nil {+ return nil, connect.NewError(connect.CodeResourceExhausted, result.PolicyDenied)+ }+ if result.Instance == nil {+ return nil, connect.NewError(connect.CodeInternal, errors.New("Sample Project Instance preparation returned no instance"))+ }+ return connect.NewResponse(s.convertToV1Instance(ctx, result.Instance)), nil+}++func (s *InstanceService) sampleProjectInstanceCreatePolicy(ctx context.Context, workspaceID string) (sampleprojectinstance.CreatePolicyResult, error) {+ if err := s.instanceCountGuard(ctx); err != nil {+ if connect.CodeOf(err) == connect.CodeResourceExhausted {+ return sampleprojectinstance.CreatePolicyResult{DeniedReason: transportNeutralError(err)}, nil+ }+ return sampleprojectinstance.CreatePolicyResult{}, transportNeutralError(err)+ }+ if err := s.checkActivationLimit(ctx, workspaceID, true); err != nil {+ if connect.CodeOf(err) == connect.CodeResourceExhausted {+ return sampleprojectinstance.CreatePolicyResult{DeniedReason: transportNeutralError(err)}, nil+ }+ return sampleprojectinstance.CreatePolicyResult{}, transportNeutralError(err)+ }+ return sampleprojectinstance.CreatePolicyResult{}, nil+}++func sampleProjectInstanceConnectError(err error) error {+ switch sampleprojectinstance.FailureKindOf(err) {+ case sampleprojectinstance.FailureFailedPrecondition:+ return connect.NewError(connect.CodeFailedPrecondition, err)+ case sampleprojectinstance.FailureUnavailable:+ return connect.NewError(connect.CodeUnavailable, err)+ case sampleprojectinstance.FailureDeadlineExceeded:+ return connect.NewError(connect.CodeDeadlineExceeded, err)+ default:+ return connect.NewError(connect.CodeInternal, err)+ }+}++func transportNeutralError(err error) error {+ var connectErr *connect.Error+ if errors.As(err, &connectErr) {+ if cause := connectErr.Unwrap(); cause != nil {+ return cause+ }+ return errors.New(connectErr.Message())+ }+ return err+}++func (s *InstanceService) getSampleProjectInstanceParent(ctx context.Context, parent *string) (*string, error) {+ projectID, err := s.getProjectInstanceParent(ctx, parent)+ if err == nil || connect.CodeOf(err) != connect.CodeNotFound || parent == nil {+ return projectID, err+ }+ missingProjectID, parseErr := common.GetProjectID(*parent)+ if parseErr != nil {+ return nil, err+ }+ reservation, storeErr := s.store.GetSampleProjectInstance(ctx, common.GetWorkspaceIDFromContext(ctx))+ if storeErr != nil {+ return nil, connect.NewError(connect.CodeInternal, storeErr)+ }+ if reservation != nil && reservation.ProjectID == missingProjectID {+ return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("Sample Project Instance entitlement is already consumed"))+ }+ return nil, err+}+func (s *InstanceService) getProjectInstanceParent(ctx context.Context, parent *string) (*string, error) {if parent == nil {return nil, nildiff --git a/backend/api/v1/instance_service_test.go b/backend/api/v1/instance_service_test.goindex 00c0bb30b5..d478201ba3 100644--- a/backend/api/v1/instance_service_test.go+++ b/backend/api/v1/instance_service_test.go@@ -1,6 +1,7 @@package v1import (+ "context""errors""log/slog""testing"@@ -9,12 +10,95 @@ import ("connectrpc.com/connect""github.com/stretchr/testify/require"+ "github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/component/config"+ "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/generated-go/v1/v1connect""github.com/bytebase/bytebase/backend/store")+func TestPrepareSampleProjectInstanceValidatesParentAndDeployment(t *testing.T) {+ service := &InstanceService{profile: &config.Profile{SaaS: true}}+ _, err := service.PrepareSampleProjectInstance(context.Background(), connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{}))+ require.Equal(t, connect.CodeInvalidArgument, connect.CodeOf(err))++ ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)+ service = &InstanceService{+ store: stores,+ profile: &config.Profile{},+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},+ sampleProjectManager: &sampleprojectinstance.Manager{},+ }+ _, err = service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(projectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))++ service.profile = nil+ _, err = service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(projectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+}++func TestPrepareSampleProjectInstanceRejectsConsumedEntitlementAfterProjectDeletion(t *testing.T) {+ ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)+ workspaceID := common.GetWorkspaceIDFromContext(ctx)+ _, _, err := stores.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{+ WorkspaceID: workspaceID,+ ProjectID: projectID,+ InstanceID: "sample-deleted-project",+ DBName: "bb_sample_deleted_project",+ RoleName: "bb_sample_role_deleted_project",+ ReplicaID: "replica-a",+ })+ require.NoError(t, err)+ _, err = stores.GetDB().ExecContext(ctx, `+ UPDATE project+ SET deleted = TRUE+ WHERE workspace = $1 AND resource_id = $2+ `, workspaceID, projectID)+ require.NoError(t, err)+ service := &InstanceService{+ store: stores,+ profile: &config.Profile{SaaS: true},+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},+ sampleProjectManager: &sampleprojectinstance.Manager{},+ }++ _, err = service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(projectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+}++func TestSampleProjectInstanceConnectErrorMapsUnknownFailure(t *testing.T) {+ err := sampleProjectInstanceConnectError(errors.New("unexpected manager failure"))+ require.Equal(t, connect.CodeInternal, connect.CodeOf(err))+}++func TestSampleProjectInstanceCreatePolicyMapsCapacityDenial(t *testing.T) {+ ctx, stores, _, _, _ := setupProjectInstanceLifecycleAPITest(t)+ service := &InstanceService{+ store: stores,+ profile: &config.Profile{SaaS: true},+ licenseService: &instanceLicenseServiceStub{instanceLimit: 1, activatedInstanceLimit: 10},+ }+ policy, err := service.sampleProjectInstanceCreatePolicy(ctx, common.GetWorkspaceIDFromContext(ctx))+ require.NoError(t, err)+ require.Error(t, policy.DeniedReason)+ require.Equal(t, connect.CodeUnknown, connect.CodeOf(policy.DeniedReason))+}++func TestTransportNeutralErrorRemovesConnectType(t *testing.T) {+ neutral := transportNeutralError(connect.NewError(connect.CodeResourceExhausted, errors.New("instance limit reached")))+ var connectErr *connect.Error+ require.NotErrorAs(t, neutral, &connectErr)+ require.EqualError(t, neutral, "instance limit reached")+}+func TestValidateIAMCredentialForSaaS(t *testing.T) {saas := &InstanceService{profile: &config.Profile{SaaS: true}}selfHosted := &InstanceService{profile: &config.Profile{SaaS: false}}diff --git a/backend/api/v1/sample_project_instance_integration_test.go b/backend/api/v1/sample_project_instance_integration_test.gonew file mode 100644index 0000000000..c7207177ac--- /dev/null+++ b/backend/api/v1/sample_project_instance_integration_test.go@@ -0,0 +1,733 @@+package v1++import (+ "context"+ "crypto/sha256"+ "database/sql"+ "errors"+ "fmt"+ "net/http/httptest"+ "net/url"+ "sync"+ "testing"+ "time"++ "connectrpc.com/connect"+ "github.com/jackc/pgx/v5"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/permission"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ "github.com/bytebase/bytebase/backend/component/config"+ "github.com/bytebase/bytebase/backend/component/dbfactory"+ "github.com/bytebase/bytebase/backend/component/iam"+ "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"+ "github.com/bytebase/bytebase/backend/enterprise"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"+ "github.com/bytebase/bytebase/backend/migrator"+ _ "github.com/bytebase/bytebase/backend/plugin/db/pg"+ sampleprojectinstancerunner "github.com/bytebase/bytebase/backend/runner/sampleprojectinstance"+ "github.com/bytebase/bytebase/backend/runner/schemasync"+ "github.com/bytebase/bytebase/backend/store"+)++func TestPrepareSampleProjectInstanceLifecycle(t *testing.T) {+ now := time.Date(2026, time.August, 17, 12, 0, 0, 0, time.UTC)+ ctx, fixture := newSampleProjectInstanceFixture(t, func() time.Time { return now })+ runner := sampleprojectinstancerunner.NewRunner(fixture.manager, sampleprojectinstancerunner.Options{+ Clock: func() time.Time { return now },+ })++ prepared, err := fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(fixture.projectID),+ }))+ require.NoError(t, err)+ require.Equal(t, "Sample Project Instance", prepared.Msg.Title)+ require.Equal(t, v1pb.Engine_POSTGRES, prepared.Msg.Engine)+ require.Equal(t, "environments/test", prepared.Msg.GetEnvironment())+ require.True(t, prepared.Msg.Activation)++ record := fixture.sampleRecord(ctx, t)+ allocation := fixture.allocation(ctx, t)+ require.Equal(t, fixture.workspaceID, record.workspace)+ require.Equal(t, fixture.projectID, record.project)+ require.Equal(t, prepared.Msg.Name, common.FormatProjectInstance(record.project, record.instance))+ require.Equal(t, allocation.Database, record.database)+ require.Equal(t, allocation.Role, record.role)+ require.False(t, record.createdAt.IsZero())+ require.Equal(t, now.Add(7*24*time.Hour), record.expiresAt)+ require.Nil(t, record.deletedAt)++ database, err := fixture.store.GetDatabase(ctx, &store.FindDatabaseMessage{+ Workspace: fixture.workspaceID,+ ProjectID: &fixture.projectID,+ InstanceID: &record.instance,+ DatabaseName: &record.database,+ })+ require.NoError(t, err)+ require.NotNil(t, database)+ require.NoError(t, fixture.target.sampleEmployeeCount(ctx, allocation, func(count int) bool { return count > 0 }))+ fixture.target.assertSeededOwnershipAndDDL(ctx, t, allocation)++ repeated, err := fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(fixture.projectID),+ }))+ require.NoError(t, err)+ require.Equal(t, prepared.Msg.Name, repeated.Msg.Name)+ require.Equal(t, 1, fixture.sampleRecordCount(ctx, t))+ require.True(t, fixture.target.databaseExists(ctx, allocation.Database))+ require.True(t, fixture.target.roleExists(ctx, allocation.Role))+ fixture.target.assertIsolation(ctx, t, allocation)++ now = now.Add(6 * 24 * time.Hour)+ require.NoError(t, runner.RunOnce(ctx))+ require.True(t, fixture.target.databaseExists(ctx, allocation.Database))+ require.Nil(t, fixture.sampleRecord(ctx, t).deletedAt)++ held := fixture.target.sampleConnection(ctx, t, allocation)+ t.Cleanup(func() { _ = held.Close(context.Background()) })+ now = now.Add(24*time.Hour + time.Second)+ require.NoError(t, runner.RunOnce(ctx))+ require.Error(t, held.Ping(ctx))+ require.False(t, fixture.target.databaseExists(ctx, allocation.Database))+ require.False(t, fixture.target.roleExists(ctx, allocation.Role))+ require.NotNil(t, fixture.sampleRecord(ctx, t).deletedAt)++ instance, err := fixture.store.GetInstance(ctx, &store.FindInstanceMessage{+ Workspace: fixture.workspaceID,+ ResourceID: &record.instance,+ })+ require.NoError(t, err)+ require.NotNil(t, instance)+ require.False(t, instance.Deleted)+ database, err = fixture.store.GetDatabase(ctx, &store.FindDatabaseMessage{+ Workspace: fixture.workspaceID,+ ProjectID: &fixture.projectID,+ InstanceID: &record.instance,+ DatabaseName: &record.database,+ })+ require.NoError(t, err)+ require.NotNil(t, database)+ require.False(t, database.Deleted)++ _, err = fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(fixture.projectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+}++func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(t *testing.T) {+ now := time.Date(2026, time.August, 17, 12, 0, 0, 0, time.UTC)+ ctx, fixture := newSampleProjectInstanceFixture(t, func() time.Time { return now })+ runner := sampleprojectinstancerunner.NewRunner(fixture.manager, sampleprojectinstancerunner.Options{+ Clock: func() time.Time { return now },+ })++ t.Run("ACL denies callers without project permission", func(t *testing.T) {+ iamManager, err := iam.NewManager(fixture.store, nil, true)+ require.NoError(t, err)+ aclInterceptor := NewACLInterceptor(fixture.store, "", iamManager, fixture.service.profile)+ injectIdentity := connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {+ return func(requestCtx context.Context, request connect.AnyRequest) (connect.AnyResponse, error) {+ requestCtx = context.WithValue(requestCtx, common.WorkspaceIDContextKey, fixture.workspaceID)+ requestCtx = context.WithValue(requestCtx, common.AuthContextKey, &common.AuthContext{+ AuthMethod: common.AuthMethodIAM,+ Permission: string(permission.InstancesCreate),+ })+ requestCtx = context.WithValue(requestCtx, common.UserContextKey, &store.UserMessage{Email: "[email protected]"})+ return next(requestCtx, request)+ }+ })+ _, handler := v1connect.NewInstanceServiceHandler(fixture.service, connect.WithInterceptors(injectIdentity, aclInterceptor))+ server := httptest.NewServer(handler)+ t.Cleanup(server.Close)+ client := v1connect.NewInstanceServiceClient(server.Client(), server.URL)++ _, err = client.PrepareSampleProjectInstance(context.Background(), connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(fixture.projectID),+ }))+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))+ require.Zero(t, fixture.sampleRecordCount(ctx, t))+ })++ t.Run("Cloud-only gating", func(t *testing.T) {+ fixture.service.profile.SaaS = false+ _, err := fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(fixture.projectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+ fixture.service.profile.SaaS = true+ })++ concurrentCtx, concurrentProjectID := fixture.newWorkspaceProject(ctx, t, "concurrent")+ t.Run("two concurrent cold-start requests create exactly one instance", func(t *testing.T) {+ const requests = 2+ results := make(chan error, requests)+ var wg sync.WaitGroup+ for range requests {+ wg.Go(func() {+ requestCtx, cancel := context.WithTimeout(concurrentCtx, 15*time.Second)+ defer cancel()+ _, err := fixture.service.PrepareSampleProjectInstance(requestCtx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(concurrentProjectID),+ }))+ results <- err+ })+ }+ wg.Wait()+ close(results)+ for err := range results {+ require.NoError(t, err)+ }++ record := fixture.sampleRecordFor(concurrentCtx, t, "sample-workspace-concurrent")+ require.Equal(t, 1, fixture.sampleRecordCountFor(concurrentCtx, t, "sample-workspace-concurrent"))+ require.True(t, fixture.target.databaseExists(concurrentCtx, record.database))+ require.True(t, fixture.target.roleExists(concurrentCtx, record.role))+ fixture.assertActiveMetadata(concurrentCtx, t, record)+ })++ t.Run("cross-project repeat is rejected", func(t *testing.T) {+ otherProjectID := fixture.addProject(concurrentCtx, t, "sample-workspace-concurrent", "other")+ _, err := fixture.service.PrepareSampleProjectInstance(concurrentCtx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(otherProjectID),+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+ })++ t.Run("stale partial reservation is removed after one hour", func(t *testing.T) {+ staleCtx, staleProjectID := fixture.newWorkspaceProject(ctx, t, "stale")+ allocation := fixture.createPartialReservation(staleCtx, t, "sample-workspace-stale", staleProjectID, now.Add(-time.Hour-time.Second))+ require.NoError(t, runner.RunOnce(staleCtx))+ record, err := fixture.store.GetSampleProjectInstance(staleCtx, "sample-workspace-stale")+ require.NoError(t, err)+ require.Nil(t, record)+ require.False(t, fixture.target.databaseExists(staleCtx, allocation.Database))+ require.False(t, fixture.target.roleExists(staleCtx, allocation.Role))+ instance, err := fixture.store.GetInstance(staleCtx, &store.FindInstanceMessage{+ Workspace: "sample-workspace-stale",+ ResourceID: ptr(sampleInstanceID("sample-workspace-stale")),+ ShowDeleted: true,+ })+ require.NoError(t, err)+ require.Nil(t, instance)+ })++ t.Run("missing target resources are cleaned idempotently", func(t *testing.T) {+ missingCtx, missingProjectID := fixture.newWorkspaceProject(ctx, t, "missing")+ _, err := fixture.service.PrepareSampleProjectInstance(missingCtx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(missingProjectID),+ }))+ require.NoError(t, err)+ record := fixture.sampleRecordFor(missingCtx, t, "sample-workspace-missing")+ require.NoError(t, fixture.target.dropResources(missingCtx, sampleprojectinstance.Allocation{+ Database: record.database,+ Role: record.role,+ }))++ now = now.Add(8 * 24 * time.Hour)+ require.NoError(t, runner.RunOnce(missingCtx))+ require.NotNil(t, fixture.sampleRecordFor(missingCtx, t, "sample-workspace-missing").deletedAt)+ })++ t.Run("cleanup terminates role sessions outside the sample database", func(t *testing.T) {+ sessionCtx, sessionProjectID := fixture.newWorkspaceProject(ctx, t, "external-session")+ _, err := fixture.service.PrepareSampleProjectInstance(sessionCtx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{+ Parent: common.FormatProject(sessionProjectID),+ }))+ require.NoError(t, err)+ record := fixture.sampleRecordFor(sessionCtx, t, "sample-workspace-external-session")+ allocation := sampleprojectinstance.Allocation{+ Database: record.database,+ Role: record.role,+ Password: fixture.allocationFor(sessionCtx, t, "sample-workspace-external-session").Password,+ }+ outside := fixture.target.externalRoleConnection(sessionCtx, t, allocation)+ t.Cleanup(func() { _ = outside.Close(context.Background()) })++ now = now.Add(8 * 24 * time.Hour)+ require.NoError(t, runner.RunOnce(sessionCtx))+ require.Error(t, outside.Ping(sessionCtx))+ require.False(t, fixture.target.databaseExists(sessionCtx, allocation.Database))+ require.False(t, fixture.target.roleExists(sessionCtx, allocation.Role))+ })+}++type sampleProjectInstanceFixture struct {+ store *store.Store+ service *InstanceService+ manager *sampleprojectinstance.Manager+ sampleTarget *sampleprojectinstance.Target+ target *sampleTargetInspector+ workspaceID string+ projectID string+}++func newSampleProjectInstanceFixture(t *testing.T, clock func() time.Time) (context.Context, *sampleProjectInstanceFixture) {+ t.Helper()+ ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)+ t.Cleanup(cancel)++ metadata := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { metadata.Close(context.Background()) })+ target := testcontainer.GetTestTLSPgContainer(ctx, t)+ t.Cleanup(func() { target.Close(context.Background()) })++ require.NoError(t, migrator.MigrateSchema(ctx, metadata.GetDB()))+ _, err := metadata.GetDB().ExecContext(ctx, `+ INSERT INTO workspace (resource_id) VALUES ('sample-workspace');+ INSERT INTO project (resource_id, workspace, name) VALUES ('sample-project', 'sample-workspace', 'Sample Project');+ `)+ require.NoError(t, err)++ metadataURL := postgresTestURL(metadata)+ stores, err := store.New(ctx, metadataURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, stores.Close()) })+ setSampleProjectInstanceTestEnvironment(ctx, t, stores, "sample-workspace")++ licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, stores, false, "")+ require.NoError(t, err)+ dbFactory := dbfactory.New(stores, licenseService)+ syncer := schemasync.NewSyncer(stores, dbFactory, licenseService, nil)+ require.NoError(t, prepareSampleTargetBaseline(ctx, target.GetDB()))+ targetURL := tlsPostgresTestURL(target)+ sampleTarget, err := sampleprojectinstance.NewTarget(targetURL)+ require.NoError(t, err)+ inspector := newSampleTargetInspector(t, targetURL)+ manager := sampleprojectinstance.NewManagerFromURL(+ stores,+ targetURL,+ syncer,+ sampleprojectinstance.ManagerOptions{Clock: clock, ReplicaID: "replica-a"},+ )+ return context.WithValue(ctx, common.WorkspaceIDContextKey, "sample-workspace"), &sampleProjectInstanceFixture{+ store: stores,+ service: &InstanceService{+ store: stores,+ profile: &config.Profile{SaaS: true},+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},+ dbFactory: dbFactory,+ schemaSyncer: syncer,+ sampleProjectManager: manager,+ },+ manager: manager,+ sampleTarget: sampleTarget,+ target: inspector,+ workspaceID: "sample-workspace",+ projectID: "sample-project",+ }+}++func tlsPostgresTestURL(container *testcontainer.Container) string {+ return fmt.Sprintf(+ "postgres://postgres:root-password@localhost:%s/postgres?sslmode=verify-full&sslrootcert=%s",+ container.GetPort(),+ url.QueryEscape(container.GetTLSCAPath()),+ )+}++func postgresTestURL(container *testcontainer.Container) string {+ return fmt.Sprintf(+ "postgres://postgres:root-password@%s:%s/postgres?sslmode=disable",+ container.GetHost(),+ container.GetPort(),+ )+}++type sampleProjectInstanceRecord struct {+ workspace string+ project string+ instance string+ database string+ role string+ createdAt time.Time+ expiresAt time.Time+ deletedAt *time.Time+}++func (f *sampleProjectInstanceFixture) sampleRecord(ctx context.Context, t *testing.T) sampleProjectInstanceRecord {+ return f.sampleRecordFor(ctx, t, f.workspaceID)+}++func (f *sampleProjectInstanceFixture) sampleRecordFor(ctx context.Context, t *testing.T, workspaceID string) sampleProjectInstanceRecord {+ t.Helper()+ record := sampleProjectInstanceRecord{}+ require.NoError(t, f.store.GetDB().QueryRowContext(ctx, `+ SELECT workspace, project, instance, db_name, role_name, created_at, expires_at, deleted_at+ FROM sample_project_instance+ WHERE workspace = $1+ `, workspaceID).Scan(+ &record.workspace,+ &record.project,+ &record.instance,+ &record.database,+ &record.role,+ &record.createdAt,+ &record.expiresAt,+ &record.deletedAt,+ ))+ return record+}++func (f *sampleProjectInstanceFixture) sampleRecordCount(ctx context.Context, t *testing.T) int {+ return f.sampleRecordCountFor(ctx, t, "")+}++func (f *sampleProjectInstanceFixture) sampleRecordCountFor(ctx context.Context, t *testing.T, workspaceID string) int {+ t.Helper()+ var count int+ query := "SELECT COUNT(*) FROM sample_project_instance"+ args := []any{}+ if workspaceID != "" {+ query += " WHERE workspace = $1"+ args = append(args, workspaceID)+ }+ require.NoError(t, f.store.GetDB().QueryRowContext(ctx, query, args...).Scan(&count))+ return count+}++func (f *sampleProjectInstanceFixture) allocation(ctx context.Context, t *testing.T) sampleprojectinstance.Allocation {+ return f.allocationFor(ctx, t, f.workspaceID)+}++func (f *sampleProjectInstanceFixture) allocationFor(+ ctx context.Context,+ t *testing.T,+ workspaceID string,+) sampleprojectinstance.Allocation {+ record := f.sampleRecordFor(ctx, t, workspaceID)+ instance, err := f.store.GetInstance(ctx, &store.FindInstanceMessage{+ Workspace: workspaceID,+ ResourceID: &record.instance,+ ShowDeleted: true,+ })+ require.NoError(t, err)+ require.NotNil(t, instance)+ for _, dataSource := range instance.Metadata.GetDataSources() {+ if dataSource.GetId() == "admin" {+ return sampleprojectinstance.Allocation{+ Database: record.database,+ Role: record.role,+ Password: dataSource.GetPassword(),+ }+ }+ }+ require.FailNow(t, "sample instance has no admin data source")+ return sampleprojectinstance.Allocation{}+}++func (f *sampleProjectInstanceFixture) newWorkspaceProject(ctx context.Context, t *testing.T, suffix string) (context.Context, string) {+ t.Helper()+ workspaceID := "sample-workspace-" + suffix+ projectID := "sample-project-" + suffix+ _, err := f.store.GetDB().ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ($1)`, workspaceID)+ require.NoError(t, err)+ setSampleProjectInstanceTestEnvironment(ctx, t, f.store, workspaceID)+ _, err = f.store.GetDB().ExecContext(ctx, `+ INSERT INTO project (resource_id, workspace, name) VALUES ($1, $2, $3)+ `, projectID, workspaceID, "Sample Project "+suffix)+ require.NoError(t, err)+ return context.WithValue(ctx, common.WorkspaceIDContextKey, workspaceID), projectID+}++func setSampleProjectInstanceTestEnvironment(ctx context.Context, t *testing.T, stores *store.Store, workspaceID string) {+ t.Helper()+ _, err := stores.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_ENVIRONMENT,+ Workspace: workspaceID,+ Value: &storepb.EnvironmentSetting{Environments: []*storepb.EnvironmentSetting_Environment{+ {Title: "Test", Id: "test"},+ }},+ })+ require.NoError(t, err)+}++func (f *sampleProjectInstanceFixture) addProject(ctx context.Context, t *testing.T, workspaceID, suffix string) string {+ t.Helper()+ projectID := "sample-project-" + suffix+ _, err := f.store.GetDB().ExecContext(ctx, `+ INSERT INTO project (resource_id, workspace, name) VALUES ($1, $2, $3)+ `, projectID, workspaceID, "Sample Project "+suffix)+ require.NoError(t, err)+ return projectID+}++func (f *sampleProjectInstanceFixture) assertActiveMetadata(ctx context.Context, t *testing.T, record sampleProjectInstanceRecord) {+ t.Helper()+ var instanceCount, databaseCount int+ require.NoError(t, f.store.GetDB().QueryRowContext(ctx, `+ SELECT COUNT(*) FROM instance+ WHERE workspace = $1 AND resource_id = $2 AND deleted = FALSE+ `, record.workspace, record.instance).Scan(&instanceCount))+ require.NoError(t, f.store.GetDB().QueryRowContext(ctx, `+ SELECT COUNT(*) FROM db+ WHERE project = $1 AND instance = $2 AND name = $3 AND deleted = FALSE+ `, record.project, record.instance, record.database).Scan(&databaseCount))+ require.Equal(t, 1, instanceCount)+ require.Equal(t, 1, databaseCount)+}++func (f *sampleProjectInstanceFixture) createPartialReservation(+ ctx context.Context,+ t *testing.T,+ workspaceID, projectID string,+ createdAt time.Time,+) sampleprojectinstance.Allocation {+ t.Helper()+ record, created, err := f.store.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{+ WorkspaceID: workspaceID,+ ProjectID: projectID,+ InstanceID: sampleInstanceID(workspaceID),+ DBName: sampleDatabaseName(workspaceID),+ RoleName: sampleRoleName(workspaceID),+ ReplicaID: "replica-a",+ })+ require.NoError(t, err)+ require.True(t, created)+ allocation := sampleprojectinstance.Allocation{+ Database: record.DBName,+ Role: record.RoleName,+ Password: "sample-partial-password",+ }+ require.NoError(t, f.sampleTarget.Provision(ctx, allocation))+ config, err := f.sampleTarget.InstanceConfig(allocation)+ require.NoError(t, err)+ instance, err := f.store.CreateInstance(ctx, &store.InstanceMessage{+ Workspace: workspaceID,+ ProjectID: &projectID,+ EnvironmentID: ptr("test"),+ ResourceID: record.InstanceID,+ Metadata: &storepb.Instance{+ Title: "Sample Project Instance",+ Engine: storepb.Engine_POSTGRES,+ Activation: true,+ DataSources: []*storepb.DataSource{+ config.AdminDataSource,+ },+ SyncDatabases: &storepb.SyncDatabases{Databases: config.SyncDatabaseNames},+ },+ })+ require.NoError(t, err)+ _, _, databases, err := f.service.schemaSyncer.SyncInstance(ctx, instance)+ require.NoError(t, err)+ require.Len(t, databases, 1)+ _, err = f.store.GetDB().ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = $1+ WHERE workspace = $2+ `, createdAt, workspaceID)+ require.NoError(t, err)+ return allocation+}++func sampleToken(workspaceID string) string {+ sum := sha256.Sum256([]byte(workspaceID))+ return fmt.Sprintf("%x", sum[:16])+}++func sampleInstanceID(workspaceID string) string {+ return "sample-" + sampleToken(workspaceID)+}++func sampleDatabaseName(workspaceID string) string {+ return "bb_sample_" + sampleToken(workspaceID)+}++func sampleRoleName(workspaceID string) string {+ return "bb_sample_role_" + sampleToken(workspaceID)+}++type sampleTargetInspector struct {+ config *pgx.ConnConfig+}++func newSampleTargetInspector(t *testing.T, targetURL string) *sampleTargetInspector {+ t.Helper()+ config, err := pgx.ParseConfig(targetURL)+ require.NoError(t, err)+ return &sampleTargetInspector{config: config}+}++func prepareSampleTargetBaseline(ctx context.Context, db *sql.DB) error {+ for _, statement := range []string{+ "REVOKE ALL PRIVILEGES ON DATABASE postgres FROM PUBLIC",+ "REVOKE ALL PRIVILEGES ON DATABASE template1 FROM PUBLIC",+ } {+ if _, err := db.ExecContext(ctx, statement); err != nil {+ return err+ }+ }+ return nil+}++func (t *sampleTargetInspector) connect(ctx context.Context, database, user, password string) (*pgx.Conn, error) {+ config := t.config.Copy()+ if database != "" {+ config.Database = database+ }+ if user != "" {+ config.User = user+ config.Password = password+ }+ return pgx.ConnectConfig(ctx, config)+}++func (t *sampleTargetInspector) roleExists(ctx context.Context, role string) bool {+ conn, err := t.connect(ctx, "", "", "")+ if err != nil {+ return false+ }+ defer conn.Close(ctx)+ var exists bool+ return conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", role).Scan(&exists) == nil && exists+}++func (t *sampleTargetInspector) databaseExists(ctx context.Context, database string) bool {+ conn, err := t.connect(ctx, "", "", "")+ if err != nil {+ return false+ }+ defer conn.Close(ctx)+ var exists bool+ return conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", database).Scan(&exists) == nil && exists+}++func (t *sampleTargetInspector) sampleConnection(ctx context.Context, tst *testing.T, allocation sampleprojectinstance.Allocation) *pgx.Conn {+ tst.Helper()+ conn, err := t.connect(ctx, allocation.Database, allocation.Role, allocation.Password)+ require.NoError(tst, err)+ return conn+}++func (t *sampleTargetInspector) sampleEmployeeCount(ctx context.Context, allocation sampleprojectinstance.Allocation, assert func(int) bool) error {+ conn, err := t.connect(ctx, allocation.Database, allocation.Role, allocation.Password)+ if err != nil {+ return errors.New("sample target cannot be inspected")+ }+ defer conn.Close(ctx)+ var count int+ if err := conn.QueryRow(ctx, "SELECT COUNT(*) FROM employee").Scan(&count); err != nil || !assert(count) {+ return errors.New("sample target seed is not available")+ }+ return nil+}++func (t *sampleTargetInspector) assertSeededOwnershipAndDDL(+ ctx context.Context,+ tst *testing.T,+ allocation sampleprojectinstance.Allocation,+) {+ tst.Helper()+ sample := t.sampleConnection(ctx, tst, allocation)+ defer sample.Close(ctx)++ for _, query := range []string{+ `SELECT nspowner = (SELECT oid FROM pg_roles WHERE rolname = current_user) FROM pg_namespace WHERE nspname = 'bbdataarchive'`,+ `SELECT relowner = (SELECT oid FROM pg_roles WHERE rolname = current_user) FROM pg_class WHERE oid = 'public.employee'::regclass`,+ `SELECT relowner = (SELECT oid FROM pg_roles WHERE rolname = current_user) FROM pg_class WHERE oid = 'public.employee_emp_no_seq'::regclass`,+ `SELECT proowner = (SELECT oid FROM pg_roles WHERE rolname = current_user) FROM pg_proc WHERE oid = 'public.log_dml_operations()'::regprocedure`,+ `SELECT typowner = (SELECT oid FROM pg_roles WHERE rolname = current_user) FROM pg_type WHERE oid = 'public.employee'::regtype`,+ } {+ var owned bool+ require.NoError(tst, sample.QueryRow(ctx, query).Scan(&owned))+ require.True(tst, owned)+ }+ _, err := sample.Exec(ctx, "ALTER TABLE employee ADD COLUMN sample_integration_marker BOOLEAN NOT NULL DEFAULT false")+ require.NoError(tst, err)+ for _, statement := range []string{+ "CREATE SCHEMA sample_integration_ddl",+ "CREATE TABLE sample_integration_ddl.example (id INT PRIMARY KEY)",+ "DROP SCHEMA sample_integration_ddl CASCADE",+ } {+ _, err := sample.Exec(ctx, statement)+ require.NoError(tst, err)+ }+}++func (t *sampleTargetInspector) assertIsolation(ctx context.Context, tst *testing.T, allocation sampleprojectinstance.Allocation) {+ tst.Helper()+ admin, err := t.connect(ctx, "", "", "")+ require.NoError(tst, err)+ defer admin.Close(ctx)++ var canLogin, superuser, createDatabase, createRole, replicate, bypassRLS, publicConnect, publicCreate bool+ require.NoError(tst, admin.QueryRow(ctx, `+ SELECT rolcanlogin, rolsuper, rolcreatedb, rolcreaterole, rolreplication, rolbypassrls+ FROM pg_roles+ WHERE rolname = $1+ `, allocation.Role).Scan(&canLogin, &superuser, &createDatabase, &createRole, &replicate, &bypassRLS))+ require.NoError(tst, admin.QueryRow(ctx, `+ SELECT NOT EXISTS (+ SELECT 1+ FROM pg_database, aclexplode(COALESCE(datacl, acldefault('d', datdba))) AS privilege+ WHERE datname = $1+ AND privilege.grantee = 0+ AND privilege.privilege_type = 'CONNECT'+ )+ `, allocation.Database).Scan(&publicConnect))+ database, err := t.connect(ctx, allocation.Database, "", "")+ require.NoError(tst, err)+ defer database.Close(ctx)+ require.NoError(tst, database.QueryRow(ctx, `+ SELECT NOT EXISTS (+ SELECT 1+ FROM pg_namespace, aclexplode(COALESCE(nspacl, acldefault('n', nspowner))) AS privilege+ WHERE nspname = 'public'+ AND privilege.grantee = 0+ AND privilege.privilege_type = 'CREATE'+ )+ `).Scan(&publicCreate))+ require.True(tst, canLogin)+ require.False(tst, superuser)+ require.False(tst, createDatabase)+ require.False(tst, createRole)+ require.False(tst, replicate)+ require.False(tst, bypassRLS)+ require.True(tst, publicConnect)+ require.True(tst, publicCreate)+}++func (t *sampleTargetInspector) dropResources(ctx context.Context, allocation sampleprojectinstance.Allocation) error {+ admin, err := t.connect(ctx, "", "", "")+ if err != nil {+ return err+ }+ defer admin.Close(ctx)+ if t.databaseExists(ctx, allocation.Database) {+ if _, err := admin.Exec(ctx, fmt.Sprintf("DROP DATABASE %s", pgx.Identifier{allocation.Database}.Sanitize())); err != nil {+ return err+ }+ }+ if t.roleExists(ctx, allocation.Role) {+ if _, err := admin.Exec(ctx, fmt.Sprintf("DROP ROLE %s", pgx.Identifier{allocation.Role}.Sanitize())); err != nil {+ return err+ }+ }+ return nil+}++func (t *sampleTargetInspector) externalRoleConnection(ctx context.Context, tst *testing.T, allocation sampleprojectinstance.Allocation) *pgx.Conn {+ tst.Helper()+ admin, err := t.connect(ctx, "", "", "")+ require.NoError(tst, err)+ defer admin.Close(ctx)+ database := "outside_" + sampleToken(allocation.Role)+ _, err = admin.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{database}.Sanitize()))+ require.NoError(tst, err)+ tst.Cleanup(func() {+ cleanupCtx, cancel := context.WithTimeout(context.Background(), time.Minute)+ defer cancel()+ cleanup, cleanupErr := t.connect(cleanupCtx, "", "", "")+ if cleanupErr == nil {+ defer cleanup.Close(cleanupCtx)+ _, _ = cleanup.Exec(cleanupCtx, fmt.Sprintf("DROP DATABASE IF EXISTS %s WITH (FORCE)", pgx.Identifier{database}.Sanitize()))+ }+ })+ conn, err := t.connect(ctx, database, allocation.Role, allocation.Password)+ require.NoError(tst, err)+ return conn+}diff --git a/backend/api/v1/testdata/mcp_method_classification.md b/backend/api/v1/testdata/mcp_method_classification.mdindex 0fc8b08f02..cb98283b4f 100644--- a/backend/api/v1/testdata/mcp_method_classification.md+++ b/backend/api/v1/testdata/mcp_method_classification.md@@ -18,10 +18,10 @@ served by no ceiling.|---|---|---|| READ | 56 | served to a read-only session and above || WRITE | 40 | served to a read-write session only |-| EXCLUDED | 85 | served by no ceiling this phase ships |+| EXCLUDED | 86 | served by no ceiling this phase ships || FORBIDDEN | 28 | never served, whatever the ceiling || MCP_METHOD_CLASS_UNSPECIFIED | 0 | unclassified — CI rejects this, and the gate refuses it |-| **total** | **209** | |+| **total** | **210** | || Method | Class | Reason | Permission ||---|---|---|---|@@ -91,6 +91,7 @@ served by no ceiling.| InstanceService/GetInstance | READ | — | bb.instances.get || InstanceService/ListInstanceDatabase | EXCLUDED | ADMINISTERS_THE_WORKSPACE | bb.instances.get || InstanceService/ListInstances | READ | — | bb.instances.list |+| InstanceService/PrepareSampleProjectInstance | EXCLUDED | ADMINISTERS_THE_WORKSPACE | bb.instances.create || InstanceService/RemoveDataSource | EXCLUDED | ADMINISTERS_THE_WORKSPACE | bb.instances.update || InstanceService/SyncInstance | WRITE | — | bb.instances.sync || InstanceService/UndeleteInstance | EXCLUDED | ADMINISTERS_THE_WORKSPACE | bb.instances.undelete |diff --git a/backend/bin/server/cmd/profile.go b/backend/bin/server/cmd/profile.goindex ea3b65a17d..2ae7b74757 100644--- a/backend/bin/server/cmd/profile.go+++ b/backend/bin/server/cmd/profile.go@@ -11,21 +11,22 @@ import (func getBaseProfile(dataDir string) *config.Profile {config := &config.Profile{- ExternalURL: flags.externalURL,- Port: flags.port, // Using flags.port as our gRPC server port.- DatastorePort: flags.port + 2, // Using flags.port + 2 as our datastore port.- HA: flags.ha,- SaaS: flags.saas,- Debug: flags.debug,- IsDocker: isDocker(),- DataDir: dataDir,- Version: version,- GitCommit: gitcommit,- PgURL: os.Getenv("PG_URL"),- ReplicaID: uuid.NewString(),- StripeAPISecret: os.Getenv("STRIPE_API_SECRET"),- StripeWebhookSecret: os.Getenv("STRIPE_WEBHOOK_SECRET"),- LicensePrivateKey: os.Getenv("LICENSE_PRIVATE_KEY"),+ ExternalURL: flags.externalURL,+ Port: flags.port, // Using flags.port as our gRPC server port.+ DatastorePort: flags.port + 2, // Using flags.port + 2 as our datastore port.+ HA: flags.ha,+ SaaS: flags.saas,+ Debug: flags.debug,+ IsDocker: isDocker(),+ DataDir: dataDir,+ Version: version,+ GitCommit: gitcommit,+ PgURL: os.Getenv("PG_URL"),+ SampleProjectInstancePgURL: os.Getenv("SAMPLE_PROJECT_INSTANCE_PG_URL"),+ ReplicaID: uuid.NewString(),+ StripeAPISecret: os.Getenv("STRIPE_API_SECRET"),+ StripeWebhookSecret: os.Getenv("STRIPE_WEBHOOK_SECRET"),+ LicensePrivateKey: os.Getenv("LICENSE_PRIVATE_KEY"),}config.LastActiveTS.Store(time.Now().Unix())diff --git a/backend/common/testcontainer/testcontainer.go b/backend/common/testcontainer/testcontainer.goindex 08a445f4df..30cee0c68f 100644--- a/backend/common/testcontainer/testcontainer.go+++ b/backend/common/testcontainer/testcontainer.go@@ -1,10 +1,20 @@package testcontainerimport (+ "bytes""context"+ "crypto/rand"+ "crypto/rsa"+ "crypto/x509"+ "crypto/x509/pkix""database/sql"+ "encoding/pem""fmt""log/slog"+ "math/big"+ "net"+ "os"+ "path/filepath""runtime""strings""testing"@@ -21,6 +31,8 @@ type Container struct {host stringport stringdb *sql.DB+ tlsDir string+ tlsCAPath string}func (c *Container) GetHost() string {@@ -35,6 +47,12 @@ func (c *Container) GetDB() *sql.DB {return c.db}+// GetTLSCAPath returns the CA certificate path for a TLS-enabled PostgreSQL+// container.+func (c *Container) GetTLSCAPath() string {+ return c.tlsCAPath+}+func (c *Container) Close(ctx context.Context) {if c == nil {return@@ -49,6 +67,11 @@ func (c *Container) Close(ctx context.Context) {slog.Error("close container error")}}+ if c.tlsDir != "" {+ if err := os.RemoveAll(c.tlsDir); err != nil {+ slog.Error("remove TLS directory error")+ }+ }}// GetTestMySQLContainer creates a MySQL container for testing@@ -106,6 +129,12 @@ func GetPgContainer(ctx context.Context) (*Container, error) {return getPgContainerWithImage(ctx, "postgres:16-alpine")}+// GetTLSPgContainer creates a TLS-enabled PostgreSQL 16 container. Clients+// can connect with sslmode=verify-full and the CA returned by GetTLSCAPath.+func GetTLSPgContainer(ctx context.Context) (*Container, error) {+ return getTLSPgContainerWithImage(ctx, "postgres:16-alpine")+}+// GetPg17Container creates a PostgreSQL 17 container for testing. PG17 is required// for features absent in 16 — notably MERGE ... RETURNING.func GetPg17Container(ctx context.Context) (*Container, error) {@@ -162,6 +191,153 @@ func getPgContainerWithImage(ctx context.Context, image string) (retC *Container}, nil}+func getTLSPgContainerWithImage(ctx context.Context, image string) (retC *Container, retErr error) {+ tlsDir, ca, certificate, key, err := createPostgreSQLTLSMaterial()+ if err != nil {+ return nil, err+ }+ defer func() {+ if retErr != nil {+ _ = os.RemoveAll(tlsDir)+ }+ }()++ req := testcontainers.ContainerRequest{+ Image: image,+ Env: map[string]string{+ "LANG": "en_US.UTF-8",+ "POSTGRES_PASSWORD": "root-password",+ },+ ExposedPorts: []string{"5432/tcp"},+ Entrypoint: []string{+ "/bin/sh",+ "-c",+ "chown postgres:postgres /tmp/server.key && exec /usr/local/bin/docker-entrypoint.sh \"$@\"",+ "--",+ },+ Cmd: []string{+ "postgres",+ "-c", "ssl=on",+ "-c", "ssl_cert_file=/tmp/server.crt",+ "-c", "ssl_key_file=/tmp/server.key",+ },+ Files: []testcontainers.ContainerFile{+ {Reader: bytes.NewReader(certificate), ContainerFilePath: "/tmp/server.crt", FileMode: 0o644},+ {Reader: bytes.NewReader(key), ContainerFilePath: "/tmp/server.key", FileMode: 0o600},+ },+ WaitingFor: wait.ForLog("database system is ready to accept connections").WithOccurrence(2).WithStartupTimeout(5 * time.Minute),+ }+ c, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{+ ContainerRequest: req,+ Started: true,+ })+ if err != nil {+ return nil, err+ }+ var db *sql.DB+ defer func() {+ if retErr != nil {+ if db != nil {+ _ = db.Close()+ }+ _ = c.Terminate(ctx)+ }+ }()++ host, err := c.Host(ctx)+ if err != nil {+ return nil, err+ }+ port, err := c.MappedPort(ctx, "5432/tcp")+ if err != nil {+ return nil, err+ }+ db, err = sql.Open("pgx", fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=postgres sslmode=disable", host, port.Port()))+ if err != nil {+ return nil, err+ }+ if err := waitDBPing(ctx, db); err != nil {+ return nil, err+ }++ return &Container{+ container: c,+ host: host,+ port: port.Port(),+ db: db,+ tlsDir: tlsDir,+ tlsCAPath: ca,+ }, nil+}++func createPostgreSQLTLSMaterial() (string, string, []byte, []byte, error) {+ tlsDir, err := os.MkdirTemp("", "bytebase-postgres-tls-*")+ if err != nil {+ return "", "", nil, nil, err+ }+ fail := func(err error) (string, string, []byte, []byte, error) {+ _ = os.RemoveAll(tlsDir)+ return "", "", nil, nil, err+ }++ caKey, err := rsa.GenerateKey(rand.Reader, 2048)+ if err != nil {+ return fail(err)+ }+ serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))+ if err != nil {+ return fail(err)+ }+ now := time.Now()+ caTemplate := x509.Certificate{+ SerialNumber: serial,+ Subject: pkix.Name{CommonName: "Bytebase PostgreSQL Test CA"},+ NotBefore: now.Add(-time.Minute),+ NotAfter: now.Add(24 * time.Hour),+ IsCA: true,+ BasicConstraintsValid: true,+ KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageDigitalSignature,+ }+ caDER, err := x509.CreateCertificate(rand.Reader, &caTemplate, &caTemplate, &caKey.PublicKey, caKey)+ if err != nil {+ return fail(err)+ }+ ca, err := x509.ParseCertificate(caDER)+ if err != nil {+ return fail(err)+ }+ serverKey, err := rsa.GenerateKey(rand.Reader, 2048)+ if err != nil {+ return fail(err)+ }+ serial, err = rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))+ if err != nil {+ return fail(err)+ }+ serverTemplate := x509.Certificate{+ SerialNumber: serial,+ Subject: pkix.Name{CommonName: "localhost"},+ DNSNames: []string{"localhost"},+ IPAddresses: []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("::1")},+ NotBefore: now.Add(-time.Minute),+ NotAfter: now.Add(24 * time.Hour),+ KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},+ }+ serverDER, err := x509.CreateCertificate(rand.Reader, &serverTemplate, ca, &serverKey.PublicKey, caKey)+ if err != nil {+ return fail(err)+ }+ caPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: caDER})+ certificate := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: serverDER})+ key := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(serverKey)})+ caPath := filepath.Join(tlsDir, "ca.crt")+ if err := os.WriteFile(caPath, caPEM, 0o644); err != nil {+ return fail(err)+ }+ return tlsDir, caPath, certificate, key, nil+}+func waitDBPing(ctx context.Context, db *sql.DB) error {started := time.Now()ticker := time.NewTicker(3 * time.Second)@@ -195,6 +371,17 @@ func GetTestPgContainer(ctx context.Context, t testing.TB) *Container {return container}+// GetTestTLSPgContainer creates a TLS-enabled PostgreSQL container, failing+// the test when the container cannot be started.+func GetTestTLSPgContainer(ctx context.Context, t testing.TB) *Container {+ t.Helper()+ container, err := GetTLSPgContainer(ctx)+ if err != nil {+ t.Fatalf("failed to create TLS PostgreSQL container: %v", err)+ }+ return container+}+// GetTestPg17Container creates a PostgreSQL 17 container for testing, failing the// test on error.func GetTestPg17Container(ctx context.Context, t testing.TB) *Container {diff --git a/backend/component/config/profile.go b/backend/component/config/profile.goindex 2b35fb0e91..88d37e8621 100644--- a/backend/component/config/profile.go+++ b/backend/component/config/profile.go@@ -39,6 +39,10 @@ type Profile struct {GitCommit string// PgURL is the optional external PostgreSQL instance connection urlPgURL string+ // SampleProjectInstancePgURL is the Cloud PostgreSQL target for managed+ // Sample Project Instances. It is read only from the environment and must+ // never be logged.+ SampleProjectInstancePgURL string// LastActiveTS is the service last active timestamp, any API calls will refresh this value.LastActiveTS atomic.Int64diff --git a/backend/component/sampleprojectinstance/cloudsql_smoke_test.go b/backend/component/sampleprojectinstance/cloudsql_smoke_test.gonew file mode 100644index 0000000000..40aee4c131--- /dev/null+++ b/backend/component/sampleprojectinstance/cloudsql_smoke_test.go@@ -0,0 +1,102 @@+package sampleprojectinstance++import (+ "context"+ "crypto/rand"+ "encoding/hex"+ "os"+ "testing"+ "time"++ "github.com/jackc/pgx/v5"+)++func TestCloudSQLSampleProjectInstanceSmoke(t *testing.T) {+ if os.Getenv("BB_RUN_CLOUD_SQL_SAMPLE_PROJECT_INSTANCE_SMOKE") != "1" {+ t.Skip("cloud SQL sample Project Instance smoke is disabled")+ }+ targetURL := os.Getenv("SAMPLE_PROJECT_INSTANCE_PG_URL")+ if targetURL == "" {+ t.Skip("cloud SQL sample Project Instance target is not configured")+ }++ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ defer cancel()+ target, err := NewTarget(targetURL)+ if err != nil {+ t.Fatal("cloud SQL sample Project Instance target is invalid")+ }+ if err := target.Validate(ctx); err != nil {+ t.Fatal("cloud SQL sample Project Instance target is not ready")+ }++ token, err := randomSmokeToken()+ if err != nil {+ t.Fatal("cloud SQL sample Project Instance allocation could not be generated")+ }+ allocation := Allocation{+ Database: "bbsi_" + token,+ Role: "bbsi_r_" + token,+ Password: token + token,+ }+ t.Cleanup(func() {+ cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), time.Minute)+ defer cleanupCancel()+ _ = target.Remove(cleanupCtx, allocation)+ })++ if err := target.Provision(ctx, allocation); err != nil {+ t.Fatal("cloud SQL sample Project Instance provisioning failed")+ }+ sampleConfig := target.config.Copy()+ sampleConfig.Database = allocation.Database+ sampleConfig.User = allocation.Role+ sampleConfig.Password = allocation.Password+ session, err := pgx.ConnectConfig(ctx, sampleConfig)+ if err != nil {+ t.Fatal("cloud SQL sample Project Instance role cannot connect")+ }+ defer session.Close(context.Background())+ if err := session.Ping(ctx); err != nil {+ t.Fatal("cloud SQL sample Project Instance role is unavailable")+ }+ cloudSQLAdminConfig := sampleConfig.Copy()+ cloudSQLAdminConfig.Database = "cloudsqladmin"+ cloudSQLAdminSession, err := pgx.ConnectConfig(ctx, cloudSQLAdminConfig)+ if err == nil {+ cloudSQLAdminSession.Close(context.Background())+ t.Fatal("cloud SQL sample Project Instance role can connect to cloudsqladmin")+ }++ if err := target.Remove(ctx, allocation); err != nil {+ t.Fatal("cloud SQL sample Project Instance cleanup failed")+ }+ if err := session.Ping(ctx); err == nil {+ t.Fatal("cloud SQL sample Project Instance session remained connected")+ }++ control, err := target.connect(ctx, "", "", "")+ if err != nil {+ t.Fatal("cloud SQL sample Project Instance cleanup could not be verified")+ }+ defer control.Close(ctx)+ databasePresent, err := databaseExists(ctx, control, allocation.Database)+ if err != nil || databasePresent {+ t.Fatal("cloud SQL sample Project Instance database remains after cleanup")+ }+ rolePresent, err := roleExists(ctx, control, allocation.Role)+ if err != nil || rolePresent {+ t.Fatal("cloud SQL sample Project Instance role remains after cleanup")+ }+ if err := target.Remove(ctx, allocation); err != nil {+ t.Fatal("cloud SQL sample Project Instance cleanup is not idempotent")+ }+}++func randomSmokeToken() (string, error) {+ bytes := make([]byte, 6)+ if _, err := rand.Read(bytes); err != nil {+ return "", err+ }+ return hex.EncodeToString(bytes), nil+}diff --git a/backend/component/sampleprojectinstance/manager.go b/backend/component/sampleprojectinstance/manager.gonew file mode 100644index 0000000000..0b66799472--- /dev/null+++ b/backend/component/sampleprojectinstance/manager.go@@ -0,0 +1,641 @@+// Package sampleprojectinstance manages the lifecycle of Cloud sample project+// instances.+package sampleprojectinstance++import (+ "context"+ "crypto/rand"+ "crypto/sha256"+ "encoding/base64"+ "encoding/hex"+ "errors"+ "fmt"+ "io"+ "log/slog"+ "time"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/runner/schemasync"+ "github.com/bytebase/bytebase/backend/store"+)++const (+ sampleProjectInstanceTitle = "Sample Project Instance"+ testEnvironmentID = "test"+ sampleLifetime = 7 * 24 * time.Hour+ prepareDeadline = 3 * time.Minute+ provisionDeadline = 2 * time.Minute+ compensationDeadline = time.Minute+ cleanupValidationDeadline = 10 * time.Second+ cleanupAttemptDeadline = time.Minute+ staleReservationAge = time.Hour+ replicaHeartbeatStaleness = time.Minute+ pollInitialDelay = 10 * time.Millisecond+ pollMaxDelay = time.Second+)++// FailureKind classifies failures at the Manager seam.+type FailureKind string++const (+ // FailureUnknown is the default for unexpected failures.+ FailureUnknown FailureKind = "unknown"+ // FailureFailedPrecondition indicates an unavailable or already consumed+ // Sample Project Instance entitlement.+ FailureFailedPrecondition FailureKind = "failed_precondition"+ // FailureUnavailable indicates a retryable target or compensation failure.+ FailureUnavailable FailureKind = "unavailable"+ // FailureDeadlineExceeded indicates lifecycle work exceeded its deadline.+ FailureDeadlineExceeded FailureKind = "deadline_exceeded"+)++type failure struct {+ kind FailureKind+ err error+}++func (e *failure) Error() string {+ if e.err == nil {+ return string(e.kind)+ }+ return e.err.Error()+}++func (e *failure) Unwrap() error {+ return e.err+}++// FailureKindOf returns the Manager failure classification.+func FailureKindOf(err error) FailureKind {+ var classified *failure+ if errors.As(err, &classified) {+ return classified.kind+ }+ return FailureUnknown+}++func newFailure(kind FailureKind, err error) error {+ if kind == FailureUnknown {+ return err+ }+ return &failure{kind: kind, err: err}+}++// AllocationNames are the deterministic names allocated to one persisted reservation.+type AllocationNames struct {+ Database string+ Role string+}++func sampleNames(instanceID string) AllocationNames {+ sum := sha256.Sum256([]byte(instanceID))+ token := fmt.Sprintf("%x", sum[:16])+ return AllocationNames{+ Database: "bb_sample_" + token,+ Role: "bb_sample_role_" + token,+ }+}++// PrepareRequest identifies the Project that will own the sample instance.+type PrepareRequest struct {+ WorkspaceID string+ ProjectID string+ CheckCreatePolicy func(context.Context) (CreatePolicyResult, error)+}++// CreatePolicyResult is the transport-neutral capacity decision supplied by+// the API adapter. A nil DeniedReason allows creation.+type CreatePolicyResult struct {+ DeniedReason error+}++// PrepareResult is the result of preparation. PolicyDenied is set only when+// creation was rejected by the supplied capacity policy.+type PrepareResult struct {+ Instance *store.InstanceMessage+ PolicyDenied error+}++// registration is the normal Instance registration requested by Manager.+// createMetadata persists the datasource with Store.CreateInstance so the+// password is encrypted at rest.+type registration struct {+ WorkspaceID string+ ProjectID string+ EnvironmentID string+ InstanceID string+ Title string+ Engine storepb.Engine+ AdminDataSource *storepb.DataSource+ SyncDatabaseNames []string+}++// metadataState is the exact resource state needed to decide idempotency.+type metadataState struct {+ ProjectActive bool+ InstanceMatches bool+ Instance *store.InstanceMessage+ Database *store.DatabaseMessage+}++func (s metadataState) active() bool {+ return s.ProjectActive && s.InstanceMatches && s.Instance != nil && !s.Instance.Deleted && s.Database != nil && !s.Database.Deleted+}++func (s metadataState) matches(reservation *store.SampleProjectInstanceMessage) bool {+ return s.active() &&+ s.Instance.ResourceID == reservation.InstanceID &&+ s.Database.InstanceID == reservation.InstanceID &&+ s.Database.DatabaseName == reservation.DBName+}++// ManagerOptions control manager identity and lifecycle test seams.+type ManagerOptions struct {+ Clock func() time.Time+ Random io.Reader+ Logger *slog.Logger+ ReplicaID string+}++// Manager orchestrates reservation, physical provisioning, metadata+// registration, discovery, expiration, and cleanup.+type Manager struct {+ store *store.Store+ target *Target+ targetErr error+ syncer *schemasync.Syncer+ clock func() time.Time+ random io.Reader+ logger *slog.Logger+ replicaID string+}++// NewManagerFromURL creates a startup-safe manager from raw target+// configuration. Invalid static configuration is retained for lifecycle calls+// instead of failing process startup.+func NewManagerFromURL(+ s *store.Store,+ targetURL string,+ syncer *schemasync.Syncer,+ options ManagerOptions,+) *Manager {+ target, err := NewTarget(targetURL)+ manager := NewManager(s, target, syncer, options)+ manager.targetErr = err+ return manager+}++// NewManager creates a Sample Project Instance lifecycle manager.+func NewManager(+ s *store.Store,+ target *Target,+ syncer *schemasync.Syncer,+ options ManagerOptions,+) *Manager {+ if options.Clock == nil {+ options.Clock = time.Now+ }+ if options.Random == nil {+ options.Random = rand.Reader+ }+ if options.Logger == nil {+ options.Logger = slog.Default()+ }+ return &Manager{+ store: s,+ target: target,+ syncer: syncer,+ clock: options.Clock,+ random: options.Random,+ logger: options.Logger,+ replicaID: options.ReplicaID,+ }+}++// Prepare provisions and registers a seven-day sample instance for a project.+func (m *Manager) Prepare(ctx context.Context, request PrepareRequest) (*PrepareResult, error) {+ if m.store == nil || (m.target == nil && m.targetErr == nil) || m.syncer == nil || m.replicaID == "" {+ return nil, errors.New("sample project instance manager is not configured")+ }+ if request.WorkspaceID == "" || request.ProjectID == "" {+ return nil, newFailure(FailureFailedPrecondition, errors.New("sample project instance requires workspace and project"))+ }+ lifecycleCtx, lifecycleCancel := preparationLifecycleContext(ctx)+ defer lifecycleCancel()+ reservation, created, err := m.reserve(lifecycleCtx, request)+ if err != nil {+ return nil, err+ }+ delay := pollInitialDelay+ for {+ if created {+ return m.prepareOwned(lifecycleCtx, reservation, request, false)+ }+ if reservation.ProjectID != request.ProjectID || reservation.DeletedAt != nil {+ return nil, newFailure(FailureFailedPrecondition, errors.New("sample project instance entitlement is already consumed"))+ }+ if reservation.ExpiresAt != nil {+ return m.activeReservation(lifecycleCtx, reservation, request)+ }++ // ClaimSampleProjectInstance atomically validates that the observed+ // reservation has not changed and that the current attempt has exceeded+ // prepareDeadline. A different owner must also have a stale heartbeat.+ claimed, claimedOK, err := m.store.ClaimSampleProjectInstance(lifecycleCtx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt, m.replicaID, prepareDeadline, replicaHeartbeatStaleness)+ if err != nil {+ return nil, errors.Join(errors.New("failed to claim abandoned sample project instance reservation"), err)+ }+ if claimedOK {+ takeoverCtx, takeoverCancel := preparationLifecycleContext(ctx)+ result, err := m.prepareOwned(takeoverCtx, claimed, request, true)+ takeoverCancel()+ return result, err+ }+ if err := sleepContext(lifecycleCtx, delay); err != nil {+ return nil, newFailure(FailureDeadlineExceeded, err)+ }+ if delay < pollMaxDelay {+ delay *= 2+ if delay > pollMaxDelay {+ delay = pollMaxDelay+ }+ }+ reservation, err = m.store.GetSampleProjectInstance(lifecycleCtx, request.WorkspaceID)+ if err != nil {+ return nil, errors.Join(errors.New("failed to poll sample project instance reservation"), err)+ }+ created = false+ if reservation == nil {+ reservation, created, err = m.reserve(lifecycleCtx, request)+ if err != nil {+ return nil, err+ }+ }+ }+}++func preparationLifecycleContext(ctx context.Context) (context.Context, context.CancelFunc) {+ return context.WithTimeout(context.WithoutCancel(ctx), prepareDeadline)+}++func (m *Manager) reserve(ctx context.Context, request PrepareRequest) (*store.SampleProjectInstanceMessage, bool, error) {+ instanceID, err := randomInstanceID(m.random)+ if err != nil {+ return nil, false, errors.Join(errors.New("failed to generate sample project instance ID"), err)+ }+ names := sampleNames(instanceID)+ return m.store.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{+ WorkspaceID: request.WorkspaceID,+ ProjectID: request.ProjectID,+ InstanceID: instanceID,+ DBName: names.Database,+ RoleName: names.Role,+ ReplicaID: m.replicaID,+ })+}++func (m *Manager) activeReservation(+ ctx context.Context,+ reservation *store.SampleProjectInstanceMessage,+ request PrepareRequest,+) (*PrepareResult, error) {+ state, err := m.lookupMetadata(ctx, Allocation{Database: reservation.DBName, Role: reservation.RoleName}, reservation.InstanceID, request.WorkspaceID, request.ProjectID)+ if err != nil {+ return nil, errors.Join(errors.New("failed to inspect sample project instance metadata"), err)+ }+ if !state.matches(reservation) {+ return nil, newFailure(FailureFailedPrecondition, errors.New("sample project instance entitlement is already consumed"))+ }+ return &PrepareResult{Instance: state.Instance}, nil+}++func (m *Manager) prepareOwned(+ lifecycleCtx context.Context,+ reservation *store.SampleProjectInstanceMessage,+ request PrepareRequest,+ takeover bool,+) (*PrepareResult, error) {+ allocation := Allocation{Database: reservation.DBName, Role: reservation.RoleName}++ state, err := m.lookupMetadata(lifecycleCtx, allocation, reservation.InstanceID, request.WorkspaceID, request.ProjectID)+ if err != nil {+ err = errors.Join(errors.New("failed to inspect sample project instance metadata"), err)+ if takeover {+ return nil, newFailure(FailureUnavailable, err)+ }+ return nil, m.discardReservation(lifecycleCtx, reservation, err)+ }+ if reservation.ExpiresAt != nil {+ if !state.matches(reservation) {+ return nil, newFailure(FailureFailedPrecondition, errors.New("sample project instance entitlement is already consumed"))+ }+ return &PrepareResult{Instance: state.Instance}, nil+ }+ if !takeover && (state.Instance != nil || state.Database != nil) {+ return nil, m.discardReservation(lifecycleCtx, reservation, errors.New("sample project instance metadata collision"))+ }++ workCtx, workCancel := preparationWorkContext(lifecycleCtx)+ defer workCancel()+ if takeover {+ if m.targetErr != nil {+ return nil, mapTargetError(m.targetErr)+ }+ m.logger.InfoContext(workCtx, "reconciling stale sample project instance reservation", "workspace", request.WorkspaceID)+ if err := m.reconcile(workCtx, allocation, reservation.InstanceID, request); err != nil {+ m.logger.ErrorContext(workCtx, "failed to reconcile stale sample project instance reservation", "workspace", request.WorkspaceID, "error", err)+ return nil, newFailure(FailureUnavailable, err)+ }+ }++ if m.targetErr != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, mapTargetError(m.targetErr))+ }+ if err := m.target.Validate(workCtx); err != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, mapTargetError(err))+ }+ if request.CheckCreatePolicy != nil {+ policy, err := request.CheckCreatePolicy(workCtx)+ if err != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, err)+ }+ if policy.DeniedReason != nil {+ return m.denyByPolicy(lifecycleCtx, reservation, policy.DeniedReason)+ }+ }+ environments, err := m.store.GetEnvironment(workCtx, request.WorkspaceID)+ if err != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, errors.Join(errors.New("failed to inspect sample project instance environments"), err))+ }+ environmentID := ""+ for _, environment := range environments.GetEnvironments() {+ if environmentID == "" || environment.Id == testEnvironmentID {+ environmentID = environment.Id+ }+ if environment.Id == testEnvironmentID {+ break+ }+ }+ if environmentID == "" {+ return nil, m.discardReservation(lifecycleCtx, reservation, newFailure(FailureFailedPrecondition, errors.New("sample project instance requires an environment")))+ }++ password, err := randomPassword(m.random)+ if err != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, errors.Join(errors.New("failed to generate sample project instance password"), err))+ }+ allocation.Password = password+ config, err := m.target.InstanceConfig(allocation)+ if err != nil {+ return nil, m.discardReservation(lifecycleCtx, reservation, mapTargetError(err))+ }+ if len(config.SyncDatabaseNames) != 1 || config.SyncDatabaseNames[0] != allocation.Database {+ return nil, m.discardReservation(lifecycleCtx, reservation, errors.New("sample project instance sync filter invariant failed"))+ }++ m.logger.InfoContext(workCtx, "preparing sample project instance", "workspace", request.WorkspaceID, "project", request.ProjectID)+ provisionCtx, provisionCancel := context.WithTimeout(workCtx, provisionDeadline)+ err = m.target.Provision(provisionCtx, allocation)+ timedOut := errors.Is(provisionCtx.Err(), context.DeadlineExceeded)+ provisionCancel()+ if err != nil {+ return m.compensate(lifecycleCtx, reservation, allocation, request, mapProvisionError(err, timedOut))+ }+ registered, err := m.createMetadata(workCtx, registration{+ WorkspaceID: request.WorkspaceID,+ ProjectID: request.ProjectID,+ EnvironmentID: environmentID,+ InstanceID: reservation.InstanceID,+ Title: sampleProjectInstanceTitle,+ Engine: storepb.Engine_POSTGRES,+ AdminDataSource: config.AdminDataSource,+ SyncDatabaseNames: config.SyncDatabaseNames,+ })+ if err != nil {+ return m.compensate(lifecycleCtx, reservation, allocation, request, errors.Join(errors.New("failed to create sample project instance metadata"), err))+ }+ synced, _, databases, err := m.syncer.SyncInstance(workCtx, registered)+ if err != nil {+ return m.compensate(lifecycleCtx, reservation, allocation, request, mapDiscoveryError(workCtx, err))+ }+ if len(databases) != 1 || databases[0].DatabaseName != allocation.Database || databases[0].Deleted {+ return m.compensate(lifecycleCtx, reservation, allocation, request, errors.New("sample project instance discovery invariant failed"))+ }+ activated, activationErr := m.store.ActivateSampleProjectInstance(workCtx, reservation.WorkspaceID, reservation.InstanceID, m.replicaID, m.clock().Add(sampleLifetime))+ if !activated {+ activationErr = errors.Join(errors.New("failed to activate sample project instance"), activationErr)+ if common.ErrorCode(activationErr) == common.NotFound {+ activationErr = newFailure(FailureFailedPrecondition, activationErr)+ }+ return m.handleActivationFailure(lifecycleCtx, reservation, allocation, request, activationErr)+ }+ m.syncer.SyncDatabasesAsync(databases)+ return &PrepareResult{Instance: synced}, nil+}++func mapProvisionError(err error, timedOut bool) error {+ if timedOut {+ return newFailure(FailureDeadlineExceeded, context.DeadlineExceeded)+ }+ return mapTargetError(err)+}++func (m *Manager) reconcile(ctx context.Context, allocation Allocation, instanceID string, request PrepareRequest) error {+ metadataErr := m.removeMetadata(ctx, instanceID, request.WorkspaceID, request.ProjectID)+ if metadataErr != nil {+ metadataErr = errors.Join(errors.New("failed to remove partial sample project instance metadata"), metadataErr)+ }+ targetErr := m.target.Remove(ctx, allocation)+ if targetErr != nil {+ targetErr = errors.Join(errors.New("failed to remove partial sample project instance target resources"), targetErr)+ }+ return errors.Join(metadataErr, targetErr)+}++func (m *Manager) compensate(+ lifecycleCtx context.Context,+ reservation *store.SampleProjectInstanceMessage,+ allocation Allocation,+ request PrepareRequest,+ original error,+) (*PrepareResult, error) {+ m.logger.WarnContext(lifecycleCtx, "compensating failed sample project instance preparation", "workspace", request.WorkspaceID, "error", original)+ compensationCtx, cancel := context.WithTimeout(lifecycleCtx, compensationDeadline)+ defer cancel()+ current, err := m.store.GetSampleProjectInstance(compensationCtx, reservation.WorkspaceID)+ if err != nil {+ return nil, newFailure(FailureUnavailable, errors.Join(original, errors.New("failed to verify sample project instance compensation ownership"), err))+ }+ if current == nil || current.InstanceID != reservation.InstanceID || current.ReplicaID != m.replicaID || current.ExpiresAt != nil || current.DeletedAt != nil {+ return nil, newFailure(FailureUnavailable, errors.Join(original, errors.New("sample project instance reservation ownership changed before compensation")))+ }+ if err := m.reconcile(compensationCtx, allocation, reservation.InstanceID, request); err != nil {+ m.logger.ErrorContext(lifecycleCtx, "sample project instance compensation failed", "workspace", request.WorkspaceID, "error", err)+ return nil, newFailure(FailureUnavailable, err)+ }+ deleted, err := m.store.DeletePendingSampleProjectInstance(compensationCtx, reservation.WorkspaceID, reservation.InstanceID, m.replicaID)+ if err != nil || !deleted {+ if err == nil {+ err = errors.New("sample project instance reservation ownership changed during compensation")+ }+ m.logger.ErrorContext(lifecycleCtx, "failed to remove compensated sample project instance reservation", "workspace", request.WorkspaceID, "error", err)+ return nil, newFailure(FailureUnavailable, err)+ }+ return nil, original+}++func (m *Manager) discardReservation(ctx context.Context, reservation *store.SampleProjectInstanceMessage, original error) error {+ deleted, err := m.store.DeletePendingSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, m.replicaID)+ if err != nil || !deleted {+ if err == nil {+ err = errors.New("sample project instance reservation ownership changed before deletion")+ }+ m.logger.ErrorContext(ctx, "failed to discard sample project instance reservation", "error", err)+ return newFailure(FailureUnavailable, err)+ }+ return original+}++func (m *Manager) denyByPolicy(ctx context.Context, reservation *store.SampleProjectInstanceMessage, reason error) (*PrepareResult, error) {+ deleted, err := m.store.DeletePendingSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, m.replicaID)+ if err != nil || !deleted {+ if err == nil {+ err = errors.New("sample project instance reservation ownership changed before policy denial")+ }+ m.logger.ErrorContext(ctx, "failed to discard denied sample project instance reservation", "error", err)+ return nil, newFailure(FailureUnavailable, err)+ }+ return &PrepareResult{PolicyDenied: reason}, nil+}++// handleActivationFailure avoids compensating resources after ownership might+// have changed. Only an exact, still-pending reservation owned by this replica+// proves that this attempt may safely compensate.+func (m *Manager) handleActivationFailure(+ ctx context.Context,+ reservation *store.SampleProjectInstanceMessage,+ allocation Allocation,+ request PrepareRequest,+ original error,+) (*PrepareResult, error) {+ current, err := m.store.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ if err != nil {+ return nil, newFailure(FailureUnavailable, errors.Join(original, err))+ }+ if current != nil && current.InstanceID == reservation.InstanceID && current.ExpiresAt != nil {+ return m.activeReservation(ctx, current, request)+ }+ if current == nil || current.InstanceID != reservation.InstanceID || current.ReplicaID != m.replicaID || current.ExpiresAt != nil || current.DeletedAt != nil {+ return nil, newFailure(FailureUnavailable, original)+ }+ return m.compensate(ctx, reservation, allocation, request, original)+}++// Cleanup removes expired target resources and reconciles stale reservations.+func (m *Manager) Cleanup(ctx context.Context, now time.Time) error {+ if m.store == nil || (m.target == nil && m.targetErr == nil) {+ return errors.New("sample project instance manager is not configured")+ }+ targetErr := m.targetErr+ if targetErr == nil {+ validationCtx, validationCancel := context.WithTimeout(ctx, cleanupValidationDeadline)+ targetErr = m.target.ValidateForCleanup(validationCtx)+ validationCancel()+ }+ if targetErr != nil {+ count, countErr := m.store.CountSampleProjectInstancesForCleanup(ctx, now, now.Add(-staleReservationAge))+ if countErr != nil {+ m.logger.ErrorContext(ctx, "failed to count outstanding sample project instance cleanup records", "error", countErr)+ }+ m.logger.ErrorContext(ctx, "sample project instance cleanup target validation failed", "outstanding", count, "error", targetErr)+ return mapTargetError(targetErr)+ }+ var cleanupErr error+ for afterWorkspace := ""; ; {+ result, err := m.store.WithLockedSampleProjectInstanceCleanupRecord(ctx, now, now.Add(-staleReservationAge), afterWorkspace, func(callbackCtx context.Context, _ *store.SampleProjectInstanceTx, reservation *store.SampleProjectInstanceMessage) error {+ attemptCtx, cancel := context.WithTimeout(callbackCtx, cleanupAttemptDeadline)+ defer cancel()+ allocation := Allocation{Database: reservation.DBName, Role: reservation.RoleName}+ if reservation.ExpiresAt == nil {+ m.logger.InfoContext(callbackCtx, "reconciling stale sample project instance reservation", "workspace", reservation.WorkspaceID)+ err := m.reconcile(attemptCtx, allocation, reservation.InstanceID, PrepareRequest{WorkspaceID: reservation.WorkspaceID, ProjectID: reservation.ProjectID})+ if err != nil {+ m.logger.ErrorContext(callbackCtx, "failed to reconcile stale sample project instance reservation", "workspace", reservation.WorkspaceID, "error", err)+ }+ return err+ }+ m.logger.InfoContext(callbackCtx, "expiring sample project instance", "workspace", reservation.WorkspaceID)+ if err := m.target.Remove(attemptCtx, allocation); err != nil {+ m.logger.ErrorContext(callbackCtx, "failed to expire sample project instance", "workspace", reservation.WorkspaceID, "error", err)+ return err+ }+ return nil+ })+ if err != nil {+ return errors.Join(cleanupErr, err)+ }+ if !result.Found {+ return cleanupErr+ }+ afterWorkspace = result.WorkspaceID+ if result.CallbackErr != nil {+ cleanupErr = errors.Join(cleanupErr, result.CallbackErr)+ }+ }+}++func preparationWorkContext(lifecycleCtx context.Context) (context.Context, context.CancelFunc) {+ workDeadline := time.Now().Add(provisionDeadline)+ if lifecycleDeadline, ok := lifecycleCtx.Deadline(); ok {+ reservedDeadline := lifecycleDeadline.Add(-compensationDeadline)+ if reservedDeadline.Before(workDeadline) {+ workDeadline = reservedDeadline+ }+ }+ return context.WithDeadline(lifecycleCtx, workDeadline)+}++func sleepContext(ctx context.Context, duration time.Duration) error {+ timer := time.NewTimer(duration)+ defer timer.Stop()+ select {+ case <-ctx.Done():+ return ctx.Err()+ case <-timer.C:+ return nil+ }+}++func randomPassword(reader io.Reader) (string, error) {+ bytes := make([]byte, 32)+ if _, err := io.ReadFull(reader, bytes); err != nil {+ return "", err+ }+ return base64.RawURLEncoding.EncodeToString(bytes), nil+}++func randomInstanceID(reader io.Reader) (string, error) {+ bytes := make([]byte, 16)+ if _, err := io.ReadFull(reader, bytes); err != nil {+ return "", err+ }+ return "sample-" + hex.EncodeToString(bytes), nil+}++func mapTargetError(err error) error {+ if errors.Is(err, context.DeadlineExceeded) {+ return newFailure(FailureDeadlineExceeded, err)+ }+ if isStaticTargetError(err) {+ return newFailure(FailureFailedPrecondition, err)+ }+ return newFailure(FailureUnavailable, err)+}++func mapDiscoveryError(ctx context.Context, err error) error {+ if errors.Is(ctx.Err(), context.DeadlineExceeded) {+ return newFailure(FailureDeadlineExceeded, context.DeadlineExceeded)+ }+ return mapTargetError(err)+}diff --git a/backend/component/sampleprojectinstance/manager_test.go b/backend/component/sampleprojectinstance/manager_test.gonew file mode 100644index 0000000000..f47234c710--- /dev/null+++ b/backend/component/sampleprojectinstance/manager_test.go@@ -0,0 +1,561 @@+package sampleprojectinstance++import (+ "context"+ "database/sql"+ "errors"+ "fmt"+ "net/url"+ "sync"+ "sync/atomic"+ "testing"+ "time"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ "github.com/bytebase/bytebase/backend/component/dbfactory"+ "github.com/bytebase/bytebase/backend/enterprise"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/migrator"+ _ "github.com/bytebase/bytebase/backend/plugin/db/pg"+ "github.com/bytebase/bytebase/backend/runner/schemasync"+ "github.com/bytebase/bytebase/backend/store"+)++func TestFailureKindOf(t *testing.T) {+ require.Equal(t, FailureUnknown, FailureKindOf(errors.New("unexpected")))+ require.Equal(t, FailureFailedPrecondition, FailureKindOf(newFailure(FailureFailedPrecondition, errors.New("invalid target"))))+ require.Equal(t, FailureUnavailable, FailureKindOf(errors.Join(errors.New("wrapped"), newFailure(FailureUnavailable, errors.New("offline")))))+ require.Equal(t, FailureDeadlineExceeded, FailureKindOf(newFailure(FailureDeadlineExceeded, context.DeadlineExceeded)))+}++func TestMapTargetErrorUsesManagerFailureVocabulary(t *testing.T) {+ require.Equal(t, FailureFailedPrecondition, FailureKindOf(mapTargetError(staticTargetError("invalid target"))))+ require.Equal(t, FailureUnavailable, FailureKindOf(mapTargetError(errors.New("offline"))))+ require.Equal(t, FailureDeadlineExceeded, FailureKindOf(mapTargetError(context.DeadlineExceeded)))+}++func TestPreparationLifecycleContextRenewsDeadline(t *testing.T) {+ oldLifecycle, oldCancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second))+ defer oldCancel()++ freshLifecycle, freshCancel := preparationLifecycleContext(oldLifecycle)+ defer freshCancel()+ freshDeadline, ok := freshLifecycle.Deadline()+ require.True(t, ok)+ require.Greater(t, time.Until(freshDeadline), prepareDeadline-time.Second)+}++func TestManagerCompensatesConcreteMetadataFailure(t *testing.T) {+ ctx, db, s, target, manager := newConcreteManager(t)+ _, err := db.ExecContext(ctx, `+ CREATE FUNCTION fail_sample_instance_insert() RETURNS trigger+ LANGUAGE plpgsql AS $$+ BEGIN+ RAISE EXCEPTION 'injected instance persistence failure';+ END;+ $$;+ CREATE TRIGGER fail_sample_instance_insert+ BEFORE INSERT ON instance+ FOR EACH ROW+ WHEN (NEW.resource_id LIKE 'sample-%')+ EXECUTE FUNCTION fail_sample_instance_insert();+ `)+ require.NoError(t, err)++ _, err = manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.Error(t, err)+ require.Nil(t, mustGetSampleProjectInstance(ctx, t, s))+ assertNoSampleAllocations(ctx, t, target)++ _, err = db.ExecContext(ctx, `+ DROP TRIGGER fail_sample_instance_insert ON instance;+ DROP FUNCTION fail_sample_instance_insert();+ `)+ require.NoError(t, err)+ _, err = manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+}++func TestManagerCompensatesConcreteDiscoveryFailure(t *testing.T) {+ ctx, db, s, target, manager := newConcreteManager(t)+ const advisoryLockID = 4242+ lockConn, err := db.Conn(ctx)+ require.NoError(t, err)+ defer lockConn.Close()+ _, err = lockConn.ExecContext(ctx, "SELECT pg_advisory_lock($1)", advisoryLockID)+ require.NoError(t, err)+ _, err = db.ExecContext(ctx, fmt.Sprintf(`+ CREATE FUNCTION block_sample_instance_insert() RETURNS trigger+ LANGUAGE plpgsql AS $$+ BEGIN+ PERFORM pg_advisory_xact_lock(%d);+ RETURN NEW;+ END;+ $$;+ CREATE TRIGGER block_sample_instance_insert+ BEFORE INSERT ON instance+ FOR EACH ROW+ WHEN (NEW.resource_id LIKE 'sample-%%')+ EXECUTE FUNCTION block_sample_instance_insert();+ `, advisoryLockID))+ require.NoError(t, err)++ prepareErr := make(chan error, 1)+ go func() {+ _, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ prepareErr <- err+ }()+ require.Eventually(t, func() bool {+ var waiting bool+ err := db.QueryRowContext(ctx, `+ SELECT EXISTS (+ SELECT 1+ FROM pg_locks+ WHERE locktype = 'advisory' AND objid = $1 AND NOT granted+ )+ `, advisoryLockID).Scan(&waiting)+ return err == nil && waiting+ }, 30*time.Second, 50*time.Millisecond)++ reservation := mustGetSampleProjectInstance(ctx, t, s)+ require.NotNil(t, reservation)+ names := AllocationNames{Database: reservation.DBName, Role: reservation.RoleName}+ admin, err := target.connect(ctx, "", "", "")+ require.NoError(t, err)+ _, err = admin.Exec(ctx, fmt.Sprintf("ALTER ROLE %s NOLOGIN", quoteIdentifier(names.Role)))+ require.NoError(t, err)+ require.NoError(t, admin.Close(ctx))+ _, err = lockConn.ExecContext(ctx, "SELECT pg_advisory_unlock($1)", advisoryLockID)+ require.NoError(t, err)+ require.Error(t, <-prepareErr)+ require.Nil(t, mustGetSampleProjectInstance(ctx, t, s))+ assertAllocationAbsent(ctx, t, target, names)++ _, err = db.ExecContext(ctx, `+ DROP TRIGGER block_sample_instance_insert ON instance;+ DROP FUNCTION block_sample_instance_insert();+ `)+ require.NoError(t, err)+ _, err = manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+}++func TestManagerCompensatesWhenWorkspaceDeletedDuringProvisioning(t *testing.T) {+ ctx, db, s, target, manager := newConcreteManager(t)+ const advisoryLockID = 4243+ lockConn, err := db.Conn(ctx)+ require.NoError(t, err)+ defer lockConn.Close()+ _, err = lockConn.ExecContext(ctx, "SELECT pg_advisory_lock($1)", advisoryLockID)+ require.NoError(t, err)+ lockReleased := false+ defer func() {+ if !lockReleased {+ _, _ = lockConn.ExecContext(context.Background(), "SELECT pg_advisory_unlock($1)", advisoryLockID)+ }+ }()+ _, err = db.ExecContext(ctx, fmt.Sprintf(`+ CREATE FUNCTION block_sample_instance_activation() RETURNS trigger+ LANGUAGE plpgsql AS $$+ BEGIN+ PERFORM pg_advisory_xact_lock(%d);+ RETURN NEW;+ END;+ $$;+ CREATE TRIGGER block_sample_instance_activation+ BEFORE INSERT ON instance+ FOR EACH ROW+ WHEN (NEW.resource_id LIKE 'sample-%%')+ EXECUTE FUNCTION block_sample_instance_activation();+ `, advisoryLockID))+ require.NoError(t, err)++ prepareErr := make(chan error, 1)+ go func() {+ _, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ prepareErr <- err+ }()+ require.Eventually(t, func() bool {+ var waiting bool+ err := db.QueryRowContext(ctx, `+ SELECT EXISTS (+ SELECT 1+ FROM pg_locks+ WHERE locktype = 'advisory' AND objid = $1 AND NOT granted+ )+ `, advisoryLockID).Scan(&waiting)+ return err == nil && waiting+ }, 30*time.Second, 50*time.Millisecond)+ require.NoError(t, s.DeleteWorkspace(ctx, "workspace-a"))+ _, err = lockConn.ExecContext(ctx, "SELECT pg_advisory_unlock($1)", advisoryLockID)+ require.NoError(t, err)+ lockReleased = true++ err = <-prepareErr+ require.Equal(t, FailureFailedPrecondition, FailureKindOf(err))+ require.Nil(t, mustGetSampleProjectInstance(ctx, t, s))+ assertNoSampleAllocations(ctx, t, target)+ var activeInstances int+ require.NoError(t, db.QueryRowContext(ctx, `+ SELECT COUNT(*)+ FROM instance+ WHERE workspace = 'workspace-a'+ AND resource_id LIKE 'sample-%'+ AND deleted = FALSE+ `).Scan(&activeInstances))+ require.Zero(t, activeInstances)+}++func TestManagerRetriesWhenConcurrentFailureDeletesReservation(t *testing.T) {+ ctx, _, _, _, manager := newConcreteManager(t)+ policyDenied := errors.New("injected capacity denial")+ firstPolicyEntered := make(chan struct{})+ releaseFirstPolicy := make(chan struct{})+ type prepareResult struct {+ result *PrepareResult+ err error+ }+ prepare := func(checkPolicy func(context.Context) (CreatePolicyResult, error)) <-chan prepareResult {+ result := make(chan prepareResult, 1)+ go func() {+ prepared, err := manager.Prepare(ctx, PrepareRequest{+ WorkspaceID: "workspace-a",+ ProjectID: "project-a",+ CheckCreatePolicy: checkPolicy,+ })+ result <- prepareResult{result: prepared, err: err}+ }()+ return result+ }++ first := prepare(func(policyCtx context.Context) (CreatePolicyResult, error) {+ close(firstPolicyEntered)+ select {+ case <-releaseFirstPolicy:+ return CreatePolicyResult{DeniedReason: policyDenied}, nil+ case <-policyCtx.Done():+ return CreatePolicyResult{}, policyCtx.Err()+ }+ })+ <-firstPolicyEntered++ secondPolicyCalled := make(chan struct{}, 1)+ second := prepare(func(context.Context) (CreatePolicyResult, error) {+ secondPolicyCalled <- struct{}{}+ return CreatePolicyResult{DeniedReason: policyDenied}, nil+ })+ close(releaseFirstPolicy)++ for _, result := range []prepareResult{<-first, <-second} {+ require.NoError(t, result.err)+ require.NotNil(t, result.result)+ require.ErrorIs(t, result.result.PolicyDenied, policyDenied)+ }+ require.Len(t, secondPolicyCalled, 1)+}++func TestManagerDoesNotHoldMetadataConnectionWhileProvisioning(t *testing.T) {+ ctx, _, s, target, manager := newConcreteManager(t)+ maxOpenConnections := s.GetDB().Stats().MaxOpenConnections+ s.GetDB().SetMaxOpenConns(1)+ t.Cleanup(func() { s.GetDB().SetMaxOpenConns(maxOpenConnections) })+ entered := make(chan struct{})+ release := make(chan struct{})+ released := false+ defer func() {+ if !released {+ close(release)+ }+ }()+ target.provisionHook = func(stage provisionStage) error {+ if stage == provisionStageRoleCreated {+ close(entered)+ <-release+ }+ return nil+ }+ prepared := make(chan error, 1)+ go func() {+ _, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ prepared <- err+ }()+ <-entered++ _, err := s.GetEnvironment(ctx, "workspace-a")+ require.NoError(t, err)++ close(release)+ released = true+ require.NoError(t, <-prepared)+}++func TestManagerHealthyOwnerProvisionsOnce(t *testing.T) {+ ctx, _, s, target, first := newConcreteManager(t)+ licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, s, false, "")+ require.NoError(t, err)+ second := NewManager(s, target, schemasync.NewSyncer(s, dbfactory.New(s, licenseService), licenseService, nil), ManagerOptions{ReplicaID: "replica-b"})+ require.NoError(t, s.UpsertReplicaHeartbeat(ctx, "replica-a"))++ entered := make(chan struct{})+ release := make(chan struct{})+ var provisions atomic.Int32+ var enteredOnce sync.Once+ target.provisionHook = func(stage provisionStage) error {+ if stage == provisionStageRoleCreated {+ provisions.Add(1)+ enteredOnce.Do(func() { close(entered) })+ <-release+ }+ return nil+ }+ type prepareResult struct {+ result *PrepareResult+ err error+ }+ prepare := func(manager *Manager) <-chan prepareResult {+ result := make(chan prepareResult, 1)+ go func() {+ prepared, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ result <- prepareResult{result: prepared, err: err}+ }()+ return result+ }+ firstResult := prepare(first)+ <-entered+ secondResult := prepare(second)+ close(release)++ firstPrepared := <-firstResult+ secondPrepared := <-secondResult+ require.NoError(t, firstPrepared.err)+ require.NoError(t, secondPrepared.err)+ require.Equal(t, firstPrepared.result.Instance.ResourceID, secondPrepared.result.Instance.ResourceID)+ require.EqualValues(t, 1, provisions.Load())+}++func TestManagerTakesOverStaleReservationAfterReconciling(t *testing.T) {+ ctx, db, s, target, first := newConcreteManager(t)+ reservation, created, err := first.reserve(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+ require.True(t, created)+ allocation := Allocation{Database: reservation.DBName, Role: reservation.RoleName, Password: "sample-password"}+ require.NoError(t, target.Provision(ctx, allocation))+ _, err = db.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = now() - INTERVAL '3 minutes 1 second',+ replica_id = 'stopped-replica'+ WHERE workspace = 'workspace-a'+ `)+ require.NoError(t, err)++ licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, s, false, "")+ require.NoError(t, err)+ second := NewManager(s, target, schemasync.NewSyncer(s, dbfactory.New(s, licenseService), licenseService, nil), ManagerOptions{ReplicaID: "replica-b"})+ prepared, err := second.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+ require.NotNil(t, prepared.Instance)++ record := mustGetSampleProjectInstance(ctx, t, s)+ require.Equal(t, "replica-b", record.ReplicaID)+ require.NotNil(t, record.ExpiresAt)+ admin, err := target.connect(ctx, "", "", "")+ require.NoError(t, err)+ defer admin.Close(ctx)+ var exists bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", record.DBName).Scan(&exists))+ require.True(t, exists)+}++func TestManagerUsesFirstEnvironmentWhenTestIsMissing(t *testing.T) {+ ctx, _, s, _, manager := newConcreteManager(t)+ _, err := s.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_ENVIRONMENT,+ Workspace: "workspace-a",+ Value: &storepb.EnvironmentSetting{Environments: []*storepb.EnvironmentSetting_Environment{+ {Title: "Production", Id: "prod"},+ }},+ })+ require.NoError(t, err)++ result, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+ require.Equal(t, "prod", *result.Instance.EnvironmentID)+ reservation := mustGetSampleProjectInstance(ctx, t, s)+ require.NotNil(t, reservation)+ names := sampleNames(reservation.InstanceID)+ require.Equal(t, names.Database, reservation.DBName)+ require.Equal(t, names.Role, reservation.RoleName)+}++func TestManagerCompensatesProvisionFailures(t *testing.T) {+ stages := []provisionStage{+ provisionStageRoleCreated,+ provisionStageDatabaseCreated,+ }+ for _, stage := range stages {+ t.Run(string(stage), func(t *testing.T) {+ ctx, _, s, target, manager := newConcreteManager(t)+ target.provisionHook = func(current provisionStage) error {+ if current == stage {+ return errors.New("injected provisioning failure")+ }+ return nil+ }++ _, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.Equal(t, FailureUnavailable, FailureKindOf(err))+ require.Nil(t, mustGetSampleProjectInstance(ctx, t, s))+ assertNoSampleAllocations(ctx, t, target)+ })+ }+}++func TestManagerPreservesAndRecoversReservationWhenCompensationFails(t *testing.T) {+ ctx, db, s, target, manager := newConcreteManager(t)+ provisionFailed := false+ target.provisionHook = func(stage provisionStage) error {+ if stage == provisionStageDatabaseCreated && !provisionFailed {+ provisionFailed = true+ return errors.New("injected provisioning failure")+ }+ if stage == provisionStageCleanupRole {+ return errors.New("injected cleanup failure")+ }+ return nil+ }++ _, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.Equal(t, FailureUnavailable, FailureKindOf(err))+ reservation := mustGetSampleProjectInstance(ctx, t, s)+ require.NotNil(t, reservation)+ require.Nil(t, reservation.ExpiresAt)+ _, err = db.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = now() - INTERVAL '3 minutes 1 second'+ WHERE workspace = 'workspace-a'+ `)+ require.NoError(t, err)++ target.provisionHook = nil+ result, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+ require.NotNil(t, result.Instance)+ reservation = mustGetSampleProjectInstance(ctx, t, s)+ require.NotNil(t, reservation.ExpiresAt)+}++func TestManagerReconcileAttemptsTargetCleanupWhenMetadataRemovalFails(t *testing.T) {+ ctx, db, _, target, manager := newConcreteManager(t)+ _, err := db.ExecContext(ctx, `+ INSERT INTO project (resource_id, workspace, name)+ VALUES ('project-b', 'workspace-a', 'Project B')+ `)+ require.NoError(t, err)+ reservation, created, err := manager.reserve(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.NoError(t, err)+ require.True(t, created)+ allocation := Allocation{Database: reservation.DBName, Role: reservation.RoleName, Password: "sample-password"}+ require.NoError(t, target.Provision(ctx, allocation))+ _, err = manager.createMetadata(ctx, registration{+ WorkspaceID: "workspace-a",+ ProjectID: "project-b",+ EnvironmentID: testEnvironmentID,+ InstanceID: reservation.InstanceID,+ Title: sampleProjectInstanceTitle,+ Engine: storepb.Engine_POSTGRES,+ AdminDataSource: &storepb.DataSource{Id: "admin", Type: storepb.DataSourceType_ADMIN},+ SyncDatabaseNames: []string{reservation.DBName},+ })+ require.NoError(t, err)++ err = manager.reconcile(ctx, allocation, reservation.InstanceID, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})+ require.Error(t, err)+ assertAllocationAbsent(ctx, t, target, AllocationNames{Database: reservation.DBName, Role: reservation.RoleName})+}++func newConcreteManager(t *testing.T) (context.Context, *sql.DB, *store.Store, *Target, *Manager) {+ t.Helper()+ ctx, db, s := newManagerStore(t)+ _, err := db.ExecContext(ctx, `+ INSERT INTO project (resource_id, workspace, name)+ VALUES ('project-a', 'workspace-a', 'Project A')+ `)+ require.NoError(t, err)+ _, err = s.UpsertSetting(ctx, &store.SettingMessage{+ Name: storepb.SettingName_ENVIRONMENT,+ Workspace: "workspace-a",+ Value: &storepb.EnvironmentSetting{Environments: []*storepb.EnvironmentSetting_Environment{+ {Title: "Test", Id: testEnvironmentID},+ }},+ })+ require.NoError(t, err)++ container := testcontainer.GetTestTLSPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })+ targetURL := fmt.Sprintf(+ "postgres://postgres:root-password@localhost:%s/postgres?sslmode=verify-full&sslrootcert=%s",+ container.GetPort(),+ url.QueryEscape(container.GetTLSCAPath()),+ )+ target, err := NewTarget(targetURL)+ require.NoError(t, err)+ admin, err := target.connect(ctx, "", "", "")+ require.NoError(t, err)+ require.NoError(t, prepareBaseline(ctx, admin))+ require.NoError(t, admin.Close(ctx))+ licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, s, false, "")+ require.NoError(t, err)+ syncer := schemasync.NewSyncer(s, dbfactory.New(s, licenseService), licenseService, nil)+ return ctx, db, s, target, NewManager(s, target, syncer, ManagerOptions{ReplicaID: "replica-a"})+}++func assertAllocationAbsent(ctx context.Context, t *testing.T, target *Target, names AllocationNames) {+ t.Helper()+ conn, err := target.connect(ctx, "", "", "")+ require.NoError(t, err)+ defer conn.Close(ctx)+ var databaseExists, roleExists bool+ require.NoError(t, conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", names.Database).Scan(&databaseExists))+ require.NoError(t, conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", names.Role).Scan(&roleExists))+ require.False(t, databaseExists)+ require.False(t, roleExists)+}++func assertNoSampleAllocations(ctx context.Context, t *testing.T, target *Target) {+ t.Helper()+ conn, err := target.connect(ctx, "", "", "")+ require.NoError(t, err)+ defer conn.Close(ctx)+ var databaseCount, roleCount int+ require.NoError(t, conn.QueryRow(ctx, "SELECT COUNT(*) FROM pg_database WHERE datname LIKE 'bb\\_sample\\_%' ESCAPE '\\'").Scan(&databaseCount))+ require.NoError(t, conn.QueryRow(ctx, "SELECT COUNT(*) FROM pg_roles WHERE rolname LIKE 'bb\\_sample\\_role\\_%' ESCAPE '\\'").Scan(&roleCount))+ require.Zero(t, databaseCount)+ require.Zero(t, roleCount)+}++func mustGetSampleProjectInstance(ctx context.Context, t *testing.T, s *store.Store) *store.SampleProjectInstanceMessage {+ t.Helper()+ reservation, err := s.GetSampleProjectInstance(ctx, "workspace-a")+ require.NoError(t, err)+ return reservation+}++func newManagerStore(t *testing.T) (context.Context, *sql.DB, *store.Store) {+ t.Helper()+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })+ db := container.GetDB()+ require.NoError(t, migrator.MigrateSchema(ctx, db))+ _, err := db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ('workspace-a'), ('workspace-b')`)+ require.NoError(t, err)+ pgURL := fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=postgres", container.GetHost(), container.GetPort())+ s, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, s.Close()) })+ return ctx, db, s+}diff --git a/backend/component/sampleprojectinstance/metadata.go b/backend/component/sampleprojectinstance/metadata.gonew file mode 100644index 0000000000..a26f592da3--- /dev/null+++ b/backend/component/sampleprojectinstance/metadata.go@@ -0,0 +1,107 @@+package sampleprojectinstance++import (+ "context"++ "github.com/pkg/errors"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++// lookupMetadata reads the deterministic Instance across its workspace, then the+// expected project-scoped Database, including their deleted state.+func (m *Manager) lookupMetadata(+ ctx context.Context,+ allocation Allocation,+ instanceID, workspaceID, projectID string,+) (metadataState, error) {+ project, err := m.store.GetProject(ctx, &store.FindProjectMessage{+ ResourceID: &projectID,+ Workspace: workspaceID,+ ShowDeleted: true,+ })+ if err != nil {+ return metadataState{}, errors.Wrap(err, "get project")+ }+ state := metadataState{ProjectActive: project != nil && !project.Deleted}+ instance, err := m.store.GetInstance(ctx, &store.FindInstanceMessage{+ Workspace: workspaceID,+ ResourceID: &instanceID,+ ShowDeleted: true,+ })+ if err != nil {+ return metadataState{}, errors.Wrap(err, "get instance")+ }+ state.Instance = instance+ state.InstanceMatches = instance != nil && instance.ProjectID != nil && *instance.ProjectID == projectID+ database, err := m.store.GetDatabase(ctx, &store.FindDatabaseMessage{+ Workspace: workspaceID,+ ProjectID: &projectID,+ InstanceID: &instanceID,+ DatabaseName: &allocation.Database,+ ShowDeleted: true,+ })+ if err != nil {+ return metadataState{}, errors.Wrap(err, "get database")+ }+ state.Database = database+ return state, nil+}++// createMetadata persists the activated, project-scoped PostgreSQL Instance through+// Store.CreateInstance so credential obfuscation remains centralized.+func (m *Manager) createMetadata(ctx context.Context, registration registration) (*store.InstanceMessage, error) {+ return m.store.CreateInstance(ctx, &store.InstanceMessage{+ Workspace: registration.WorkspaceID,+ ProjectID: ®istration.ProjectID,+ EnvironmentID: ®istration.EnvironmentID,+ ResourceID: registration.InstanceID,+ Metadata: &storepb.Instance{+ Title: registration.Title,+ Engine: registration.Engine,+ Activation: true,+ DataSources: []*storepb.DataSource{registration.AdminDataSource},+ SyncDatabases: &storepb.SyncDatabases{+ Databases: registration.SyncDatabaseNames,+ },+ },+ })+}++// removeMetadata deletes only the exact persisted Sample Project Instance in+// its owning project and workspace. Mutable Instance metadata is not ownership+// evidence; the globally unique resource ID and reservation scope are.+func (m *Manager) removeMetadata(+ ctx context.Context,+ instanceID, workspaceID, projectID string,+) error {+ instance, err := m.store.GetInstance(ctx, &store.FindInstanceMessage{+ Workspace: workspaceID,+ ResourceID: &instanceID,+ ShowDeleted: true,+ })+ if err != nil {+ return errors.Wrap(err, "get instance for removal")+ }+ if instance == nil {+ return nil+ }+ if instance.ProjectID == nil || *instance.ProjectID != projectID {+ return errors.Errorf("Sample Project Instance %q belongs to a different project", instanceID)+ }+ if !instance.Deleted {+ deleted := true+ if _, err := m.store.UpdateInstance(ctx, &store.UpdateInstanceMessage{+ ResourceID: &instanceID,+ Workspace: workspaceID,+ Deleted: &deleted,+ }); err != nil {+ return errors.Wrap(err, "soft delete instance")+ }+ }+ if err := m.store.DeleteInstance(ctx, workspaceID, instanceID); err != nil {+ return errors.Wrap(err, "delete instance")+ }+ return nil+}diff --git a/backend/component/sampleprojectinstance/metadata_test.go b/backend/component/sampleprojectinstance/metadata_test.gonew file mode 100644index 0000000000..fb95948405--- /dev/null+++ b/backend/component/sampleprojectinstance/metadata_test.go@@ -0,0 +1,107 @@+package sampleprojectinstance++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++func TestManagerMetadataCreatesAndLooksUpScopedSampleProjectInstance(t *testing.T) {+ ctx, db, stores := newManagerStore(t)+ _, err := db.ExecContext(ctx, `+ INSERT INTO project (resource_id, workspace, name)+ VALUES+ ('project-a', 'workspace-a', 'Project A'),+ ('project-b', 'workspace-a', 'Project B')+ `)+ require.NoError(t, err)+ allocation := Allocation{Database: "sample-db", Role: "sample-role", Password: "secret"}+ manager := &Manager{store: stores}+ instance, err := manager.createMetadata(ctx, registration{+ WorkspaceID: "workspace-a",+ ProjectID: "project-a",+ EnvironmentID: "test",+ InstanceID: "sample-instance",+ Title: sampleProjectInstanceTitle,+ Engine: storepb.Engine_POSTGRES,+ AdminDataSource: &storepb.DataSource{+ Id: "admin",+ Type: storepb.DataSourceType_ADMIN,+ Database: allocation.Database,+ Username: allocation.Role,+ Password: allocation.Password,+ },+ SyncDatabaseNames: []string{allocation.Database},+ })+ require.NoError(t, err)+ require.True(t, instance.Metadata.GetActivation())+ require.Equal(t, allocation.Password, instance.Metadata.GetDataSources()[0].GetPassword())++ state, err := manager.lookupMetadata(ctx, allocation, "sample-instance", "workspace-a", "project-a")+ require.NoError(t, err)+ require.True(t, state.ProjectActive)+ require.True(t, state.InstanceMatches)+ require.NotNil(t, state.Instance)+ require.Nil(t, state.Database)++ _, err = stores.UpsertDatabase(ctx, &store.DatabaseMessage{+ InstanceID: "sample-instance",+ DatabaseName: allocation.Database,+ ProjectID: "project-a",+ Metadata: &storepb.DatabaseMetadata{},+ })+ require.NoError(t, err)+ state, err = manager.lookupMetadata(ctx, allocation, "sample-instance", "workspace-a", "project-a")+ require.NoError(t, err)+ require.NotNil(t, state.Database)++ instance.Metadata.Title = "Edited Sample Project Instance"+ _, err = stores.UpdateInstance(ctx, &store.UpdateInstanceMessage{+ ResourceID: &instance.ResourceID,+ Workspace: instance.Workspace,+ Metadata: instance.Metadata,+ })+ require.NoError(t, err)+ state, err = manager.lookupMetadata(ctx, allocation, "sample-instance", "workspace-a", "project-a")+ require.NoError(t, err)+ require.True(t, state.active())++ require.NoError(t, manager.removeMetadata(ctx, "sample-instance", "workspace-a", "project-a"))+ projectID := "project-a"+ instanceID := "sample-instance"+ removed, err := stores.GetInstance(ctx, &store.FindInstanceMessage{+ Workspace: "workspace-a",+ ProjectID: &projectID,+ ResourceID: &instanceID,+ })+ require.NoError(t, err)+ require.Nil(t, removed)++ _, err = manager.createMetadata(ctx, registration{+ WorkspaceID: "workspace-a",+ ProjectID: "project-a",+ EnvironmentID: "test",+ InstanceID: "cross-project-instance",+ Title: sampleProjectInstanceTitle,+ Engine: storepb.Engine_POSTGRES,+ AdminDataSource: &storepb.DataSource{+ Id: "admin",+ Type: storepb.DataSourceType_ADMIN,+ Database: allocation.Database,+ Username: allocation.Role,+ Password: allocation.Password,+ },+ SyncDatabaseNames: []string{allocation.Database},+ })+ require.NoError(t, err)+ state, err = manager.lookupMetadata(ctx, allocation, "cross-project-instance", "workspace-a", "project-b")+ require.NoError(t, err)+ require.True(t, state.ProjectActive)+ require.False(t, state.InstanceMatches)+ require.NotNil(t, state.Instance)+ require.Nil(t, state.Database)+ require.Error(t, manager.removeMetadata(ctx, "cross-project-instance", "workspace-a", "project-b"))+}diff --git a/backend/component/sampleprojectinstance/target.go b/backend/component/sampleprojectinstance/target.gonew file mode 100644index 0000000000..f087b1993d--- /dev/null+++ b/backend/component/sampleprojectinstance/target.go@@ -0,0 +1,493 @@+// Package sampleprojectinstance manages Cloud PostgreSQL targets for sample+// project instances.+package sampleprojectinstance++import (+ "context"+ "fmt"+ "net/url"+ "strconv"+ "strings"+ "time"++ "github.com/jackc/pgx/v5"+ "github.com/pkg/errors"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/db/util"+ "github.com/bytebase/bytebase/backend/resources/postgres"+)++// Allocation identifies the physical PostgreSQL resources for one sample+// project instance.+type Allocation struct {+ Database string+ Role string+ Password string+}++// InstanceConfig describes the registered instance connection and the exact+// database that must be discovered before preparation succeeds.+type InstanceConfig struct {+ AdminDataSource *storepb.DataSource+ SyncDatabaseNames []string+}++// Target manages direct PostgreSQL operations for sample project instances.+type Target struct {+ config *pgx.ConnConfig+ verifyTLS bool+ sslCA string+ provisionHook func(provisionStage) error+}++type provisionStage string++const (+ provisionStageRoleCreated provisionStage = "role-created"+ provisionStageDatabaseCreated provisionStage = "database-created"+ provisionStageCleanupDatabase provisionStage = "cleanup-database"+ provisionStageCleanupRole provisionStage = "cleanup-role"+)++type staticTargetFailure struct {+ err error+}++func (e *staticTargetFailure) Error() string {+ return e.err.Error()+}++func (e *staticTargetFailure) Unwrap() error {+ return e.err+}++// NewTarget parses a direct PostgreSQL target URL. It intentionally accepts+// only URL-form password authentication so the configured target cannot use+// passfiles, service files, or credential rotation indirection.+func NewTarget(targetURL string) (*Target, error) {+ u, err := url.Parse(targetURL)+ if err != nil || (u.Scheme != "postgres" && u.Scheme != "postgresql") {+ return nil, staticTargetError("sample project instance target must be a PostgreSQL URL")+ }+ if u.Hostname() == "" || u.Port() == "" || u.User == nil || u.User.Username() == "" || strings.TrimPrefix(u.EscapedPath(), "/") == "" {+ return nil, staticTargetError("sample project instance target URL requires host, port, user, and database")+ }+ port, err := strconv.ParseUint(u.Port(), 10, 16)+ if err != nil || port == 0 {+ return nil, staticTargetError("sample project instance target URL requires a valid port")+ }+ password, hasPassword := u.User.Password()+ if !hasPassword || password == "" {+ return nil, staticTargetError("sample project instance target URL requires password authentication")+ }++ query := u.Query()+ if len(query["sslmode"]) != 1 || query.Get("sslmode") != "verify-full" {+ return nil, staticTargetError("sample project instance target URL requires sslmode=verify-full")+ }+ for key := range query {+ if key != "sslmode" && key != "sslrootcert" {+ return nil, staticTargetError("sample project instance target URL only supports sslmode and sslrootcert")+ }+ }+ if roots, ok := query["sslrootcert"]; ok && (len(roots) != 1 || roots[0] == "") {+ return nil, staticTargetError("sample project instance target URL requires a single non-empty sslrootcert")+ }++ config, err := pgx.ParseConfig(targetURL)+ if err != nil {+ return nil, staticTargetError("invalid sample project instance target URL")+ }+ if len(config.Fallbacks) != 0 {+ return nil, staticTargetError("sample project instance target URL must use one host")+ }+ var sslCA string+ if path := query.Get("sslrootcert"); path != "" {+ resolved, err := util.ResolveTLSMaterial(&storepb.DataSource{+ UseSsl: true,+ SslCaPath: path,+ })+ if err != nil {+ return nil, staticTargetError("invalid sample project instance target sslrootcert")+ }+ sslCA = resolved.GetSslCa()+ }+ return newTargetFromConfig(config, true, sslCA), nil+}++// InstanceConfig builds the persisted admin datasource and its exact discovery+// filter for an allocation.+func (t *Target) InstanceConfig(allocation Allocation) (*InstanceConfig, error) {+ if err := validateProvisionAllocation(allocation); err != nil {+ return nil, err+ }+ return &InstanceConfig{+ AdminDataSource: &storepb.DataSource{+ Id: "admin",+ Type: storepb.DataSourceType_ADMIN,+ Host: t.config.Host,+ Port: fmt.Sprint(t.config.Port),+ Database: allocation.Database,+ Username: allocation.Role,+ Password: allocation.Password,+ UseSsl: true,+ VerifyTlsCertificate: t.verifyTLS,+ SslCa: t.sslCA,+ },+ SyncDatabaseNames: []string{allocation.Database},+ }, nil+}++func newTargetFromConfig(config *pgx.ConnConfig, verifyTLS bool, sslCA string) *Target {+ return &Target{+ config: config,+ verifyTLS: verifyTLS,+ sslCA: sslCA,+ }+}++// Validate verifies the target is reachable and has the static isolation+// baseline required before allocating shared sample databases.+func (t *Target) Validate(ctx context.Context) error {+ if err := t.validateCapabilities(ctx, true); err != nil {+ return err+ }+ return t.validateIsolationBaseline(ctx)+}++// ValidateForCleanup verifies the connectivity and target capabilities needed+// to remove existing allocations. Unlike Validate, it does not require the+// provisioning isolation baseline because a partially provisioned allocation+// may need cleanup before that baseline can be restored.+func (t *Target) ValidateForCleanup(ctx context.Context) error {+ return t.validateCapabilities(ctx, false)+}++func (t *Target) validateCapabilities(ctx context.Context, requireCreateDB bool) error {+ conn, err := t.connect(ctx, "", "", "")+ if err != nil {+ return errors.New("failed to connect to sample project instance target")+ }+ defer conn.Close(ctx)++ var canCreateDB, canCreateRole, canSignal bool+ if err := conn.QueryRow(ctx, `+ SELECT rolcreatedb, rolcreaterole, pg_has_role(current_user, 'pg_signal_backend', 'USAGE')+ FROM pg_roles+ WHERE rolname = current_user+ `).Scan(&canCreateDB, &canCreateRole, &canSignal); err != nil {+ return errors.New("failed to inspect sample project instance target role")+ }+ if requireCreateDB && (!canCreateDB || !canCreateRole || !canSignal) {+ return staticTargetError("sample project instance target role requires CREATEDB, CREATEROLE, and pg_signal_backend")+ }+ if !requireCreateDB && (!canCreateRole || !canSignal) {+ return staticTargetError("sample project instance target role requires CREATEROLE and pg_signal_backend for cleanup")+ }+ return nil+}++func (t *Target) validateIsolationBaseline(ctx context.Context) error {+ conn, err := t.connect(ctx, "", "", "")+ if err != nil {+ return errors.New("failed to connect to sample project instance target")+ }+ defer conn.Close(ctx)++ rows, err := conn.Query(ctx, `+ SELECT+ datname,+ datallowconn,+ EXISTS (+ SELECT 1+ FROM aclexplode(COALESCE(datacl, acldefault('d', datdba))) AS privilege+ WHERE privilege.grantee = 0+ AND privilege.privilege_type IN ('CONNECT', 'TEMPORARY')+ )+ FROM pg_database+ `)+ if err != nil {+ return errors.New("failed to inspect sample project instance target database privileges")+ }+ defer rows.Close()++ for rows.Next() {+ var name string+ var allowConnections, publicAccess bool+ if err := rows.Scan(&name, &allowConnections, &publicAccess); err != nil {+ return errors.New("failed to read sample project instance target database privileges")+ }+ switch name {+ case "postgres", "template1":+ if publicAccess {+ return staticTargetError("sample project instance target requires postgres and template1 to deny PUBLIC access")+ }+ case "template0":+ if allowConnections {+ return staticTargetError("sample project instance target requires template0 to deny connections")+ }+ case "cloudsqladmin":+ // Cloud SQL reserves this exact database for its administration+ // service. It is not a tenant-accessible sample database.+ default:+ if allowConnections && publicAccess {+ return staticTargetError("sample project instance target has a connectable database with PUBLIC access")+ }+ }+ }+ if err := rows.Err(); err != nil {+ return errors.New("failed to inspect sample project instance target database privileges")+ }+ return nil+}++// Provision creates a sample role and database, applies the isolation policy,+// and seeds the employee data as the sample role. On failure, callers clean up+// any resources created by this attempt with Remove.+func (t *Target) Provision(ctx context.Context, allocation Allocation) error {+ if err := validateProvisionAllocation(allocation); err != nil {+ return err+ }++ admin, err := t.connect(ctx, "", "", "")+ if err != nil {+ return errors.New("failed to connect to sample project instance target")+ }+ defer admin.Close(ctx)++ if _, err := admin.Exec(ctx, fmt.Sprintf(+ "CREATE ROLE %s LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOREPLICATION NOBYPASSRLS PASSWORD %s",+ quoteIdentifier(allocation.Role),+ quoteLiteral(allocation.Password),+ )); err != nil {+ return errors.New("failed to create sample project instance role")+ }+ if err := t.runProvisionHook(provisionStageRoleCreated); err != nil {+ return errors.New("failed after creating sample project instance role")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s WITH ALLOW_CONNECTIONS false", quoteIdentifier(allocation.Database))); err != nil {+ return errors.New("failed to create sample project instance database")+ }+ if err := t.runProvisionHook(provisionStageDatabaseCreated); err != nil {+ return errors.New("failed after creating sample project instance database")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf("REVOKE ALL PRIVILEGES ON DATABASE %s FROM PUBLIC", quoteIdentifier(allocation.Database))); err != nil {+ return errors.New("failed to revoke PUBLIC database privileges")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf(+ "GRANT CONNECT, CREATE, TEMPORARY ON DATABASE %s TO %s",+ quoteIdentifier(allocation.Database),+ quoteIdentifier(allocation.Role),+ )); err != nil {+ return errors.New("failed to grant sample project instance database privileges")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf("ALTER DATABASE %s ALLOW_CONNECTIONS true", quoteIdentifier(allocation.Database))); err != nil {+ return errors.New("failed to enable sample project instance database connections")+ }++ sampleAdmin, err := t.connect(ctx, allocation.Database, "", "")+ if err != nil {+ return errors.New("failed to connect to sample project instance database")+ }+ defer sampleAdmin.Close(ctx)+ if _, err := sampleAdmin.Exec(ctx, "REVOKE CREATE ON SCHEMA public FROM PUBLIC"); err != nil {+ return errors.New("failed to revoke PUBLIC schema creation")+ }+ if _, err := sampleAdmin.Exec(ctx, fmt.Sprintf("GRANT USAGE, CREATE ON SCHEMA public TO %s", quoteIdentifier(allocation.Role))); err != nil {+ return errors.New("failed to grant sample project instance schema privileges")+ }++ sample, err := t.connect(ctx, allocation.Database, allocation.Role, allocation.Password)+ if err != nil {+ return errors.New("failed to connect as sample project instance role")+ }+ defer sample.Close(ctx)++ seed, err := postgres.LoadSampleData()+ if err != nil {+ return errors.New("failed to load sample project instance seed data")+ }+ tx, err := sample.Begin(ctx)+ if err != nil {+ return errors.New("failed to begin sample project instance seed transaction")+ }+ defer tx.Rollback(ctx)+ if _, err := tx.Exec(ctx, seed, pgx.QueryExecModeSimpleProtocol); err != nil {+ return errors.New("failed to seed sample project instance database")+ }+ if err := tx.Commit(ctx); err != nil {+ return errors.New("failed to commit sample project instance seed transaction")+ }+ return nil+}++func (t *Target) runProvisionHook(stage provisionStage) error {+ if t.provisionHook == nil {+ return nil+ }+ return t.provisionHook(stage)+}++// Remove revokes access, terminates every role or database session, and drops+// the allocation's database before its role. Missing resources are successful.+func (t *Target) Remove(ctx context.Context, allocation Allocation) error {+ if err := validateCleanupAllocation(allocation); err != nil {+ return err+ }+ if allocation.Database != "" && t.config.Database == allocation.Database {+ return staticTargetError("sample project instance target cannot remove its configured database")+ }++ admin, err := t.connect(ctx, "", "", "")+ if err != nil {+ return errors.New("failed to connect to sample project instance target")+ }+ defer admin.Close(ctx)++ roleExists, err := roleExists(ctx, admin, allocation.Role)+ if err != nil {+ return errors.New("failed to inspect sample project instance role")+ }+ if roleExists {+ if _, err := admin.Exec(ctx, fmt.Sprintf("ALTER ROLE %s NOLOGIN", quoteIdentifier(allocation.Role))); err != nil {+ return errors.New("failed to disable sample project instance role")+ }+ }++ databaseExists, err := databaseExists(ctx, admin, allocation.Database)+ if err != nil {+ return errors.New("failed to inspect sample project instance database")+ }+ if databaseExists && roleExists {+ if _, err := admin.Exec(ctx, fmt.Sprintf("REVOKE ALL PRIVILEGES ON DATABASE %s FROM %s", quoteIdentifier(allocation.Database), quoteIdentifier(allocation.Role))); err != nil {+ return errors.New("failed to revoke sample project instance database privileges")+ }+ }+ if err := terminateAndDrain(ctx, admin, allocation); err != nil {+ return errors.New("failed to terminate sample project instance sessions")+ }+ if databaseExists {+ if err := t.runProvisionHook(provisionStageCleanupDatabase); err != nil {+ return errors.New("failed while removing sample project instance database")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf("DROP DATABASE %s WITH (FORCE)", quoteIdentifier(allocation.Database))); err != nil {+ return errors.New("failed to drop sample project instance database")+ }+ }+ if roleExists {+ if err := t.runProvisionHook(provisionStageCleanupRole); err != nil {+ return errors.New("failed while removing sample project instance role")+ }+ if _, err := admin.Exec(ctx, fmt.Sprintf("DROP ROLE %s", quoteIdentifier(allocation.Role))); err != nil {+ return errors.New("failed to drop sample project instance role")+ }+ }+ return nil+}++func (t *Target) connect(ctx context.Context, database, user, password string) (*pgx.Conn, error) {+ config := t.config.Copy()+ if database != "" {+ config.Database = database+ }+ if user != "" {+ config.User = user+ config.Password = password+ }+ return pgx.ConnectConfig(ctx, config)+}++func validateProvisionAllocation(allocation Allocation) error {+ if allocation.Database == "" || allocation.Role == "" ||+ strings.ContainsRune(allocation.Database, 0) || strings.ContainsRune(allocation.Role, 0) {+ return staticTargetError("sample project instance provisioning requires database and role")+ }+ if allocation.Password == "" || strings.ContainsRune(allocation.Password, 0) {+ return staticTargetError("sample project instance provisioning requires password")+ }+ return nil+}++func validateCleanupAllocation(allocation Allocation) error {+ if (allocation.Database == "" && allocation.Role == "") ||+ strings.ContainsRune(allocation.Database, 0) || strings.ContainsRune(allocation.Role, 0) {+ return staticTargetError("sample project instance cleanup requires a database or role")+ }+ return nil+}++func quoteIdentifier(value string) string {+ return pgx.Identifier{value}.Sanitize()+}++func quoteLiteral(value string) string {+ return "E'" + strings.NewReplacer(`\`, `\\`, `'`, `\'`).Replace(value) + "'"+}++func staticTargetError(message string) error {+ return &staticTargetFailure{err: errors.New(message)}+}++func isStaticTargetError(err error) bool {+ var failure *staticTargetFailure+ return errors.As(err, &failure)+}++func roleExists(ctx context.Context, conn *pgx.Conn, role string) (bool, error) {+ var exists bool+ err := conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", role).Scan(&exists)+ return exists, err+}++func databaseExists(ctx context.Context, conn *pgx.Conn, database string) (bool, error) {+ var exists bool+ err := conn.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", database).Scan(&exists)+ return exists, err+}++func terminateAndDrain(ctx context.Context, conn *pgx.Conn, allocation Allocation) error {+ for {+ rows, err := conn.Query(ctx, `+ SELECT pid+ FROM pg_stat_activity+ WHERE (usename = $1 OR datname = $2)+ AND pid <> pg_backend_pid()+ `, allocation.Role, allocation.Database)+ if err != nil {+ return errors.New("failed to list sample project instance sessions")+ }+ var pids []int32+ for rows.Next() {+ var pid int32+ if err := rows.Scan(&pid); err != nil {+ rows.Close()+ return errors.New("failed to read sample project instance session")+ }+ pids = append(pids, pid)+ }+ if err := rows.Err(); err != nil {+ rows.Close()+ return errors.New("failed to list sample project instance sessions")+ }+ rows.Close()+ if len(pids) == 0 {+ return nil+ }+ for _, pid := range pids {+ if _, err := conn.Exec(ctx, "SELECT pg_terminate_backend($1)", pid); err != nil {+ return errors.New("failed to terminate sample project instance session")+ }+ }++ timer := time.NewTimer(250 * time.Millisecond)+ select {+ case <-ctx.Done():+ if !timer.Stop() {+ <-timer.C+ }+ return errors.New("timed out waiting for sample project instance sessions to drain")+ case <-timer.C:+ }+ }+}diff --git a/backend/component/sampleprojectinstance/target_test.go b/backend/component/sampleprojectinstance/target_test.gonew file mode 100644index 0000000000..ddfeebbb0b--- /dev/null+++ b/backend/component/sampleprojectinstance/target_test.go@@ -0,0 +1,528 @@+package sampleprojectinstance++import (+ "context"+ "errors"+ "fmt"+ "net/url"+ "os"+ "testing"+ "time"++ "github.com/jackc/pgx/v5"+ _ "github.com/jackc/pgx/v5/stdlib"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common/testcontainer"+)++func TestNewTargetRejectsUnsafeConfiguration(t *testing.T) {+ for _, test := range []struct {+ name string+ targetURL string+ }{+ {name: "empty", targetURL: ""},+ {name: "keyword form", targetURL: "user=postgres password=secret host=db.example.com port=5432 dbname=postgres sslmode=require"},+ {name: "missing port", targetURL: "postgres://postgres:[email protected]/postgres?sslmode=require"},+ {name: "insecure TLS", targetURL: "postgres://postgres:[email protected]:5432/postgres?sslmode=disable"},+ {name: "unauthenticated TLS", targetURL: "postgres://postgres:[email protected]:5432/postgres?sslmode=require"},+ {name: "missing password", targetURL: "postgres://[email protected]:5432/postgres?sslmode=require"},+ {name: "passfile", targetURL: "postgres://postgres:[email protected]:5432/postgres?sslmode=require&passfile=/tmp/password"},+ } {+ t.Run(test.name, func(t *testing.T) {+ _, err := NewTarget(test.targetURL)+ require.Error(t, err)+ require.NotContains(t, err.Error(), "secret")+ require.True(t, isStaticTargetError(err))+ })+ }+}++func TestNewTargetBuildsRegistrationConfig(t *testing.T) {+ caPath := t.TempDir() + "/ca.pem"+ caPEM := `-----BEGIN CERTIFICATE-----+MIIDOTCCAiGgAwIBAgIQSRJrEpBGFc7tNb1fb5pKFzANBgkqhkiG9w0BAQsFADAS+MRAwDgYDVQQKEwdBY21lIENvMCAXDTcwMDEwMTAwMDAwMFoYDzIwODQwMTI5MTYw+MDAwWjASMRAwDgYDVQQKEwdBY21lIENvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A+MIIBCgKCAQEA6Gba5tHV1dAKouAaXO3/ebDUU4rvwCUg/CNaJ2PT5xLD4N1Vcb8r+bFSW2HXKq+MPfVdwIKR/1DczEoAGf/JWQTW7EgzlXrCd3rlajEX2D73faWJekD0U+aUgz5vtrTXZ90BQL7WvRICd7FlEZ6FPOcPlumiyNmzUqtwGhO+9ad1W5BqJaRI6P+YfouNkwR6Na4TzSj5BrqUfP0FwDizKSJ0XXmh8g8G9mtwxOSN3Ru1QFc61Xyeluk+POGKBV/q6RBNklTNe0gI8usUMlYyoC7ytppNMW7X2vodAelSu25jgx2anj9fDVZu+h7AXF5+4nJS4AAt0n1lNY7nGSsdZas8PbQIDAQABo4GIMIGFMA4GA1UdDwEB/wQE+AwICpDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud+DgQWBBStsdjh3/JCXXYlQryOrL4Sh7BW5TAuBgNVHREEJzAlggtleGFtcGxlLmNv+bYcEfwAAAYcQAAAAAAAAAAAAAAAAAAAAATANBgkqhkiG9w0BAQsFAAOCAQEAxWGI+5NhpF3nwwy/4yB4i/CwwSpLrWUa70NyhvprUBC50PxiXav1TeDzwzLx/o5HyNwsv+cxv3HdkLW59i/0SlJSrNnWdfZ19oTcS+6PtLoVyISgtyN6DpkKpdG1cOkW3Cy2P2++tK/tKHRP1Y/Ra0RiDpOAmqn0gCOFGz8+lqDIor/T7MTpibL3IxqWfPrvfVRHL3B+grw/ZQTTIVjjh4JBSW3WyWgNo/ikC1lrVxzl4iPUGptxT36Cr7Zk2Bsg0XqwbOvK+5d+NTDREkSnUbie4GeutujmX3Dsx88UiV6UY/4lHJa6I5leHUNOHahRbpbWeOfs/+WkBKOclmOV2xlTVuPw==+-----END CERTIFICATE-----`+ require.NoError(t, os.WriteFile(caPath, []byte(caPEM), 0o600))++ target, err := NewTarget("postgres://control:[email protected]:5432/postgres?sslmode=verify-full&sslrootcert=" + url.QueryEscape(caPath))+ require.NoError(t, err)+ require.NotNil(t, target.config.TLSConfig)+ require.False(t, target.config.TLSConfig.InsecureSkipVerify)+ require.Equal(t, "db.example.com", target.config.TLSConfig.ServerName)++ config, err := target.InstanceConfig(Allocation{+ Database: "sample_database",+ Role: "sample_role",+ Password: "sample-password",+ })+ require.NoError(t, err)+ require.Equal(t, "admin", config.AdminDataSource.Id)+ require.Equal(t, "db.example.com", config.AdminDataSource.Host)+ require.Equal(t, "5432", config.AdminDataSource.Port)+ require.Equal(t, "sample_database", config.AdminDataSource.Database)+ require.Equal(t, "sample_role", config.AdminDataSource.Username)+ require.Equal(t, "sample-password", config.AdminDataSource.Password)+ require.True(t, config.AdminDataSource.UseSsl)+ require.True(t, config.AdminDataSource.VerifyTlsCertificate)+ require.Equal(t, caPEM, config.AdminDataSource.SslCa)+ require.Equal(t, []string{"sample_database"}, config.SyncDatabaseNames)++ _, err = target.InstanceConfig(Allocation{Database: "sample_database", Role: "sample_role"})+ require.Error(t, err)+}++func TestTargetProvisionAndRemove(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ target := newLocalTarget(t, container)+ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ require.NoError(t, target.Validate(ctx))++ allocation := Allocation{+ Database: "sample_target_test",+ Role: "sample_target_role",+ Password: "sample-target-password",+ }+ require.NoError(t, target.Provision(ctx, allocation))++ sampleAdmin := connectLocal(ctx, t, container, allocation.Database, "postgres", "root-password")+ var databaseOwner string+ require.NoError(t, sampleAdmin.QueryRow(ctx, `+ SELECT pg_get_userbyid(datdba)+ FROM pg_database+ WHERE datname = current_database()+ `).Scan(&databaseOwner))+ require.Equal(t, "postgres", databaseOwner)++ var owner string+ require.NoError(t, sampleAdmin.QueryRow(ctx, `+ SELECT tableowner+ FROM pg_tables+ WHERE schemaname = 'public' AND tablename = 'employee'+ `).Scan(&owner))+ require.Equal(t, allocation.Role, owner)+ var publicCanCreate bool+ require.NoError(t, sampleAdmin.QueryRow(ctx, `+ SELECT NOT EXISTS (+ SELECT 1+ FROM aclexplode(COALESCE(nspacl, acldefault('n', nspowner))) AS privilege+ WHERE privilege.grantee = 0 AND privilege.privilege_type = 'CREATE'+ )+ FROM pg_namespace+ WHERE nspname = 'public'+ `).Scan(&publicCanCreate))+ require.True(t, publicCanCreate)+ require.NoError(t, sampleAdmin.Close(ctx))++ var canLogin, isSuperuser, canCreateDB, canCreateRole, canReplicate, bypassRLS bool+ require.NoError(t, admin.QueryRow(ctx, `+ SELECT rolcanlogin, rolsuper, rolcreatedb, rolcreaterole, rolreplication, rolbypassrls+ FROM pg_roles+ WHERE rolname = $1+ `, allocation.Role).Scan(&canLogin, &isSuperuser, &canCreateDB, &canCreateRole, &canReplicate, &bypassRLS))+ require.True(t, canLogin)+ require.False(t, isSuperuser)+ require.False(t, canCreateDB)+ require.False(t, canCreateRole)+ require.False(t, canReplicate)+ require.False(t, bypassRLS)++ foreignRole := "sample_target_foreign"+ _, err := admin.Exec(ctx, fmt.Sprintf("CREATE ROLE %s LOGIN PASSWORD %s", quoteIdentifier(foreignRole), quoteLiteral("foreign-password")))+ require.NoError(t, err)+ foreignConfig, err := pgx.ParseConfig(fmt.Sprintf(+ "postgres://%s:%s@%s:%s/%s?sslmode=disable",+ foreignRole,+ "foreign-password",+ container.GetHost(),+ container.GetPort(),+ allocation.Database,+ ))+ require.NoError(t, err)+ foreignConn, err := pgx.ConnectConfig(ctx, foreignConfig)+ require.Error(t, err)+ require.Nil(t, foreignConn)+ _, err = admin.Exec(ctx, fmt.Sprintf("DROP ROLE %s", quoteIdentifier(foreignRole)))+ require.NoError(t, err)++ crossDatabaseConfig, err := pgx.ParseConfig(fmt.Sprintf(+ "postgres://%s:%s@%s:%s/postgres?sslmode=disable",+ allocation.Role,+ allocation.Password,+ container.GetHost(),+ container.GetPort(),+ ))+ require.NoError(t, err)+ crossDatabaseConn, err := pgx.ConnectConfig(ctx, crossDatabaseConfig)+ require.Error(t, err)+ require.Nil(t, crossDatabaseConn)++ sample := connectLocal(ctx, t, container, allocation.Database, allocation.Role, allocation.Password)+ _, err = sample.Exec(ctx, "ALTER TABLE employee ADD COLUMN target_owned boolean NOT NULL DEFAULT false")+ require.NoError(t, err)+ require.NoError(t, sample.Close(ctx))++ _, err = admin.Exec(ctx, "CREATE DATABASE other_target_test")+ require.NoError(t, err)+ _, err = admin.Exec(ctx, fmt.Sprintf("GRANT CONNECT ON DATABASE %s TO %s", quoteIdentifier("other_target_test"), quoteIdentifier(allocation.Role)))+ require.NoError(t, err)+ crossDatabaseSession := connectLocal(ctx, t, container, "other_target_test", allocation.Role, allocation.Password)+ _, err = admin.Exec(ctx, fmt.Sprintf("REVOKE CONNECT ON DATABASE %s FROM %s", quoteIdentifier("other_target_test"), quoteIdentifier(allocation.Role)))+ require.NoError(t, err)++ cleanupAllocation := Allocation{+ Database: allocation.Database,+ Role: allocation.Role,+ }+ require.NoError(t, target.Remove(ctx, cleanupAllocation))+ require.NoError(t, crossDatabaseSession.Close(ctx))++ var exists bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&exists))+ require.False(t, exists)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&exists))+ require.False(t, exists)+ require.NoError(t, target.Remove(ctx, cleanupAllocation))+ _, err = admin.Exec(ctx, "DROP DATABASE other_target_test")+ require.NoError(t, err)+}++func TestTargetValidateRejectsPublicAccess(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ require.Error(t, newLocalTarget(t, container).Validate(ctx))+}++func TestTargetValidateAllowsCloudSQLAdminPublicAccess(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ _, err := admin.Exec(ctx, "CREATE DATABASE cloudsqladmin")+ require.NoError(t, err)+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), "DROP DATABASE cloudsqladmin")+ })++ require.NoError(t, newLocalTarget(t, container).Validate(ctx))+}++func TestTargetValidateRejectsUnexpectedPublicDatabase(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ _, err := admin.Exec(ctx, "CREATE DATABASE unexpected_public_database")+ require.NoError(t, err)+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), "DROP DATABASE unexpected_public_database")+ })++ err = newLocalTarget(t, container).Validate(ctx)+ require.Error(t, err)+ require.True(t, isStaticTargetError(err))+}++func TestTargetValidateForCleanupAllowsUnexpectedPublicDatabase(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ _, err := admin.Exec(ctx, "CREATE DATABASE unexpected_public_cleanup_database")+ require.NoError(t, err)+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), "DROP DATABASE unexpected_public_cleanup_database")+ })++ target := newLocalTarget(t, container)+ require.Error(t, target.Validate(ctx))+ require.NoError(t, target.ValidateForCleanup(ctx))+}++func TestTargetProvisionLeavesResourcesForRemoveWhenDatabaseExists(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))++ allocation := Allocation{+ Database: "sample_target_existing_database",+ Role: "sample_target_partial_role",+ Password: "sample-target-password",+ }+ _, err := admin.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", quoteIdentifier(allocation.Database)))+ require.NoError(t, err)+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), fmt.Sprintf("DROP DATABASE %s", quoteIdentifier(allocation.Database)))+ })++ err = newLocalTarget(t, container).Provision(ctx, allocation)+ require.Error(t, err)+ require.False(t, isStaticTargetError(err))++ var databasePresent, rolePresent bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&databasePresent))+ require.True(t, databasePresent)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&rolePresent))+ require.True(t, rolePresent)+ require.NoError(t, newLocalTarget(t, container).Remove(ctx, Allocation{Database: allocation.Database, Role: allocation.Role}))+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&databasePresent))+ require.False(t, databasePresent)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&rolePresent))+ require.False(t, rolePresent)+}++func TestTargetProvisionLeavesResourcesForRemoveAfterInjectedFailure(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))++ stages := []provisionStage{+ provisionStageRoleCreated,+ provisionStageDatabaseCreated,+ }+ for index, interruptedStage := range stages {+ t.Run(string(interruptedStage), func(t *testing.T) {+ allocation := Allocation{+ Database: fmt.Sprintf("sample_boundary_database_%d", index),+ Role: fmt.Sprintf("sample_boundary_role_%d", index),+ Password: "sample-target-password",+ }+ target := newLocalTarget(t, container)+ target.provisionHook = func(stage provisionStage) error {+ if stage == interruptedStage {+ return errors.New("injected provisioning interruption")+ }+ return nil+ }++ require.Error(t, target.Provision(ctx, allocation))+ var exists bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&exists))+ require.Equal(t, interruptedStage == provisionStageDatabaseCreated, exists)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&exists))+ require.True(t, exists)+ target.provisionHook = nil+ require.NoError(t, target.Remove(ctx, Allocation{Database: allocation.Database, Role: allocation.Role}))+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&exists))+ require.False(t, exists)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&exists))+ require.False(t, exists)+ })+ }+}++func TestTargetProvisionKeepsDatabaseNonConnectableUntilAccessIsReady(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ _, err := admin.Exec(ctx, "CREATE ROLE other_sample_role LOGIN PASSWORD 'other-password'")+ require.NoError(t, err)+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), "DROP ROLE other_sample_role")+ })++ reachedDatabaseCreated := make(chan struct{})+ resumeProvisioning := make(chan struct{})+ target := newLocalTarget(t, container)+ target.provisionHook = func(stage provisionStage) error {+ if stage == provisionStageDatabaseCreated {+ close(reachedDatabaseCreated)+ <-resumeProvisioning+ }+ return nil+ }+ allocation := Allocation{+ Database: "sample_target_nonconnectable",+ Role: "sample_target_nonconnectable_role",+ Password: "sample-target-password",+ }+ provisionErr := make(chan error, 1)+ go func() {+ provisionErr <- target.Provision(ctx, allocation)+ }()+ <-reachedDatabaseCreated++ var allowConnections bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT datallowconn FROM pg_database WHERE datname = $1", allocation.Database).Scan(&allowConnections))+ crossConfig, err := pgx.ParseConfig(fmt.Sprintf(+ "postgres://other_sample_role:other-password@%s:%s/%s?sslmode=disable",+ container.GetHost(),+ container.GetPort(),+ allocation.Database,+ ))+ require.NoError(t, err)+ crossConnection, crossErr := pgx.ConnectConfig(ctx, crossConfig)+ close(resumeProvisioning)+ require.NoError(t, <-provisionErr)+ if crossConnection != nil {+ require.NoError(t, crossConnection.Close(ctx))+ }+ t.Cleanup(func() {+ _ = target.Remove(context.Background(), allocation)+ })++ require.False(t, allowConnections)+ require.Error(t, crossErr)+}++func TestTargetRemoveCanResumeAfterDatabaseCleanupFailure(t *testing.T) {+ if testing.Short() {+ t.Skip("skipping PostgreSQL testcontainer test in short mode")+ }+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })++ admin := connectLocal(ctx, t, container, "postgres", "postgres", "root-password")+ defer admin.Close(ctx)+ require.NoError(t, prepareBaseline(ctx, admin))+ allocation := Allocation{+ Database: "sample_target_cleanup_database",+ Role: "sample_target_cleanup_role",+ Password: "sample-target-password",+ }+ target := newLocalTarget(t, container)+ require.NoError(t, target.Provision(ctx, allocation))+ t.Cleanup(func() {+ _, _ = admin.Exec(context.Background(), fmt.Sprintf("DROP DATABASE %s", quoteIdentifier(allocation.Database)))+ _, _ = admin.Exec(context.Background(), fmt.Sprintf("DROP ROLE %s", quoteIdentifier(allocation.Role)))+ })++ target.provisionHook = func(stage provisionStage) error {+ if stage == provisionStageCleanupDatabase {+ return errors.New("injected database cleanup failure")+ }+ return nil+ }+ require.Error(t, target.Remove(ctx, Allocation{Database: allocation.Database, Role: allocation.Role}))+ var databasePresent, rolePresent bool+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&databasePresent))+ require.True(t, databasePresent)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&rolePresent))+ require.True(t, rolePresent)++ target.provisionHook = nil+ require.NoError(t, target.Remove(ctx, Allocation{Database: allocation.Database, Role: allocation.Role}))+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1)", allocation.Database).Scan(&databasePresent))+ require.False(t, databasePresent)+ require.NoError(t, admin.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = $1)", allocation.Role).Scan(&rolePresent))+ require.False(t, rolePresent)+ require.NoError(t, target.Remove(ctx, Allocation{Database: allocation.Database, Role: allocation.Role}))+}++func newLocalTarget(t *testing.T, container *testcontainer.Container) *Target {+ t.Helper()+ config, err := pgx.ParseConfig(fmt.Sprintf(+ "postgres://postgres:root-password@%s:%s/postgres?sslmode=disable",+ container.GetHost(),+ container.GetPort(),+ ))+ require.NoError(t, err)+ return newTargetFromConfig(config, false, "")+}++func connectLocal(ctx context.Context, t *testing.T, container *testcontainer.Container, database, user, password string) *pgx.Conn {+ t.Helper()+ config, err := pgx.ParseConfig(fmt.Sprintf(+ "postgres://%s:%s@%s:%s/%s?sslmode=disable",+ user,+ password,+ container.GetHost(),+ container.GetPort(),+ database,+ ))+ require.NoError(t, err)+ conn, err := pgx.ConnectConfig(ctx, config)+ require.NoError(t, err)+ return conn+}++func prepareBaseline(ctx context.Context, conn *pgx.Conn) error {+ for _, statement := range []string{+ "REVOKE ALL PRIVILEGES ON DATABASE postgres FROM PUBLIC",+ "REVOKE ALL PRIVILEGES ON DATABASE template1 FROM PUBLIC",+ } {+ if _, err := conn.Exec(ctx, statement); err != nil {+ return err+ }+ }+ return nil+}diff --git a/backend/generated-go/v1/instance_service.pb.go b/backend/generated-go/v1/instance_service.pb.goindex ddadfb3fcf..00604a334c 100644--- a/backend/generated-go/v1/instance_service.pb.go+++ b/backend/generated-go/v1/instance_service.pb.go@@ -136,7 +136,7 @@ func (x DataSourceExternalSecret_SecretType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSourceExternalSecret_SecretType.Descriptor instead.func (DataSourceExternalSecret_SecretType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20, 0}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 0}}type DataSourceExternalSecret_AuthType int32@@ -188,7 +188,7 @@ func (x DataSourceExternalSecret_AuthType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSourceExternalSecret_AuthType.Descriptor instead.func (DataSourceExternalSecret_AuthType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20, 1}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 1}}type DataSourceExternalSecret_TokenType int32@@ -246,7 +246,7 @@ func (x DataSourceExternalSecret_TokenType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSourceExternalSecret_TokenType.Descriptor instead.func (DataSourceExternalSecret_TokenType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20, 2}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 2}}type DataSourceExternalSecret_AppRoleAuthOption_SecretType int32@@ -298,7 +298,7 @@ func (x DataSourceExternalSecret_AppRoleAuthOption_SecretType) Number() protoref// Deprecated: Use DataSourceExternalSecret_AppRoleAuthOption_SecretType.Descriptor instead.func (DataSourceExternalSecret_AppRoleAuthOption_SecretType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20, 0, 0}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 0, 0}}type DataSource_AuthenticationType int32@@ -353,7 +353,7 @@ func (x DataSource_AuthenticationType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSource_AuthenticationType.Descriptor instead.func (DataSource_AuthenticationType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 0}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 0}}// CloudSQLIPType selects which Cloud SQL IP to dial for Google Cloud SQL IAM connections.@@ -406,7 +406,7 @@ func (x DataSource_CloudSQLIPType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSource_CloudSQLIPType.Descriptor instead.func (DataSource_CloudSQLIPType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 1}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 1}}type DataSource_RedisType int32@@ -458,7 +458,7 @@ func (x DataSource_RedisType) Number() protoreflect.EnumNumber {// Deprecated: Use DataSource_RedisType.Descriptor instead.func (DataSource_RedisType) EnumDescriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 2}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 2}}type GetInstanceRequest struct {@@ -779,6 +779,52 @@ func (x *CreateInstanceRequest) GetValidateOnly() bool {return false}+type PrepareSampleProjectInstanceRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ // The project that owns the sample instance.+ // Format: projects/{project}+ Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *PrepareSampleProjectInstanceRequest) Reset() {+ *x = PrepareSampleProjectInstanceRequest{}+ mi := &file_v1_instance_service_proto_msgTypes[4]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *PrepareSampleProjectInstanceRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*PrepareSampleProjectInstanceRequest) ProtoMessage() {}++func (x *PrepareSampleProjectInstanceRequest) ProtoReflect() protoreflect.Message {+ mi := &file_v1_instance_service_proto_msgTypes[4]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use PrepareSampleProjectInstanceRequest.ProtoReflect.Descriptor instead.+func (*PrepareSampleProjectInstanceRequest) Descriptor() ([]byte, []int) {+ return file_v1_instance_service_proto_rawDescGZIP(), []int{4}+}++func (x *PrepareSampleProjectInstanceRequest) GetParent() string {+ if x != nil {+ return x.Parent+ }+ return ""+}+type UpdateInstanceRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The instance to update.@@ -799,7 +845,7 @@ type UpdateInstanceRequest struct {func (x *UpdateInstanceRequest) Reset() {*x = UpdateInstanceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[4]+ mi := &file_v1_instance_service_proto_msgTypes[5]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -811,7 +857,7 @@ func (x *UpdateInstanceRequest) String() string {func (*UpdateInstanceRequest) ProtoMessage() {}func (x *UpdateInstanceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[4]+ mi := &file_v1_instance_service_proto_msgTypes[5]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -824,7 +870,7 @@ func (x *UpdateInstanceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use UpdateInstanceRequest.ProtoReflect.Descriptor instead.func (*UpdateInstanceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{4}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{5}}func (x *UpdateInstanceRequest) GetInstance() *Instance {@@ -868,7 +914,7 @@ type DeleteInstanceRequest struct {func (x *DeleteInstanceRequest) Reset() {*x = DeleteInstanceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[5]+ mi := &file_v1_instance_service_proto_msgTypes[6]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -880,7 +926,7 @@ func (x *DeleteInstanceRequest) String() string {func (*DeleteInstanceRequest) ProtoMessage() {}func (x *DeleteInstanceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[5]+ mi := &file_v1_instance_service_proto_msgTypes[6]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -893,7 +939,7 @@ func (x *DeleteInstanceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use DeleteInstanceRequest.ProtoReflect.Descriptor instead.func (*DeleteInstanceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{5}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{6}}func (x *DeleteInstanceRequest) GetName() string {@@ -928,7 +974,7 @@ type UndeleteInstanceRequest struct {func (x *UndeleteInstanceRequest) Reset() {*x = UndeleteInstanceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[6]+ mi := &file_v1_instance_service_proto_msgTypes[7]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -940,7 +986,7 @@ func (x *UndeleteInstanceRequest) String() string {func (*UndeleteInstanceRequest) ProtoMessage() {}func (x *UndeleteInstanceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[6]+ mi := &file_v1_instance_service_proto_msgTypes[7]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -953,7 +999,7 @@ func (x *UndeleteInstanceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use UndeleteInstanceRequest.ProtoReflect.Descriptor instead.func (*UndeleteInstanceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{6}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{7}}func (x *UndeleteInstanceRequest) GetName() string {@@ -977,7 +1023,7 @@ type SyncInstanceRequest struct {func (x *SyncInstanceRequest) Reset() {*x = SyncInstanceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[7]+ mi := &file_v1_instance_service_proto_msgTypes[8]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -989,7 +1035,7 @@ func (x *SyncInstanceRequest) String() string {func (*SyncInstanceRequest) ProtoMessage() {}func (x *SyncInstanceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[7]+ mi := &file_v1_instance_service_proto_msgTypes[8]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1002,7 +1048,7 @@ func (x *SyncInstanceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use SyncInstanceRequest.ProtoReflect.Descriptor instead.func (*SyncInstanceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{7}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{8}}func (x *SyncInstanceRequest) GetName() string {@@ -1032,7 +1078,7 @@ type ListInstanceDatabaseRequest struct {func (x *ListInstanceDatabaseRequest) Reset() {*x = ListInstanceDatabaseRequest{}- mi := &file_v1_instance_service_proto_msgTypes[8]+ mi := &file_v1_instance_service_proto_msgTypes[9]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1044,7 +1090,7 @@ func (x *ListInstanceDatabaseRequest) String() string {func (*ListInstanceDatabaseRequest) ProtoMessage() {}func (x *ListInstanceDatabaseRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[8]+ mi := &file_v1_instance_service_proto_msgTypes[9]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1057,7 +1103,7 @@ func (x *ListInstanceDatabaseRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use ListInstanceDatabaseRequest.ProtoReflect.Descriptor instead.func (*ListInstanceDatabaseRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{8}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{9}}func (x *ListInstanceDatabaseRequest) GetName() string {@@ -1084,7 +1130,7 @@ type ListInstanceDatabaseResponse struct {func (x *ListInstanceDatabaseResponse) Reset() {*x = ListInstanceDatabaseResponse{}- mi := &file_v1_instance_service_proto_msgTypes[9]+ mi := &file_v1_instance_service_proto_msgTypes[10]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1096,7 +1142,7 @@ func (x *ListInstanceDatabaseResponse) String() string {func (*ListInstanceDatabaseResponse) ProtoMessage() {}func (x *ListInstanceDatabaseResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[9]+ mi := &file_v1_instance_service_proto_msgTypes[10]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1109,7 +1155,7 @@ func (x *ListInstanceDatabaseResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use ListInstanceDatabaseResponse.ProtoReflect.Descriptor instead.func (*ListInstanceDatabaseResponse) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{9}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{10}}func (x *ListInstanceDatabaseResponse) GetDatabases() []string {@@ -1129,7 +1175,7 @@ type SyncInstanceResponse struct {func (x *SyncInstanceResponse) Reset() {*x = SyncInstanceResponse{}- mi := &file_v1_instance_service_proto_msgTypes[10]+ mi := &file_v1_instance_service_proto_msgTypes[11]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1141,7 +1187,7 @@ func (x *SyncInstanceResponse) String() string {func (*SyncInstanceResponse) ProtoMessage() {}func (x *SyncInstanceResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[10]+ mi := &file_v1_instance_service_proto_msgTypes[11]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1154,7 +1200,7 @@ func (x *SyncInstanceResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use SyncInstanceResponse.ProtoReflect.Descriptor instead.func (*SyncInstanceResponse) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{10}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{11}}func (x *SyncInstanceResponse) GetDatabases() []string {@@ -1179,7 +1225,7 @@ type BatchSyncInstancesRequest struct {func (x *BatchSyncInstancesRequest) Reset() {*x = BatchSyncInstancesRequest{}- mi := &file_v1_instance_service_proto_msgTypes[11]+ mi := &file_v1_instance_service_proto_msgTypes[12]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1191,7 +1237,7 @@ func (x *BatchSyncInstancesRequest) String() string {func (*BatchSyncInstancesRequest) ProtoMessage() {}func (x *BatchSyncInstancesRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[11]+ mi := &file_v1_instance_service_proto_msgTypes[12]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1204,7 +1250,7 @@ func (x *BatchSyncInstancesRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use BatchSyncInstancesRequest.ProtoReflect.Descriptor instead.func (*BatchSyncInstancesRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{11}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{12}}func (x *BatchSyncInstancesRequest) GetParent() string {@@ -1229,7 +1275,7 @@ type BatchSyncInstancesResponse struct {func (x *BatchSyncInstancesResponse) Reset() {*x = BatchSyncInstancesResponse{}- mi := &file_v1_instance_service_proto_msgTypes[12]+ mi := &file_v1_instance_service_proto_msgTypes[13]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1241,7 +1287,7 @@ func (x *BatchSyncInstancesResponse) String() string {func (*BatchSyncInstancesResponse) ProtoMessage() {}func (x *BatchSyncInstancesResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[12]+ mi := &file_v1_instance_service_proto_msgTypes[13]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1254,7 +1300,7 @@ func (x *BatchSyncInstancesResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use BatchSyncInstancesResponse.ProtoReflect.Descriptor instead.func (*BatchSyncInstancesResponse) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{12}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{13}}type BatchUpdateInstancesRequest struct {@@ -1271,7 +1317,7 @@ type BatchUpdateInstancesRequest struct {func (x *BatchUpdateInstancesRequest) Reset() {*x = BatchUpdateInstancesRequest{}- mi := &file_v1_instance_service_proto_msgTypes[13]+ mi := &file_v1_instance_service_proto_msgTypes[14]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1283,7 +1329,7 @@ func (x *BatchUpdateInstancesRequest) String() string {func (*BatchUpdateInstancesRequest) ProtoMessage() {}func (x *BatchUpdateInstancesRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[13]+ mi := &file_v1_instance_service_proto_msgTypes[14]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1296,7 +1342,7 @@ func (x *BatchUpdateInstancesRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use BatchUpdateInstancesRequest.ProtoReflect.Descriptor instead.func (*BatchUpdateInstancesRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{13}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{14}}func (x *BatchUpdateInstancesRequest) GetParent() string {@@ -1322,7 +1368,7 @@ type BatchUpdateInstancesResponse struct {func (x *BatchUpdateInstancesResponse) Reset() {*x = BatchUpdateInstancesResponse{}- mi := &file_v1_instance_service_proto_msgTypes[14]+ mi := &file_v1_instance_service_proto_msgTypes[15]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1334,7 +1380,7 @@ func (x *BatchUpdateInstancesResponse) String() string {func (*BatchUpdateInstancesResponse) ProtoMessage() {}func (x *BatchUpdateInstancesResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[14]+ mi := &file_v1_instance_service_proto_msgTypes[15]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1347,7 +1393,7 @@ func (x *BatchUpdateInstancesResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use BatchUpdateInstancesResponse.ProtoReflect.Descriptor instead.func (*BatchUpdateInstancesResponse) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{14}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{15}}func (x *BatchUpdateInstancesResponse) GetInstances() []*Instance {@@ -1373,7 +1419,7 @@ type AddDataSourceRequest struct {func (x *AddDataSourceRequest) Reset() {*x = AddDataSourceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[15]+ mi := &file_v1_instance_service_proto_msgTypes[16]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1385,7 +1431,7 @@ func (x *AddDataSourceRequest) String() string {func (*AddDataSourceRequest) ProtoMessage() {}func (x *AddDataSourceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[15]+ mi := &file_v1_instance_service_proto_msgTypes[16]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1398,7 +1444,7 @@ func (x *AddDataSourceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use AddDataSourceRequest.ProtoReflect.Descriptor instead.func (*AddDataSourceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{15}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{16}}func (x *AddDataSourceRequest) GetName() string {@@ -1436,7 +1482,7 @@ type RemoveDataSourceRequest struct {func (x *RemoveDataSourceRequest) Reset() {*x = RemoveDataSourceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[16]+ mi := &file_v1_instance_service_proto_msgTypes[17]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1448,7 +1494,7 @@ func (x *RemoveDataSourceRequest) String() string {func (*RemoveDataSourceRequest) ProtoMessage() {}func (x *RemoveDataSourceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[16]+ mi := &file_v1_instance_service_proto_msgTypes[17]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1461,7 +1507,7 @@ func (x *RemoveDataSourceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use RemoveDataSourceRequest.ProtoReflect.Descriptor instead.func (*RemoveDataSourceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{16}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{17}}func (x *RemoveDataSourceRequest) GetName() string {@@ -1498,7 +1544,7 @@ type UpdateDataSourceRequest struct {func (x *UpdateDataSourceRequest) Reset() {*x = UpdateDataSourceRequest{}- mi := &file_v1_instance_service_proto_msgTypes[17]+ mi := &file_v1_instance_service_proto_msgTypes[18]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1510,7 +1556,7 @@ func (x *UpdateDataSourceRequest) String() string {func (*UpdateDataSourceRequest) ProtoMessage() {}func (x *UpdateDataSourceRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[17]+ mi := &file_v1_instance_service_proto_msgTypes[18]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1523,7 +1569,7 @@ func (x *UpdateDataSourceRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use UpdateDataSourceRequest.ProtoReflect.Descriptor instead.func (*UpdateDataSourceRequest) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{17}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{18}}func (x *UpdateDataSourceRequest) GetName() string {@@ -1570,7 +1616,7 @@ type SyncDatabases struct {func (x *SyncDatabases) Reset() {*x = SyncDatabases{}- mi := &file_v1_instance_service_proto_msgTypes[18]+ mi := &file_v1_instance_service_proto_msgTypes[19]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1582,7 +1628,7 @@ func (x *SyncDatabases) String() string {func (*SyncDatabases) ProtoMessage() {}func (x *SyncDatabases) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[18]+ mi := &file_v1_instance_service_proto_msgTypes[19]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1595,7 +1641,7 @@ func (x *SyncDatabases) ProtoReflect() protoreflect.Message {// Deprecated: Use SyncDatabases.ProtoReflect.Descriptor instead.func (*SyncDatabases) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{18}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{19}}func (x *SyncDatabases) GetDatabases() []string {@@ -1645,7 +1691,7 @@ type Instance struct {func (x *Instance) Reset() {*x = Instance{}- mi := &file_v1_instance_service_proto_msgTypes[19]+ mi := &file_v1_instance_service_proto_msgTypes[20]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1657,7 +1703,7 @@ func (x *Instance) String() string {func (*Instance) ProtoMessage() {}func (x *Instance) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[19]+ mi := &file_v1_instance_service_proto_msgTypes[20]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1670,7 +1716,7 @@ func (x *Instance) ProtoReflect() protoreflect.Message {// Deprecated: Use Instance.ProtoReflect.Descriptor instead.func (*Instance) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{19}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{20}}func (x *Instance) GetName() string {@@ -1810,7 +1856,7 @@ type DataSourceExternalSecret struct {func (x *DataSourceExternalSecret) Reset() {*x = DataSourceExternalSecret{}- mi := &file_v1_instance_service_proto_msgTypes[20]+ mi := &file_v1_instance_service_proto_msgTypes[21]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1822,7 +1868,7 @@ func (x *DataSourceExternalSecret) String() string {func (*DataSourceExternalSecret) ProtoMessage() {}func (x *DataSourceExternalSecret) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[20]+ mi := &file_v1_instance_service_proto_msgTypes[21]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1835,7 +1881,7 @@ func (x *DataSourceExternalSecret) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSourceExternalSecret.ProtoReflect.Descriptor instead.func (*DataSourceExternalSecret) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21}}func (x *DataSourceExternalSecret) GetSecretType() DataSourceExternalSecret_SecretType {@@ -2079,7 +2125,7 @@ type DataSource struct {func (x *DataSource) Reset() {*x = DataSource{}- mi := &file_v1_instance_service_proto_msgTypes[21]+ mi := &file_v1_instance_service_proto_msgTypes[22]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2091,7 +2137,7 @@ func (x *DataSource) String() string {func (*DataSource) ProtoMessage() {}func (x *DataSource) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[21]+ mi := &file_v1_instance_service_proto_msgTypes[22]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2104,7 +2150,7 @@ func (x *DataSource) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSource.ProtoReflect.Descriptor instead.func (*DataSource) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22}}func (x *DataSource) GetId() string {@@ -2523,7 +2569,7 @@ type InstanceResource struct {func (x *InstanceResource) Reset() {*x = InstanceResource{}- mi := &file_v1_instance_service_proto_msgTypes[22]+ mi := &file_v1_instance_service_proto_msgTypes[23]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2535,7 +2581,7 @@ func (x *InstanceResource) String() string {func (*InstanceResource) ProtoMessage() {}func (x *InstanceResource) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[22]+ mi := &file_v1_instance_service_proto_msgTypes[23]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2548,7 +2594,7 @@ func (x *InstanceResource) ProtoReflect() protoreflect.Message {// Deprecated: Use InstanceResource.ProtoReflect.Descriptor instead.func (*InstanceResource) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{22}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{23}}func (x *InstanceResource) GetTitle() string {@@ -2612,7 +2658,7 @@ type SASLConfig struct {func (x *SASLConfig) Reset() {*x = SASLConfig{}- mi := &file_v1_instance_service_proto_msgTypes[23]+ mi := &file_v1_instance_service_proto_msgTypes[24]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2624,7 +2670,7 @@ func (x *SASLConfig) String() string {func (*SASLConfig) ProtoMessage() {}func (x *SASLConfig) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[23]+ mi := &file_v1_instance_service_proto_msgTypes[24]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2637,7 +2683,7 @@ func (x *SASLConfig) ProtoReflect() protoreflect.Message {// Deprecated: Use SASLConfig.ProtoReflect.Descriptor instead.func (*SASLConfig) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{23}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{24}}func (x *SASLConfig) GetMechanism() isSASLConfig_Mechanism {@@ -2689,7 +2735,7 @@ type KerberosConfig struct {func (x *KerberosConfig) Reset() {*x = KerberosConfig{}- mi := &file_v1_instance_service_proto_msgTypes[24]+ mi := &file_v1_instance_service_proto_msgTypes[25]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2701,7 +2747,7 @@ func (x *KerberosConfig) String() string {func (*KerberosConfig) ProtoMessage() {}func (x *KerberosConfig) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[24]+ mi := &file_v1_instance_service_proto_msgTypes[25]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2714,7 +2760,7 @@ func (x *KerberosConfig) ProtoReflect() protoreflect.Message {// Deprecated: Use KerberosConfig.ProtoReflect.Descriptor instead.func (*KerberosConfig) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{24}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{25}}func (x *KerberosConfig) GetPrimary() string {@@ -2782,7 +2828,7 @@ type DataSourceExternalSecret_AppRoleAuthOption struct {func (x *DataSourceExternalSecret_AppRoleAuthOption) Reset() {*x = DataSourceExternalSecret_AppRoleAuthOption{}- mi := &file_v1_instance_service_proto_msgTypes[26]+ mi := &file_v1_instance_service_proto_msgTypes[27]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2794,7 +2840,7 @@ func (x *DataSourceExternalSecret_AppRoleAuthOption) String() string {func (*DataSourceExternalSecret_AppRoleAuthOption) ProtoMessage() {}func (x *DataSourceExternalSecret_AppRoleAuthOption) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[26]+ mi := &file_v1_instance_service_proto_msgTypes[27]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2807,7 +2853,7 @@ func (x *DataSourceExternalSecret_AppRoleAuthOption) ProtoReflect() protoreflect// Deprecated: Use DataSourceExternalSecret_AppRoleAuthOption.ProtoReflect.Descriptor instead.func (*DataSourceExternalSecret_AppRoleAuthOption) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{20, 0}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 0}}func (x *DataSourceExternalSecret_AppRoleAuthOption) GetRoleId() string {@@ -2849,7 +2895,7 @@ type DataSource_AzureCredential struct {func (x *DataSource_AzureCredential) Reset() {*x = DataSource_AzureCredential{}- mi := &file_v1_instance_service_proto_msgTypes[27]+ mi := &file_v1_instance_service_proto_msgTypes[28]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2861,7 +2907,7 @@ func (x *DataSource_AzureCredential) String() string {func (*DataSource_AzureCredential) ProtoMessage() {}func (x *DataSource_AzureCredential) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[27]+ mi := &file_v1_instance_service_proto_msgTypes[28]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2874,7 +2920,7 @@ func (x *DataSource_AzureCredential) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSource_AzureCredential.ProtoReflect.Descriptor instead.func (*DataSource_AzureCredential) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 0}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 0}}func (x *DataSource_AzureCredential) GetTenantId() string {@@ -2915,7 +2961,7 @@ type DataSource_AWSCredential struct {func (x *DataSource_AWSCredential) Reset() {*x = DataSource_AWSCredential{}- mi := &file_v1_instance_service_proto_msgTypes[28]+ mi := &file_v1_instance_service_proto_msgTypes[29]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2927,7 +2973,7 @@ func (x *DataSource_AWSCredential) String() string {func (*DataSource_AWSCredential) ProtoMessage() {}func (x *DataSource_AWSCredential) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[28]+ mi := &file_v1_instance_service_proto_msgTypes[29]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2940,7 +2986,7 @@ func (x *DataSource_AWSCredential) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSource_AWSCredential.ProtoReflect.Descriptor instead.func (*DataSource_AWSCredential) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 1}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 1}}func (x *DataSource_AWSCredential) GetAccessKeyId() string {@@ -2987,7 +3033,7 @@ type DataSource_GCPCredential struct {func (x *DataSource_GCPCredential) Reset() {*x = DataSource_GCPCredential{}- mi := &file_v1_instance_service_proto_msgTypes[29]+ mi := &file_v1_instance_service_proto_msgTypes[30]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2999,7 +3045,7 @@ func (x *DataSource_GCPCredential) String() string {func (*DataSource_GCPCredential) ProtoMessage() {}func (x *DataSource_GCPCredential) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[29]+ mi := &file_v1_instance_service_proto_msgTypes[30]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -3012,7 +3058,7 @@ func (x *DataSource_GCPCredential) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSource_GCPCredential.ProtoReflect.Descriptor instead.func (*DataSource_GCPCredential) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 2}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 2}}func (x *DataSource_GCPCredential) GetContent() string {@@ -3032,7 +3078,7 @@ type DataSource_Address struct {func (x *DataSource_Address) Reset() {*x = DataSource_Address{}- mi := &file_v1_instance_service_proto_msgTypes[30]+ mi := &file_v1_instance_service_proto_msgTypes[31]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -3044,7 +3090,7 @@ func (x *DataSource_Address) String() string {func (*DataSource_Address) ProtoMessage() {}func (x *DataSource_Address) ProtoReflect() protoreflect.Message {- mi := &file_v1_instance_service_proto_msgTypes[30]+ mi := &file_v1_instance_service_proto_msgTypes[31]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -3057,7 +3103,7 @@ func (x *DataSource_Address) ProtoReflect() protoreflect.Message {// Deprecated: Use DataSource_Address.ProtoReflect.Descriptor instead.func (*DataSource_Address) Descriptor() ([]byte, []int) {- return file_v1_instance_service_proto_rawDescGZIP(), []int{21, 3}+ return file_v1_instance_service_proto_rawDescGZIP(), []int{22, 3}}func (x *DataSource_Address) GetHost() string {@@ -3100,7 +3146,10 @@ const file_v1_instance_service_proto_rawDesc = "" +"\vinstance_id\x18\x02 \x01(\tR\n" +"instanceId\x12#\n" +"\rvalidate_only\x18\x03 \x01(\bR\fvalidateOnlyB\t\n" +- "\a_parentJ\x04\b\x04\x10\x05R\x18initial_database_project\"\xb1\x01\n" ++ "\a_parentJ\x04\b\x04\x10\x05R\x18initial_database_project\"[\n" ++ "#PrepareSampleProjectInstanceRequest\x124\n" ++ "\x06parent\x18\x01 \x01(\tB\x1c\xe0A\x02\xfaA\x16\n" ++ "\x14bytebase.com/ProjectR\x06parent\"\xb1\x01\n" +"\x15UpdateInstanceRequest\x126\n" +"\binstance\x18\x01 \x01(\v2\x15.bytebase.v1.InstanceB\x03\xe0A\x02R\binstance\x12;\n" +"\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskR\n" +@@ -3359,11 +3408,12 @@ const file_v1_instance_service_proto_rawDesc = "" +"\x0eDataSourceType\x12\x1b\n" +"\x17DATA_SOURCE_UNSPECIFIED\x10\x00\x12\t\n" +"\x05ADMIN\x10\x01\x12\r\n" +- "\tREAD_ONLY\x10\x022\xb0\x16\n" ++ "\tREAD_ONLY\x10\x022\x95\x18\n" +"\x0fInstanceService\x12\xad\x01\n" +"\vGetInstance\x12\x1f.bytebase.v1.GetInstanceRequest\x1a\x15.bytebase.v1.Instance\"f\xdaA\x04name\x8a\xea0\x10bb.instances.get\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02=Z#\x12!/v1/{name=projects/*/instances/*}\x12\x16/v1/{name=instances/*}\x12\xb2\x01\n" +"\rListInstances\x12!.bytebase.v1.ListInstancesRequest\x1a\".bytebase.v1.ListInstancesResponse\"Z\xdaA\x00\x8a\xea0\x11bb.instances.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x024Z#\x12!/v1/{parent=projects/*}/instances\x12\r/v1/instances\x12\xce\x01\n" +- "\x0eCreateInstance\x12\".bytebase.v1.CreateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x80\x01\xdaA\binstance\x8a\xea0\x13bb.instances.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02H:\binstanceZ-:\binstance\"!/v1/{parent=projects/*}/instances\"\r/v1/instances\x12\xf5\x01\n" ++ "\x0eCreateInstance\x12\".bytebase.v1.CreateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x80\x01\xdaA\binstance\x8a\xea0\x13bb.instances.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02H:\binstanceZ-:\binstance\"!/v1/{parent=projects/*}/instances\"\r/v1/instances\x12\xe2\x01\n" ++ "\x1cPrepareSampleProjectInstance\x120.bytebase.v1.PrepareSampleProjectInstanceRequest\x1a\x15.bytebase.v1.Instance\"y\xdaA\x06parent\x8a\xea0\x13bb.instances.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02C:\x01*\">/v1/{parent=projects/*}/instances:prepareSampleProjectInstance\x12\xf5\x01\n" +"\x0eUpdateInstance\x12\".bytebase.v1.UpdateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\xa7\x01\xdaA\x14instance,update_mask\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02c:\binstanceZ6:\binstance2*/v1/{instance.name=projects/*/instances/*}2\x1f/v1/{instance.name=instances/*}\x12\xbf\x01\n" +"\x0eDeleteInstance\x12\".bytebase.v1.DeleteInstanceRequest\x1a\x16.google.protobuf.Empty\"q\xdaA\x04name\x8a\xea0\x13bb.instances.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02=Z#*!/v1/{name=projects/*/instances/*}*\x16/v1/{name=instances/*}\x12\xd6\x01\n" +"\x10UndeleteInstance\x12$.bytebase.v1.UndeleteInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x84\x01\x8a\xea0\x15bb.instances.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02U:\x01*Z/:\x01*\"*/v1/{name=projects/*/instances/*}:undelete\"\x1f/v1/{name=instances/*}:undelete\x12\xc5\x01\n" +@@ -3389,7 +3439,7 @@ func file_v1_instance_service_proto_rawDescGZIP() []byte {}var file_v1_instance_service_proto_enumTypes = make([]protoimpl.EnumInfo, 8)-var file_v1_instance_service_proto_msgTypes = make([]protoimpl.MessageInfo, 32)+var file_v1_instance_service_proto_msgTypes = make([]protoimpl.MessageInfo, 33)var file_v1_instance_service_proto_goTypes = []any{(DataSourceType)(0), // 0: bytebase.v1.DataSourceType(DataSourceExternalSecret_SecretType)(0), // 1: bytebase.v1.DataSourceExternalSecret.SecretType@@ -3403,110 +3453,113 @@ var file_v1_instance_service_proto_goTypes = []any{(*ListInstancesRequest)(nil), // 9: bytebase.v1.ListInstancesRequest(*ListInstancesResponse)(nil), // 10: bytebase.v1.ListInstancesResponse(*CreateInstanceRequest)(nil), // 11: bytebase.v1.CreateInstanceRequest- (*UpdateInstanceRequest)(nil), // 12: bytebase.v1.UpdateInstanceRequest- (*DeleteInstanceRequest)(nil), // 13: bytebase.v1.DeleteInstanceRequest- (*UndeleteInstanceRequest)(nil), // 14: bytebase.v1.UndeleteInstanceRequest- (*SyncInstanceRequest)(nil), // 15: bytebase.v1.SyncInstanceRequest- (*ListInstanceDatabaseRequest)(nil), // 16: bytebase.v1.ListInstanceDatabaseRequest- (*ListInstanceDatabaseResponse)(nil), // 17: bytebase.v1.ListInstanceDatabaseResponse- (*SyncInstanceResponse)(nil), // 18: bytebase.v1.SyncInstanceResponse- (*BatchSyncInstancesRequest)(nil), // 19: bytebase.v1.BatchSyncInstancesRequest- (*BatchSyncInstancesResponse)(nil), // 20: bytebase.v1.BatchSyncInstancesResponse- (*BatchUpdateInstancesRequest)(nil), // 21: bytebase.v1.BatchUpdateInstancesRequest- (*BatchUpdateInstancesResponse)(nil), // 22: bytebase.v1.BatchUpdateInstancesResponse- (*AddDataSourceRequest)(nil), // 23: bytebase.v1.AddDataSourceRequest- (*RemoveDataSourceRequest)(nil), // 24: bytebase.v1.RemoveDataSourceRequest- (*UpdateDataSourceRequest)(nil), // 25: bytebase.v1.UpdateDataSourceRequest- (*SyncDatabases)(nil), // 26: bytebase.v1.SyncDatabases- (*Instance)(nil), // 27: bytebase.v1.Instance- (*DataSourceExternalSecret)(nil), // 28: bytebase.v1.DataSourceExternalSecret- (*DataSource)(nil), // 29: bytebase.v1.DataSource- (*InstanceResource)(nil), // 30: bytebase.v1.InstanceResource- (*SASLConfig)(nil), // 31: bytebase.v1.SASLConfig- (*KerberosConfig)(nil), // 32: bytebase.v1.KerberosConfig- nil, // 33: bytebase.v1.Instance.LabelsEntry- (*DataSourceExternalSecret_AppRoleAuthOption)(nil), // 34: bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption- (*DataSource_AzureCredential)(nil), // 35: bytebase.v1.DataSource.AzureCredential- (*DataSource_AWSCredential)(nil), // 36: bytebase.v1.DataSource.AWSCredential- (*DataSource_GCPCredential)(nil), // 37: bytebase.v1.DataSource.GCPCredential- (*DataSource_Address)(nil), // 38: bytebase.v1.DataSource.Address- nil, // 39: bytebase.v1.DataSource.ExtraConnectionParametersEntry- (*fieldmaskpb.FieldMask)(nil), // 40: google.protobuf.FieldMask- (State)(0), // 41: bytebase.v1.State- (Engine)(0), // 42: bytebase.v1.Engine- (*InstanceRole)(nil), // 43: bytebase.v1.InstanceRole- (*durationpb.Duration)(nil), // 44: google.protobuf.Duration- (*timestamppb.Timestamp)(nil), // 45: google.protobuf.Timestamp- (*emptypb.Empty)(nil), // 46: google.protobuf.Empty+ (*PrepareSampleProjectInstanceRequest)(nil), // 12: bytebase.v1.PrepareSampleProjectInstanceRequest+ (*UpdateInstanceRequest)(nil), // 13: bytebase.v1.UpdateInstanceRequest+ (*DeleteInstanceRequest)(nil), // 14: bytebase.v1.DeleteInstanceRequest+ (*UndeleteInstanceRequest)(nil), // 15: bytebase.v1.UndeleteInstanceRequest+ (*SyncInstanceRequest)(nil), // 16: bytebase.v1.SyncInstanceRequest+ (*ListInstanceDatabaseRequest)(nil), // 17: bytebase.v1.ListInstanceDatabaseRequest+ (*ListInstanceDatabaseResponse)(nil), // 18: bytebase.v1.ListInstanceDatabaseResponse+ (*SyncInstanceResponse)(nil), // 19: bytebase.v1.SyncInstanceResponse+ (*BatchSyncInstancesRequest)(nil), // 20: bytebase.v1.BatchSyncInstancesRequest+ (*BatchSyncInstancesResponse)(nil), // 21: bytebase.v1.BatchSyncInstancesResponse+ (*BatchUpdateInstancesRequest)(nil), // 22: bytebase.v1.BatchUpdateInstancesRequest+ (*BatchUpdateInstancesResponse)(nil), // 23: bytebase.v1.BatchUpdateInstancesResponse+ (*AddDataSourceRequest)(nil), // 24: bytebase.v1.AddDataSourceRequest+ (*RemoveDataSourceRequest)(nil), // 25: bytebase.v1.RemoveDataSourceRequest+ (*UpdateDataSourceRequest)(nil), // 26: bytebase.v1.UpdateDataSourceRequest+ (*SyncDatabases)(nil), // 27: bytebase.v1.SyncDatabases+ (*Instance)(nil), // 28: bytebase.v1.Instance+ (*DataSourceExternalSecret)(nil), // 29: bytebase.v1.DataSourceExternalSecret+ (*DataSource)(nil), // 30: bytebase.v1.DataSource+ (*InstanceResource)(nil), // 31: bytebase.v1.InstanceResource+ (*SASLConfig)(nil), // 32: bytebase.v1.SASLConfig+ (*KerberosConfig)(nil), // 33: bytebase.v1.KerberosConfig+ nil, // 34: bytebase.v1.Instance.LabelsEntry+ (*DataSourceExternalSecret_AppRoleAuthOption)(nil), // 35: bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption+ (*DataSource_AzureCredential)(nil), // 36: bytebase.v1.DataSource.AzureCredential+ (*DataSource_AWSCredential)(nil), // 37: bytebase.v1.DataSource.AWSCredential+ (*DataSource_GCPCredential)(nil), // 38: bytebase.v1.DataSource.GCPCredential+ (*DataSource_Address)(nil), // 39: bytebase.v1.DataSource.Address+ nil, // 40: bytebase.v1.DataSource.ExtraConnectionParametersEntry+ (*fieldmaskpb.FieldMask)(nil), // 41: google.protobuf.FieldMask+ (State)(0), // 42: bytebase.v1.State+ (Engine)(0), // 43: bytebase.v1.Engine+ (*InstanceRole)(nil), // 44: bytebase.v1.InstanceRole+ (*durationpb.Duration)(nil), // 45: google.protobuf.Duration+ (*timestamppb.Timestamp)(nil), // 46: google.protobuf.Timestamp+ (*emptypb.Empty)(nil), // 47: google.protobuf.Empty}var file_v1_instance_service_proto_depIdxs = []int32{- 27, // 0: bytebase.v1.ListInstancesResponse.instances:type_name -> bytebase.v1.Instance- 27, // 1: bytebase.v1.CreateInstanceRequest.instance:type_name -> bytebase.v1.Instance- 27, // 2: bytebase.v1.UpdateInstanceRequest.instance:type_name -> bytebase.v1.Instance- 40, // 3: bytebase.v1.UpdateInstanceRequest.update_mask:type_name -> google.protobuf.FieldMask- 27, // 4: bytebase.v1.ListInstanceDatabaseRequest.instance:type_name -> bytebase.v1.Instance- 15, // 5: bytebase.v1.BatchSyncInstancesRequest.requests:type_name -> bytebase.v1.SyncInstanceRequest- 12, // 6: bytebase.v1.BatchUpdateInstancesRequest.requests:type_name -> bytebase.v1.UpdateInstanceRequest- 27, // 7: bytebase.v1.BatchUpdateInstancesResponse.instances:type_name -> bytebase.v1.Instance- 29, // 8: bytebase.v1.AddDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource- 29, // 9: bytebase.v1.RemoveDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource- 29, // 10: bytebase.v1.UpdateDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource- 40, // 11: bytebase.v1.UpdateDataSourceRequest.update_mask:type_name -> google.protobuf.FieldMask- 41, // 12: bytebase.v1.Instance.state:type_name -> bytebase.v1.State- 42, // 13: bytebase.v1.Instance.engine:type_name -> bytebase.v1.Engine- 29, // 14: bytebase.v1.Instance.data_sources:type_name -> bytebase.v1.DataSource- 43, // 15: bytebase.v1.Instance.roles:type_name -> bytebase.v1.InstanceRole- 44, // 16: bytebase.v1.Instance.sync_interval:type_name -> google.protobuf.Duration- 26, // 17: bytebase.v1.Instance.sync_databases:type_name -> bytebase.v1.SyncDatabases- 45, // 18: bytebase.v1.Instance.last_sync_time:type_name -> google.protobuf.Timestamp- 33, // 19: bytebase.v1.Instance.labels:type_name -> bytebase.v1.Instance.LabelsEntry+ 28, // 0: bytebase.v1.ListInstancesResponse.instances:type_name -> bytebase.v1.Instance+ 28, // 1: bytebase.v1.CreateInstanceRequest.instance:type_name -> bytebase.v1.Instance+ 28, // 2: bytebase.v1.UpdateInstanceRequest.instance:type_name -> bytebase.v1.Instance+ 41, // 3: bytebase.v1.UpdateInstanceRequest.update_mask:type_name -> google.protobuf.FieldMask+ 28, // 4: bytebase.v1.ListInstanceDatabaseRequest.instance:type_name -> bytebase.v1.Instance+ 16, // 5: bytebase.v1.BatchSyncInstancesRequest.requests:type_name -> bytebase.v1.SyncInstanceRequest+ 13, // 6: bytebase.v1.BatchUpdateInstancesRequest.requests:type_name -> bytebase.v1.UpdateInstanceRequest+ 28, // 7: bytebase.v1.BatchUpdateInstancesResponse.instances:type_name -> bytebase.v1.Instance+ 30, // 8: bytebase.v1.AddDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource+ 30, // 9: bytebase.v1.RemoveDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource+ 30, // 10: bytebase.v1.UpdateDataSourceRequest.data_source:type_name -> bytebase.v1.DataSource+ 41, // 11: bytebase.v1.UpdateDataSourceRequest.update_mask:type_name -> google.protobuf.FieldMask+ 42, // 12: bytebase.v1.Instance.state:type_name -> bytebase.v1.State+ 43, // 13: bytebase.v1.Instance.engine:type_name -> bytebase.v1.Engine+ 30, // 14: bytebase.v1.Instance.data_sources:type_name -> bytebase.v1.DataSource+ 44, // 15: bytebase.v1.Instance.roles:type_name -> bytebase.v1.InstanceRole+ 45, // 16: bytebase.v1.Instance.sync_interval:type_name -> google.protobuf.Duration+ 27, // 17: bytebase.v1.Instance.sync_databases:type_name -> bytebase.v1.SyncDatabases+ 46, // 18: bytebase.v1.Instance.last_sync_time:type_name -> google.protobuf.Timestamp+ 34, // 19: bytebase.v1.Instance.labels:type_name -> bytebase.v1.Instance.LabelsEntry1, // 20: bytebase.v1.DataSourceExternalSecret.secret_type:type_name -> bytebase.v1.DataSourceExternalSecret.SecretType2, // 21: bytebase.v1.DataSourceExternalSecret.auth_type:type_name -> bytebase.v1.DataSourceExternalSecret.AuthType- 34, // 22: bytebase.v1.DataSourceExternalSecret.app_role:type_name -> bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption+ 35, // 22: bytebase.v1.DataSourceExternalSecret.app_role:type_name -> bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption3, // 23: bytebase.v1.DataSourceExternalSecret.token_type:type_name -> bytebase.v1.DataSourceExternalSecret.TokenType0, // 24: bytebase.v1.DataSource.type:type_name -> bytebase.v1.DataSourceType- 28, // 25: bytebase.v1.DataSource.external_secret:type_name -> bytebase.v1.DataSourceExternalSecret+ 29, // 25: bytebase.v1.DataSource.external_secret:type_name -> bytebase.v1.DataSourceExternalSecret5, // 26: bytebase.v1.DataSource.authentication_type:type_name -> bytebase.v1.DataSource.AuthenticationType6, // 27: bytebase.v1.DataSource.cloud_sql_ip_type:type_name -> bytebase.v1.DataSource.CloudSQLIPType- 35, // 28: bytebase.v1.DataSource.azure_credential:type_name -> bytebase.v1.DataSource.AzureCredential- 36, // 29: bytebase.v1.DataSource.aws_credential:type_name -> bytebase.v1.DataSource.AWSCredential- 37, // 30: bytebase.v1.DataSource.gcp_credential:type_name -> bytebase.v1.DataSource.GCPCredential- 31, // 31: bytebase.v1.DataSource.sasl_config:type_name -> bytebase.v1.SASLConfig- 38, // 32: bytebase.v1.DataSource.additional_addresses:type_name -> bytebase.v1.DataSource.Address+ 36, // 28: bytebase.v1.DataSource.azure_credential:type_name -> bytebase.v1.DataSource.AzureCredential+ 37, // 29: bytebase.v1.DataSource.aws_credential:type_name -> bytebase.v1.DataSource.AWSCredential+ 38, // 30: bytebase.v1.DataSource.gcp_credential:type_name -> bytebase.v1.DataSource.GCPCredential+ 32, // 31: bytebase.v1.DataSource.sasl_config:type_name -> bytebase.v1.SASLConfig+ 39, // 32: bytebase.v1.DataSource.additional_addresses:type_name -> bytebase.v1.DataSource.Address7, // 33: bytebase.v1.DataSource.redis_type:type_name -> bytebase.v1.DataSource.RedisType- 39, // 34: bytebase.v1.DataSource.extra_connection_parameters:type_name -> bytebase.v1.DataSource.ExtraConnectionParametersEntry- 42, // 35: bytebase.v1.InstanceResource.engine:type_name -> bytebase.v1.Engine- 29, // 36: bytebase.v1.InstanceResource.data_sources:type_name -> bytebase.v1.DataSource- 32, // 37: bytebase.v1.SASLConfig.krb_config:type_name -> bytebase.v1.KerberosConfig+ 40, // 34: bytebase.v1.DataSource.extra_connection_parameters:type_name -> bytebase.v1.DataSource.ExtraConnectionParametersEntry+ 43, // 35: bytebase.v1.InstanceResource.engine:type_name -> bytebase.v1.Engine+ 30, // 36: bytebase.v1.InstanceResource.data_sources:type_name -> bytebase.v1.DataSource+ 33, // 37: bytebase.v1.SASLConfig.krb_config:type_name -> bytebase.v1.KerberosConfig4, // 38: bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption.type:type_name -> bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption.SecretType8, // 39: bytebase.v1.InstanceService.GetInstance:input_type -> bytebase.v1.GetInstanceRequest9, // 40: bytebase.v1.InstanceService.ListInstances:input_type -> bytebase.v1.ListInstancesRequest11, // 41: bytebase.v1.InstanceService.CreateInstance:input_type -> bytebase.v1.CreateInstanceRequest- 12, // 42: bytebase.v1.InstanceService.UpdateInstance:input_type -> bytebase.v1.UpdateInstanceRequest- 13, // 43: bytebase.v1.InstanceService.DeleteInstance:input_type -> bytebase.v1.DeleteInstanceRequest- 14, // 44: bytebase.v1.InstanceService.UndeleteInstance:input_type -> bytebase.v1.UndeleteInstanceRequest- 15, // 45: bytebase.v1.InstanceService.SyncInstance:input_type -> bytebase.v1.SyncInstanceRequest- 16, // 46: bytebase.v1.InstanceService.ListInstanceDatabase:input_type -> bytebase.v1.ListInstanceDatabaseRequest- 19, // 47: bytebase.v1.InstanceService.BatchSyncInstances:input_type -> bytebase.v1.BatchSyncInstancesRequest- 21, // 48: bytebase.v1.InstanceService.BatchUpdateInstances:input_type -> bytebase.v1.BatchUpdateInstancesRequest- 23, // 49: bytebase.v1.InstanceService.AddDataSource:input_type -> bytebase.v1.AddDataSourceRequest- 24, // 50: bytebase.v1.InstanceService.RemoveDataSource:input_type -> bytebase.v1.RemoveDataSourceRequest- 25, // 51: bytebase.v1.InstanceService.UpdateDataSource:input_type -> bytebase.v1.UpdateDataSourceRequest- 27, // 52: bytebase.v1.InstanceService.GetInstance:output_type -> bytebase.v1.Instance- 10, // 53: bytebase.v1.InstanceService.ListInstances:output_type -> bytebase.v1.ListInstancesResponse- 27, // 54: bytebase.v1.InstanceService.CreateInstance:output_type -> bytebase.v1.Instance- 27, // 55: bytebase.v1.InstanceService.UpdateInstance:output_type -> bytebase.v1.Instance- 46, // 56: bytebase.v1.InstanceService.DeleteInstance:output_type -> google.protobuf.Empty- 27, // 57: bytebase.v1.InstanceService.UndeleteInstance:output_type -> bytebase.v1.Instance- 18, // 58: bytebase.v1.InstanceService.SyncInstance:output_type -> bytebase.v1.SyncInstanceResponse- 17, // 59: bytebase.v1.InstanceService.ListInstanceDatabase:output_type -> bytebase.v1.ListInstanceDatabaseResponse- 20, // 60: bytebase.v1.InstanceService.BatchSyncInstances:output_type -> bytebase.v1.BatchSyncInstancesResponse- 22, // 61: bytebase.v1.InstanceService.BatchUpdateInstances:output_type -> bytebase.v1.BatchUpdateInstancesResponse- 27, // 62: bytebase.v1.InstanceService.AddDataSource:output_type -> bytebase.v1.Instance- 27, // 63: bytebase.v1.InstanceService.RemoveDataSource:output_type -> bytebase.v1.Instance- 27, // 64: bytebase.v1.InstanceService.UpdateDataSource:output_type -> bytebase.v1.Instance- 52, // [52:65] is the sub-list for method output_type- 39, // [39:52] is the sub-list for method input_type+ 12, // 42: bytebase.v1.InstanceService.PrepareSampleProjectInstance:input_type -> bytebase.v1.PrepareSampleProjectInstanceRequest+ 13, // 43: bytebase.v1.InstanceService.UpdateInstance:input_type -> bytebase.v1.UpdateInstanceRequest+ 14, // 44: bytebase.v1.InstanceService.DeleteInstance:input_type -> bytebase.v1.DeleteInstanceRequest+ 15, // 45: bytebase.v1.InstanceService.UndeleteInstance:input_type -> bytebase.v1.UndeleteInstanceRequest+ 16, // 46: bytebase.v1.InstanceService.SyncInstance:input_type -> bytebase.v1.SyncInstanceRequest+ 17, // 47: bytebase.v1.InstanceService.ListInstanceDatabase:input_type -> bytebase.v1.ListInstanceDatabaseRequest+ 20, // 48: bytebase.v1.InstanceService.BatchSyncInstances:input_type -> bytebase.v1.BatchSyncInstancesRequest+ 22, // 49: bytebase.v1.InstanceService.BatchUpdateInstances:input_type -> bytebase.v1.BatchUpdateInstancesRequest+ 24, // 50: bytebase.v1.InstanceService.AddDataSource:input_type -> bytebase.v1.AddDataSourceRequest+ 25, // 51: bytebase.v1.InstanceService.RemoveDataSource:input_type -> bytebase.v1.RemoveDataSourceRequest+ 26, // 52: bytebase.v1.InstanceService.UpdateDataSource:input_type -> bytebase.v1.UpdateDataSourceRequest+ 28, // 53: bytebase.v1.InstanceService.GetInstance:output_type -> bytebase.v1.Instance+ 10, // 54: bytebase.v1.InstanceService.ListInstances:output_type -> bytebase.v1.ListInstancesResponse+ 28, // 55: bytebase.v1.InstanceService.CreateInstance:output_type -> bytebase.v1.Instance+ 28, // 56: bytebase.v1.InstanceService.PrepareSampleProjectInstance:output_type -> bytebase.v1.Instance+ 28, // 57: bytebase.v1.InstanceService.UpdateInstance:output_type -> bytebase.v1.Instance+ 47, // 58: bytebase.v1.InstanceService.DeleteInstance:output_type -> google.protobuf.Empty+ 28, // 59: bytebase.v1.InstanceService.UndeleteInstance:output_type -> bytebase.v1.Instance+ 19, // 60: bytebase.v1.InstanceService.SyncInstance:output_type -> bytebase.v1.SyncInstanceResponse+ 18, // 61: bytebase.v1.InstanceService.ListInstanceDatabase:output_type -> bytebase.v1.ListInstanceDatabaseResponse+ 21, // 62: bytebase.v1.InstanceService.BatchSyncInstances:output_type -> bytebase.v1.BatchSyncInstancesResponse+ 23, // 63: bytebase.v1.InstanceService.BatchUpdateInstances:output_type -> bytebase.v1.BatchUpdateInstancesResponse+ 28, // 64: bytebase.v1.InstanceService.AddDataSource:output_type -> bytebase.v1.Instance+ 28, // 65: bytebase.v1.InstanceService.RemoveDataSource:output_type -> bytebase.v1.Instance+ 28, // 66: bytebase.v1.InstanceService.UpdateDataSource:output_type -> bytebase.v1.Instance+ 53, // [53:67] is the sub-list for method output_type+ 39, // [39:53] is the sub-list for method input_type39, // [39:39] is the sub-list for extension type_name39, // [39:39] is the sub-list for extension extendee0, // [0:39] is the sub-list for field type_name@@ -3522,21 +3575,21 @@ func file_v1_instance_service_proto_init() {file_v1_instance_role_service_proto_init()file_v1_instance_service_proto_msgTypes[1].OneofWrappers = []any{}file_v1_instance_service_proto_msgTypes[3].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[8].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[11].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[13].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[19].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[20].OneofWrappers = []any{+ file_v1_instance_service_proto_msgTypes[9].OneofWrappers = []any{}+ file_v1_instance_service_proto_msgTypes[12].OneofWrappers = []any{}+ file_v1_instance_service_proto_msgTypes[14].OneofWrappers = []any{}+ file_v1_instance_service_proto_msgTypes[20].OneofWrappers = []any{}+ file_v1_instance_service_proto_msgTypes[21].OneofWrappers = []any{(*DataSourceExternalSecret_AppRole)(nil),(*DataSourceExternalSecret_Token)(nil),}- file_v1_instance_service_proto_msgTypes[21].OneofWrappers = []any{+ file_v1_instance_service_proto_msgTypes[22].OneofWrappers = []any{(*DataSource_AzureCredential_)(nil),(*DataSource_AwsCredential)(nil),(*DataSource_GcpCredential)(nil),}- file_v1_instance_service_proto_msgTypes[22].OneofWrappers = []any{}- file_v1_instance_service_proto_msgTypes[23].OneofWrappers = []any{+ file_v1_instance_service_proto_msgTypes[23].OneofWrappers = []any{}+ file_v1_instance_service_proto_msgTypes[24].OneofWrappers = []any{(*SASLConfig_KrbConfig)(nil),}type x struct{}@@ -3545,7 +3598,7 @@ func file_v1_instance_service_proto_init() {GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_instance_service_proto_rawDesc), len(file_v1_instance_service_proto_rawDesc)),NumEnums: 8,- NumMessages: 32,+ NumMessages: 33,NumExtensions: 0,NumServices: 1,},diff --git a/backend/generated-go/v1/instance_service.pb.gw.go b/backend/generated-go/v1/instance_service.pb.gw.goindex e98cb2eefa..f629df797f 100644--- a/backend/generated-go/v1/instance_service.pb.gw.go+++ b/backend/generated-go/v1/instance_service.pb.gw.go@@ -301,6 +301,51 @@ func local_request_InstanceService_CreateInstance_1(ctx context.Context, marshalreturn msg, metadata, err}+func request_InstanceService_PrepareSampleProjectInstance_0(ctx context.Context, marshaler runtime.Marshaler, client InstanceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {+ var (+ protoReq PrepareSampleProjectInstanceRequest+ metadata runtime.ServerMetadata+ err error+ )+ if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)+ }+ val, ok := pathParams["parent"]+ if !ok {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")+ }+ protoReq.Parent, err = runtime.String(val)+ if err != nil {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)+ }+ if req.Body != nil {+ _, _ = io.Copy(io.Discard, req.Body)+ }+ msg, err := client.PrepareSampleProjectInstance(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))+ return msg, metadata, err+}++func local_request_InstanceService_PrepareSampleProjectInstance_0(ctx context.Context, marshaler runtime.Marshaler, server InstanceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {+ var (+ protoReq PrepareSampleProjectInstanceRequest+ metadata runtime.ServerMetadata+ err error+ )+ if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)+ }+ val, ok := pathParams["parent"]+ if !ok {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent")+ }+ protoReq.Parent, err = runtime.String(val)+ if err != nil {+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err)+ }+ msg, err := server.PrepareSampleProjectInstance(ctx, &protoReq)+ return msg, metadata, err+}+var filter_InstanceService_UpdateInstance_0 = &utilities.DoubleArray{Encoding: map[string]int{"instance": 0, "name": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}}func request_InstanceService_UpdateInstance_0(ctx context.Context, marshaler runtime.Marshaler, client InstanceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {@@ -1451,6 +1496,26 @@ func RegisterInstanceServiceHandlerServer(ctx context.Context, mux *runtime.Serv}forward_InstanceService_CreateInstance_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)})+ mux.Handle(http.MethodPost, pattern_InstanceService_PrepareSampleProjectInstance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {+ ctx, cancel := context.WithCancel(req.Context())+ defer cancel()+ var stream runtime.ServerTransportStream+ ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)+ annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/bytebase.v1.InstanceService/PrepareSampleProjectInstance", runtime.WithHTTPPathPattern("/v1/{parent=projects/*}/instances:prepareSampleProjectInstance"))+ if err != nil {+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)+ return+ }+ resp, md, err := local_request_InstanceService_PrepareSampleProjectInstance_0(annotatedContext, inboundMarshaler, server, req, pathParams)+ md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)+ if err != nil {+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)+ return+ }+ forward_InstanceService_PrepareSampleProjectInstance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)+ })mux.Handle(http.MethodPatch, pattern_InstanceService_UpdateInstance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {ctx, cancel := context.WithCancel(req.Context())defer cancel()@@ -1993,6 +2058,23 @@ func RegisterInstanceServiceHandlerClient(ctx context.Context, mux *runtime.Serv}forward_InstanceService_CreateInstance_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)})+ mux.Handle(http.MethodPost, pattern_InstanceService_PrepareSampleProjectInstance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {+ ctx, cancel := context.WithCancel(req.Context())+ defer cancel()+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)+ annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/bytebase.v1.InstanceService/PrepareSampleProjectInstance", runtime.WithHTTPPathPattern("/v1/{parent=projects/*}/instances:prepareSampleProjectInstance"))+ if err != nil {+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)+ return+ }+ resp, md, err := request_InstanceService_PrepareSampleProjectInstance_0(annotatedContext, inboundMarshaler, client, req, pathParams)+ annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)+ if err != nil {+ runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)+ return+ }+ forward_InstanceService_PrepareSampleProjectInstance_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)+ })mux.Handle(http.MethodPatch, pattern_InstanceService_UpdateInstance_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {ctx, cancel := context.WithCancel(req.Context())defer cancel()@@ -2337,59 +2419,61 @@ func RegisterInstanceServiceHandlerClient(ctx context.Context, mux *runtime.Serv}var (- pattern_InstanceService_GetInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, ""))- pattern_InstanceService_GetInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, ""))- pattern_InstanceService_ListInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, ""))- pattern_InstanceService_ListInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, ""))- pattern_InstanceService_CreateInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, ""))- pattern_InstanceService_CreateInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, ""))- pattern_InstanceService_UpdateInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "instance.name"}, ""))- pattern_InstanceService_UpdateInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "instance.name"}, ""))- pattern_InstanceService_DeleteInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, ""))- pattern_InstanceService_DeleteInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, ""))- pattern_InstanceService_UndeleteInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "undelete"))- pattern_InstanceService_UndeleteInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "undelete"))- pattern_InstanceService_SyncInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "sync"))- pattern_InstanceService_SyncInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "sync"))- pattern_InstanceService_ListInstanceDatabase_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "databases"))- pattern_InstanceService_ListInstanceDatabase_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "databases"))- pattern_InstanceService_BatchSyncInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, "batchSync"))- pattern_InstanceService_BatchSyncInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, "batchSync"))- pattern_InstanceService_BatchUpdateInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, "batchUpdate"))- pattern_InstanceService_BatchUpdateInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, "batchUpdate"))- pattern_InstanceService_AddDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "addDataSource"))- pattern_InstanceService_AddDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "addDataSource"))- pattern_InstanceService_RemoveDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "removeDataSource"))- pattern_InstanceService_RemoveDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "removeDataSource"))- pattern_InstanceService_UpdateDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "updateDataSource"))- pattern_InstanceService_UpdateDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "updateDataSource"))+ pattern_InstanceService_GetInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, ""))+ pattern_InstanceService_GetInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, ""))+ pattern_InstanceService_ListInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, ""))+ pattern_InstanceService_ListInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, ""))+ pattern_InstanceService_CreateInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, ""))+ pattern_InstanceService_CreateInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, ""))+ pattern_InstanceService_PrepareSampleProjectInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, "prepareSampleProjectInstance"))+ pattern_InstanceService_UpdateInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "instance.name"}, ""))+ pattern_InstanceService_UpdateInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "instance.name"}, ""))+ pattern_InstanceService_DeleteInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, ""))+ pattern_InstanceService_DeleteInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, ""))+ pattern_InstanceService_UndeleteInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "undelete"))+ pattern_InstanceService_UndeleteInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "undelete"))+ pattern_InstanceService_SyncInstance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "sync"))+ pattern_InstanceService_SyncInstance_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "sync"))+ pattern_InstanceService_ListInstanceDatabase_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "databases"))+ pattern_InstanceService_ListInstanceDatabase_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "databases"))+ pattern_InstanceService_BatchSyncInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, "batchSync"))+ pattern_InstanceService_BatchSyncInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, "batchSync"))+ pattern_InstanceService_BatchUpdateInstances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "instances"}, "batchUpdate"))+ pattern_InstanceService_BatchUpdateInstances_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2, 2, 3}, []string{"v1", "projects", "parent", "instances"}, "batchUpdate"))+ pattern_InstanceService_AddDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "addDataSource"))+ pattern_InstanceService_AddDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "addDataSource"))+ pattern_InstanceService_RemoveDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "removeDataSource"))+ pattern_InstanceService_RemoveDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "removeDataSource"))+ pattern_InstanceService_UpdateDataSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 2, 5, 2}, []string{"v1", "instances", "name"}, "updateDataSource"))+ pattern_InstanceService_UpdateDataSource_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "instances", "name"}, "updateDataSource")))var (- forward_InstanceService_GetInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_GetInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_ListInstances_0 = runtime.ForwardResponseMessage- forward_InstanceService_ListInstances_1 = runtime.ForwardResponseMessage- forward_InstanceService_CreateInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_CreateInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_UpdateInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_UpdateInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_DeleteInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_DeleteInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_UndeleteInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_UndeleteInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_SyncInstance_0 = runtime.ForwardResponseMessage- forward_InstanceService_SyncInstance_1 = runtime.ForwardResponseMessage- forward_InstanceService_ListInstanceDatabase_0 = runtime.ForwardResponseMessage- forward_InstanceService_ListInstanceDatabase_1 = runtime.ForwardResponseMessage- forward_InstanceService_BatchSyncInstances_0 = runtime.ForwardResponseMessage- forward_InstanceService_BatchSyncInstances_1 = runtime.ForwardResponseMessage- forward_InstanceService_BatchUpdateInstances_0 = runtime.ForwardResponseMessage- forward_InstanceService_BatchUpdateInstances_1 = runtime.ForwardResponseMessage- forward_InstanceService_AddDataSource_0 = runtime.ForwardResponseMessage- forward_InstanceService_AddDataSource_1 = runtime.ForwardResponseMessage- forward_InstanceService_RemoveDataSource_0 = runtime.ForwardResponseMessage- forward_InstanceService_RemoveDataSource_1 = runtime.ForwardResponseMessage- forward_InstanceService_UpdateDataSource_0 = runtime.ForwardResponseMessage- forward_InstanceService_UpdateDataSource_1 = runtime.ForwardResponseMessage+ forward_InstanceService_GetInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_GetInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_ListInstances_0 = runtime.ForwardResponseMessage+ forward_InstanceService_ListInstances_1 = runtime.ForwardResponseMessage+ forward_InstanceService_CreateInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_CreateInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_PrepareSampleProjectInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_UpdateInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_UpdateInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_DeleteInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_DeleteInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_UndeleteInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_UndeleteInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_SyncInstance_0 = runtime.ForwardResponseMessage+ forward_InstanceService_SyncInstance_1 = runtime.ForwardResponseMessage+ forward_InstanceService_ListInstanceDatabase_0 = runtime.ForwardResponseMessage+ forward_InstanceService_ListInstanceDatabase_1 = runtime.ForwardResponseMessage+ forward_InstanceService_BatchSyncInstances_0 = runtime.ForwardResponseMessage+ forward_InstanceService_BatchSyncInstances_1 = runtime.ForwardResponseMessage+ forward_InstanceService_BatchUpdateInstances_0 = runtime.ForwardResponseMessage+ forward_InstanceService_BatchUpdateInstances_1 = runtime.ForwardResponseMessage+ forward_InstanceService_AddDataSource_0 = runtime.ForwardResponseMessage+ forward_InstanceService_AddDataSource_1 = runtime.ForwardResponseMessage+ forward_InstanceService_RemoveDataSource_0 = runtime.ForwardResponseMessage+ forward_InstanceService_RemoveDataSource_1 = runtime.ForwardResponseMessage+ forward_InstanceService_UpdateDataSource_0 = runtime.ForwardResponseMessage+ forward_InstanceService_UpdateDataSource_1 = runtime.ForwardResponseMessage)diff --git a/backend/generated-go/v1/instance_service_equal.pb.go b/backend/generated-go/v1/instance_service_equal.pb.goindex 1cc09c36d9..223e620c9c 100644--- a/backend/generated-go/v1/instance_service_equal.pb.go+++ b/backend/generated-go/v1/instance_service_equal.pb.go@@ -92,6 +92,19 @@ func (x *CreateInstanceRequest) Equal(y *CreateInstanceRequest) bool {return true}+func (x *PrepareSampleProjectInstanceRequest) Equal(y *PrepareSampleProjectInstanceRequest) bool {+ if x == y {+ return true+ }+ if x == nil || y == nil {+ return x == nil && y == nil+ }+ if x.Parent != y.Parent {+ return false+ }+ return true+}+func (x *UpdateInstanceRequest) Equal(y *UpdateInstanceRequest) bool {if x == y {return truediff --git a/backend/generated-go/v1/instance_service_grpc.pb.go b/backend/generated-go/v1/instance_service_grpc.pb.goindex bffb3fd91e..2f81581894 100644--- a/backend/generated-go/v1/instance_service_grpc.pb.go+++ b/backend/generated-go/v1/instance_service_grpc.pb.go@@ -20,19 +20,20 @@ import (const _ = grpc.SupportPackageIsVersion9const (- InstanceService_GetInstance_FullMethodName = "/bytebase.v1.InstanceService/GetInstance"- InstanceService_ListInstances_FullMethodName = "/bytebase.v1.InstanceService/ListInstances"- InstanceService_CreateInstance_FullMethodName = "/bytebase.v1.InstanceService/CreateInstance"- InstanceService_UpdateInstance_FullMethodName = "/bytebase.v1.InstanceService/UpdateInstance"- InstanceService_DeleteInstance_FullMethodName = "/bytebase.v1.InstanceService/DeleteInstance"- InstanceService_UndeleteInstance_FullMethodName = "/bytebase.v1.InstanceService/UndeleteInstance"- InstanceService_SyncInstance_FullMethodName = "/bytebase.v1.InstanceService/SyncInstance"- InstanceService_ListInstanceDatabase_FullMethodName = "/bytebase.v1.InstanceService/ListInstanceDatabase"- InstanceService_BatchSyncInstances_FullMethodName = "/bytebase.v1.InstanceService/BatchSyncInstances"- InstanceService_BatchUpdateInstances_FullMethodName = "/bytebase.v1.InstanceService/BatchUpdateInstances"- InstanceService_AddDataSource_FullMethodName = "/bytebase.v1.InstanceService/AddDataSource"- InstanceService_RemoveDataSource_FullMethodName = "/bytebase.v1.InstanceService/RemoveDataSource"- InstanceService_UpdateDataSource_FullMethodName = "/bytebase.v1.InstanceService/UpdateDataSource"+ InstanceService_GetInstance_FullMethodName = "/bytebase.v1.InstanceService/GetInstance"+ InstanceService_ListInstances_FullMethodName = "/bytebase.v1.InstanceService/ListInstances"+ InstanceService_CreateInstance_FullMethodName = "/bytebase.v1.InstanceService/CreateInstance"+ InstanceService_PrepareSampleProjectInstance_FullMethodName = "/bytebase.v1.InstanceService/PrepareSampleProjectInstance"+ InstanceService_UpdateInstance_FullMethodName = "/bytebase.v1.InstanceService/UpdateInstance"+ InstanceService_DeleteInstance_FullMethodName = "/bytebase.v1.InstanceService/DeleteInstance"+ InstanceService_UndeleteInstance_FullMethodName = "/bytebase.v1.InstanceService/UndeleteInstance"+ InstanceService_SyncInstance_FullMethodName = "/bytebase.v1.InstanceService/SyncInstance"+ InstanceService_ListInstanceDatabase_FullMethodName = "/bytebase.v1.InstanceService/ListInstanceDatabase"+ InstanceService_BatchSyncInstances_FullMethodName = "/bytebase.v1.InstanceService/BatchSyncInstances"+ InstanceService_BatchUpdateInstances_FullMethodName = "/bytebase.v1.InstanceService/BatchUpdateInstances"+ InstanceService_AddDataSource_FullMethodName = "/bytebase.v1.InstanceService/AddDataSource"+ InstanceService_RemoveDataSource_FullMethodName = "/bytebase.v1.InstanceService/RemoveDataSource"+ InstanceService_UpdateDataSource_FullMethodName = "/bytebase.v1.InstanceService/UpdateDataSource")// InstanceServiceClient is the client API for InstanceService service.@@ -50,6 +51,9 @@ type InstanceServiceClient interface {// Creates a new database instance.// Permissions required: bb.instances.createCreateInstance(ctx context.Context, in *CreateInstanceRequest, opts ...grpc.CallOption) (*Instance, error)+ // Prepares a Sample Project Instance for a project.+ // Permissions required: bb.instances.create+ PrepareSampleProjectInstance(ctx context.Context, in *PrepareSampleProjectInstanceRequest, opts ...grpc.CallOption) (*Instance, error)// Updates a database instance.// Permissions required: bb.instances.updateUpdateInstance(ctx context.Context, in *UpdateInstanceRequest, opts ...grpc.CallOption) (*Instance, error)@@ -124,6 +128,16 @@ func (c *instanceServiceClient) CreateInstance(ctx context.Context, in *CreateInreturn out, nil}+func (c *instanceServiceClient) PrepareSampleProjectInstance(ctx context.Context, in *PrepareSampleProjectInstanceRequest, opts ...grpc.CallOption) (*Instance, error) {+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)+ out := new(Instance)+ err := c.cc.Invoke(ctx, InstanceService_PrepareSampleProjectInstance_FullMethodName, in, out, cOpts...)+ if err != nil {+ return nil, err+ }+ return out, nil+}+func (c *instanceServiceClient) UpdateInstance(ctx context.Context, in *UpdateInstanceRequest, opts ...grpc.CallOption) (*Instance, error) {cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)out := new(Instance)@@ -239,6 +253,9 @@ type InstanceServiceServer interface {// Creates a new database instance.// Permissions required: bb.instances.createCreateInstance(context.Context, *CreateInstanceRequest) (*Instance, error)+ // Prepares a Sample Project Instance for a project.+ // Permissions required: bb.instances.create+ PrepareSampleProjectInstance(context.Context, *PrepareSampleProjectInstanceRequest) (*Instance, error)// Updates a database instance.// Permissions required: bb.instances.updateUpdateInstance(context.Context, *UpdateInstanceRequest) (*Instance, error)@@ -292,6 +309,9 @@ func (UnimplementedInstanceServiceServer) ListInstances(context.Context, *ListInfunc (UnimplementedInstanceServiceServer) CreateInstance(context.Context, *CreateInstanceRequest) (*Instance, error) {return nil, status.Error(codes.Unimplemented, "method CreateInstance not implemented")}+func (UnimplementedInstanceServiceServer) PrepareSampleProjectInstance(context.Context, *PrepareSampleProjectInstanceRequest) (*Instance, error) {+ return nil, status.Error(codes.Unimplemented, "method PrepareSampleProjectInstance not implemented")+}func (UnimplementedInstanceServiceServer) UpdateInstance(context.Context, *UpdateInstanceRequest) (*Instance, error) {return nil, status.Error(codes.Unimplemented, "method UpdateInstance not implemented")}@@ -397,6 +417,24 @@ func _InstanceService_CreateInstance_Handler(srv interface{}, ctx context.Contexreturn interceptor(ctx, in, info, handler)}+func _InstanceService_PrepareSampleProjectInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {+ in := new(PrepareSampleProjectInstanceRequest)+ if err := dec(in); err != nil {+ return nil, err+ }+ if interceptor == nil {+ return srv.(InstanceServiceServer).PrepareSampleProjectInstance(ctx, in)+ }+ info := &grpc.UnaryServerInfo{+ Server: srv,+ FullMethod: InstanceService_PrepareSampleProjectInstance_FullMethodName,+ }+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {+ return srv.(InstanceServiceServer).PrepareSampleProjectInstance(ctx, req.(*PrepareSampleProjectInstanceRequest))+ }+ return interceptor(ctx, in, info, handler)+}+func _InstanceService_UpdateInstance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {in := new(UpdateInstanceRequest)if err := dec(in); err != nil {@@ -596,6 +634,10 @@ var InstanceService_ServiceDesc = grpc.ServiceDesc{MethodName: "CreateInstance",Handler: _InstanceService_CreateInstance_Handler,},+ {+ MethodName: "PrepareSampleProjectInstance",+ Handler: _InstanceService_PrepareSampleProjectInstance_Handler,+ },{MethodName: "UpdateInstance",Handler: _InstanceService_UpdateInstance_Handler,diff --git a/backend/generated-go/v1/v1connect/instance_service.connect.go b/backend/generated-go/v1/v1connect/instance_service.connect.goindex e886ed83d8..9050f1e57f 100644--- a/backend/generated-go/v1/v1connect/instance_service.connect.go+++ b/backend/generated-go/v1/v1connect/instance_service.connect.go@@ -43,6 +43,9 @@ const (// InstanceServiceCreateInstanceProcedure is the fully-qualified name of the InstanceService's// CreateInstance RPC.InstanceServiceCreateInstanceProcedure = "/bytebase.v1.InstanceService/CreateInstance"+ // InstanceServicePrepareSampleProjectInstanceProcedure is the fully-qualified name of the+ // InstanceService's PrepareSampleProjectInstance RPC.+ InstanceServicePrepareSampleProjectInstanceProcedure = "/bytebase.v1.InstanceService/PrepareSampleProjectInstance"// InstanceServiceUpdateInstanceProcedure is the fully-qualified name of the InstanceService's// UpdateInstance RPC.InstanceServiceUpdateInstanceProcedure = "/bytebase.v1.InstanceService/UpdateInstance"@@ -86,6 +89,9 @@ type InstanceServiceClient interface {// Creates a new database instance.// Permissions required: bb.instances.createCreateInstance(context.Context, *connect.Request[v1.CreateInstanceRequest]) (*connect.Response[v1.Instance], error)+ // Prepares a Sample Project Instance for a project.+ // Permissions required: bb.instances.create+ PrepareSampleProjectInstance(context.Context, *connect.Request[v1.PrepareSampleProjectInstanceRequest]) (*connect.Response[v1.Instance], error)// Updates a database instance.// Permissions required: bb.instances.updateUpdateInstance(context.Context, *connect.Request[v1.UpdateInstanceRequest]) (*connect.Response[v1.Instance], error)@@ -151,6 +157,12 @@ func NewInstanceServiceClient(httpClient connect.HTTPClient, baseURL string, optconnect.WithSchema(instanceServiceMethods.ByName("CreateInstance")),connect.WithClientOptions(opts...),),+ prepareSampleProjectInstance: connect.NewClient[v1.PrepareSampleProjectInstanceRequest, v1.Instance](+ httpClient,+ baseURL+InstanceServicePrepareSampleProjectInstanceProcedure,+ connect.WithSchema(instanceServiceMethods.ByName("PrepareSampleProjectInstance")),+ connect.WithClientOptions(opts...),+ ),updateInstance: connect.NewClient[v1.UpdateInstanceRequest, v1.Instance](httpClient,baseURL+InstanceServiceUpdateInstanceProcedure,@@ -216,19 +228,20 @@ func NewInstanceServiceClient(httpClient connect.HTTPClient, baseURL string, opt// instanceServiceClient implements InstanceServiceClient.type instanceServiceClient struct {- getInstance *connect.Client[v1.GetInstanceRequest, v1.Instance]- listInstances *connect.Client[v1.ListInstancesRequest, v1.ListInstancesResponse]- createInstance *connect.Client[v1.CreateInstanceRequest, v1.Instance]- updateInstance *connect.Client[v1.UpdateInstanceRequest, v1.Instance]- deleteInstance *connect.Client[v1.DeleteInstanceRequest, emptypb.Empty]- undeleteInstance *connect.Client[v1.UndeleteInstanceRequest, v1.Instance]- syncInstance *connect.Client[v1.SyncInstanceRequest, v1.SyncInstanceResponse]- listInstanceDatabase *connect.Client[v1.ListInstanceDatabaseRequest, v1.ListInstanceDatabaseResponse]- batchSyncInstances *connect.Client[v1.BatchSyncInstancesRequest, v1.BatchSyncInstancesResponse]- batchUpdateInstances *connect.Client[v1.BatchUpdateInstancesRequest, v1.BatchUpdateInstancesResponse]- addDataSource *connect.Client[v1.AddDataSourceRequest, v1.Instance]- removeDataSource *connect.Client[v1.RemoveDataSourceRequest, v1.Instance]- updateDataSource *connect.Client[v1.UpdateDataSourceRequest, v1.Instance]+ getInstance *connect.Client[v1.GetInstanceRequest, v1.Instance]+ listInstances *connect.Client[v1.ListInstancesRequest, v1.ListInstancesResponse]+ createInstance *connect.Client[v1.CreateInstanceRequest, v1.Instance]+ prepareSampleProjectInstance *connect.Client[v1.PrepareSampleProjectInstanceRequest, v1.Instance]+ updateInstance *connect.Client[v1.UpdateInstanceRequest, v1.Instance]+ deleteInstance *connect.Client[v1.DeleteInstanceRequest, emptypb.Empty]+ undeleteInstance *connect.Client[v1.UndeleteInstanceRequest, v1.Instance]+ syncInstance *connect.Client[v1.SyncInstanceRequest, v1.SyncInstanceResponse]+ listInstanceDatabase *connect.Client[v1.ListInstanceDatabaseRequest, v1.ListInstanceDatabaseResponse]+ batchSyncInstances *connect.Client[v1.BatchSyncInstancesRequest, v1.BatchSyncInstancesResponse]+ batchUpdateInstances *connect.Client[v1.BatchUpdateInstancesRequest, v1.BatchUpdateInstancesResponse]+ addDataSource *connect.Client[v1.AddDataSourceRequest, v1.Instance]+ removeDataSource *connect.Client[v1.RemoveDataSourceRequest, v1.Instance]+ updateDataSource *connect.Client[v1.UpdateDataSourceRequest, v1.Instance]}// GetInstance calls bytebase.v1.InstanceService.GetInstance.@@ -246,6 +259,11 @@ func (c *instanceServiceClient) CreateInstance(ctx context.Context, req *connectreturn c.createInstance.CallUnary(ctx, req)}+// PrepareSampleProjectInstance calls bytebase.v1.InstanceService.PrepareSampleProjectInstance.+func (c *instanceServiceClient) PrepareSampleProjectInstance(ctx context.Context, req *connect.Request[v1.PrepareSampleProjectInstanceRequest]) (*connect.Response[v1.Instance], error) {+ return c.prepareSampleProjectInstance.CallUnary(ctx, req)+}+// UpdateInstance calls bytebase.v1.InstanceService.UpdateInstance.func (c *instanceServiceClient) UpdateInstance(ctx context.Context, req *connect.Request[v1.UpdateInstanceRequest]) (*connect.Response[v1.Instance], error) {return c.updateInstance.CallUnary(ctx, req)@@ -307,6 +325,9 @@ type InstanceServiceHandler interface {// Creates a new database instance.// Permissions required: bb.instances.createCreateInstance(context.Context, *connect.Request[v1.CreateInstanceRequest]) (*connect.Response[v1.Instance], error)+ // Prepares a Sample Project Instance for a project.+ // Permissions required: bb.instances.create+ PrepareSampleProjectInstance(context.Context, *connect.Request[v1.PrepareSampleProjectInstanceRequest]) (*connect.Response[v1.Instance], error)// Updates a database instance.// Permissions required: bb.instances.updateUpdateInstance(context.Context, *connect.Request[v1.UpdateInstanceRequest]) (*connect.Response[v1.Instance], error)@@ -368,6 +389,12 @@ func NewInstanceServiceHandler(svc InstanceServiceHandler, opts ...connect.Handlconnect.WithSchema(instanceServiceMethods.ByName("CreateInstance")),connect.WithHandlerOptions(opts...),)+ instanceServicePrepareSampleProjectInstanceHandler := connect.NewUnaryHandler(+ InstanceServicePrepareSampleProjectInstanceProcedure,+ svc.PrepareSampleProjectInstance,+ connect.WithSchema(instanceServiceMethods.ByName("PrepareSampleProjectInstance")),+ connect.WithHandlerOptions(opts...),+ )instanceServiceUpdateInstanceHandler := connect.NewUnaryHandler(InstanceServiceUpdateInstanceProcedure,svc.UpdateInstance,@@ -436,6 +463,8 @@ func NewInstanceServiceHandler(svc InstanceServiceHandler, opts ...connect.HandlinstanceServiceListInstancesHandler.ServeHTTP(w, r)case InstanceServiceCreateInstanceProcedure:instanceServiceCreateInstanceHandler.ServeHTTP(w, r)+ case InstanceServicePrepareSampleProjectInstanceProcedure:+ instanceServicePrepareSampleProjectInstanceHandler.ServeHTTP(w, r)case InstanceServiceUpdateInstanceProcedure:instanceServiceUpdateInstanceHandler.ServeHTTP(w, r)case InstanceServiceDeleteInstanceProcedure:@@ -477,6 +506,10 @@ func (UnimplementedInstanceServiceHandler) CreateInstance(context.Context, *connreturn nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.InstanceService.CreateInstance is not implemented"))}+func (UnimplementedInstanceServiceHandler) PrepareSampleProjectInstance(context.Context, *connect.Request[v1.PrepareSampleProjectInstanceRequest]) (*connect.Response[v1.Instance], error) {+ return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.InstanceService.PrepareSampleProjectInstance is not implemented"))+}+func (UnimplementedInstanceServiceHandler) UpdateInstance(context.Context, *connect.Request[v1.UpdateInstanceRequest]) (*connect.Response[v1.Instance], error) {return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.InstanceService.UpdateInstance is not implemented"))}diff --git a/backend/migrator/migration/3.22/0011##sample_project_instance.sql b/backend/migrator/migration/3.22/0011##sample_project_instance.sqlnew file mode 100644index 0000000000..78e1d25414--- /dev/null+++ b/backend/migrator/migration/3.22/0011##sample_project_instance.sql@@ -0,0 +1,14 @@+-- Tracks the lifetime sample Project Instance entitlement independently of+-- Bytebase metadata and its physical PostgreSQL resources.+CREATE TABLE sample_project_instance (+ workspace text PRIMARY KEY,+ project text NOT NULL,+ instance text NOT NULL UNIQUE,+ db_name text NOT NULL UNIQUE,+ role_name text NOT NULL UNIQUE,+ replica_id text NOT NULL,+ created_at timestamptz NOT NULL DEFAULT now(),+ expires_at timestamptz,+ deleted_at timestamptz,+ CHECK (deleted_at IS NULL OR expires_at IS NOT NULL)+);diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sqlindex c71186fd0e..56efa99385 100644--- a/backend/migrator/migration/LATEST.sql+++ b/backend/migrator/migration/LATEST.sql@@ -17,6 +17,21 @@ CREATE TABLE workspace (deleted boolean NOT NULL DEFAULT FALSE);+-- Tracks the lifetime sample Project Instance entitlement independently of+-- Bytebase metadata and its physical PostgreSQL resources.+CREATE TABLE sample_project_instance (+ workspace text PRIMARY KEY,+ project text NOT NULL,+ instance text NOT NULL UNIQUE,+ db_name text NOT NULL UNIQUE,+ role_name text NOT NULL UNIQUE,+ replica_id text NOT NULL,+ created_at timestamptz NOT NULL DEFAULT now(),+ expires_at timestamptz,+ deleted_at timestamptz,+ CHECK (deleted_at IS NULL OR expires_at IS NOT NULL)+);+CREATE TABLE subscription (workspace text NOT NULL REFERENCES workspace(resource_id) PRIMARY KEY,-- Stored as SubscriptionPayload (proto/store/store/subscription.proto)diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.goindex 41aa741303..15b7aef266 100644--- a/backend/migrator/migrator_test.go+++ b/backend/migrator/migrator_test.go@@ -21,8 +21,8 @@ import (func TestLatestVersion(t *testing.T) {files, err := getSortedVersionedFiles()require.NoError(t, err)- require.Equal(t, semver.MustParse("3.22.10"), *files[len(files)-1].version)- require.Equal(t, "migration/3.22/0010##saved_query_updated_at_index.sql", files[len(files)-1].path)+ require.Equal(t, semver.MustParse("3.22.11"), *files[len(files)-1].version)+ require.Equal(t, "migration/3.22/0011##sample_project_instance.sql", files[len(files)-1].path)}func TestVersionUnique(t *testing.T) {diff --git a/backend/resources/postgres/sample_instance.go b/backend/resources/postgres/sample_instance.goindex 089dc1125b..bf95eaedbb 100644--- a/backend/resources/postgres/sample_instance.go+++ b/backend/resources/postgres/sample_instance.go@@ -36,7 +36,7 @@ var (// StartAllSampleInstances starts all postgres sample instances.func StartAllSampleInstances(ctx context.Context, dataDir string, basePort int) []func() {- sampleData, err := loadSampleData()+ sampleData, err := LoadSampleData()if err != nil {slog.Error("failed to load sample data", log.BBError(err))return nil@@ -74,7 +74,9 @@ func StartAllSampleInstances(ctx context.Context, dataDir string, basePort int)return stoppers}-func loadSampleData() (string, error) {+// LoadSampleData returns the ordered employee sample SQL embedded in this+// package. Callers execute it in their own transaction.+func LoadSampleData() (string, error) {// Load sample datanames, err := fs.Glob(sampleFS, "sample/*.sql")if err != nil {diff --git a/backend/runner/sampleprojectinstance/cleanup.go b/backend/runner/sampleprojectinstance/cleanup.gonew file mode 100644index 0000000000..371a4b4de9--- /dev/null+++ b/backend/runner/sampleprojectinstance/cleanup.go@@ -0,0 +1,76 @@+// Package sampleprojectinstance periodically expires Cloud sample Project+// Instances. Every replica runs this worker; row locking makes passes safe.+package sampleprojectinstance++import (+ "context"+ "log/slog"+ "sync"+ "time"+)++const interval = time.Hour++// Runner performs startup and hourly sample Project Instance cleanup.+type Runner struct {+ manager cleanupManager+ clock func() time.Time+ logger *slog.Logger+}++type cleanupManager interface {+ Cleanup(context.Context, time.Time) error+}++// Options configures a cleanup runner.+type Options struct {+ Clock func() time.Time+ Logger *slog.Logger+}++// NewRunner creates a cleanup runner.+func NewRunner(manager cleanupManager, options ...Options) *Runner {+ option := Options{}+ if len(options) > 0 {+ option = options[0]+ }+ if option.Clock == nil {+ option.Clock = time.Now+ }+ if option.Logger == nil {+ option.Logger = slog.Default()+ }+ return &Runner{+ manager: manager,+ clock: option.Clock,+ logger: option.Logger,+ }+}++// Run performs cleanup immediately, then once per hour until shutdown.+func (r *Runner) Run(ctx context.Context, wg *sync.WaitGroup) {+ defer wg.Done()+ r.runOnceAndLog(ctx)++ ticker := time.NewTicker(interval)+ defer ticker.Stop()+ for {+ select {+ case <-ctx.Done():+ return+ case <-ticker.C:+ r.runOnceAndLog(ctx)+ }+ }+}++// RunOnce performs one Sample Project Instance cleanup pass.+func (r *Runner) RunOnce(ctx context.Context) error {+ return r.manager.Cleanup(ctx, r.clock())+}++func (r *Runner) runOnceAndLog(ctx context.Context) {+ if err := r.RunOnce(ctx); err != nil {+ r.logger.ErrorContext(ctx, "Sample Project Instance cleanup failed", "error", err)+ }+}diff --git a/backend/runner/sampleprojectinstance/runner_test.go b/backend/runner/sampleprojectinstance/runner_test.gonew file mode 100644index 0000000000..f1f5326a2b--- /dev/null+++ b/backend/runner/sampleprojectinstance/runner_test.go@@ -0,0 +1,56 @@+package sampleprojectinstance++import (+ "context"+ "sync"+ "testing"+ "time"++ "github.com/stretchr/testify/require"+)++func TestRunnerCleansUpImmediatelyAndStops(t *testing.T) {+ ctx, cancel := context.WithCancel(context.Background())+ t.Cleanup(cancel)+ manager := &cleanupManagerStub{calls: make(chan time.Time, 1)}+ now := time.Date(2026, time.August, 17, 12, 0, 0, 0, time.UTC)+ runner := NewRunner(manager, Options{Clock: func() time.Time { return now }})++ var wg sync.WaitGroup+ wg.Add(1)+ go runner.Run(ctx, &wg)++ require.Equal(t, now, <-manager.calls)+ cancel()+ done := make(chan struct{})+ go func() {+ wg.Wait()+ close(done)+ }()+ require.Eventually(t, func() bool {+ select {+ case <-done:+ return true+ default:+ return false+ }+ }, time.Second, 10*time.Millisecond)+}++func TestRunnerRunOnceUsesInjectedClock(t *testing.T) {+ manager := &cleanupManagerStub{calls: make(chan time.Time, 1)}+ now := time.Date(2026, time.August, 17, 12, 0, 0, 0, time.UTC)+ runner := NewRunner(manager, Options{Clock: func() time.Time { return now }})++ require.NoError(t, runner.RunOnce(context.Background()))+ require.Equal(t, now, <-manager.calls)+}++type cleanupManagerStub struct {+ calls chan time.Time+}++func (m *cleanupManagerStub) Cleanup(_ context.Context, now time.Time) error {+ m.calls <- now+ return nil+}diff --git a/backend/server/grpc_routes.go b/backend/server/grpc_routes.goindex 9e78834033..d8dc031714 100644--- a/backend/server/grpc_routes.go+++ b/backend/server/grpc_routes.go@@ -28,6 +28,7 @@ import ("github.com/bytebase/bytebase/backend/component/dbfactory""github.com/bytebase/bytebase/backend/component/iam""github.com/bytebase/bytebase/backend/component/sampleinstance"+ "github.com/bytebase/bytebase/backend/component/sampleprojectinstance""github.com/bytebase/bytebase/backend/component/sheet""github.com/bytebase/bytebase/backend/component/webhook""github.com/bytebase/bytebase/backend/enterprise"@@ -51,6 +52,7 @@ func configureGrpcRouters(iamManager *iam.Manager,secret string,sampleInstanceManager *sampleinstance.Manager,+ sampleProjectManager *sampleprojectinstance.Manager,) (http.Handler, error) {// Note: the gateway response modifier takes the token duration on server startup. If the value is changed,// the user has to restart the server to take the latest value.@@ -103,7 +105,7 @@ func configureGrpcRouters(groupService := apiv1.NewGroupService(stores, iamManager, licenseService)identityProviderService := apiv1.NewIdentityProviderService(stores, licenseService, profile)instanceRoleService := apiv1.NewInstanceRoleService(stores)- instanceService := apiv1.NewInstanceService(stores, profile, licenseService, dbFactory, schemaSyncer, sampleInstanceManager)+ instanceService := apiv1.NewInstanceService(stores, profile, licenseService, dbFactory, schemaSyncer, sampleInstanceManager, sampleProjectManager)issueService := apiv1.NewIssueService(stores, webhookManager, bus, licenseService, iamManager)orgPolicyService := apiv1.NewOrgPolicyService(stores, licenseService, iamManager)planService := apiv1.NewPlanService(stores, bus, iamManager, webhookManager, licenseService)diff --git a/backend/server/server.go b/backend/server/server.goindex f098e1ae00..2765f8193f 100644--- a/backend/server/server.go+++ b/backend/server/server.go@@ -28,6 +28,7 @@ import ("github.com/bytebase/bytebase/backend/component/productmetrics""github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/sampleinstance"+ "github.com/bytebase/bytebase/backend/component/sampleprojectinstance""github.com/bytebase/bytebase/backend/component/sheet""github.com/bytebase/bytebase/backend/component/telemetry""github.com/bytebase/bytebase/backend/component/webhook"@@ -41,6 +42,7 @@ import ("github.com/bytebase/bytebase/backend/runner/monitor""github.com/bytebase/bytebase/backend/runner/notifylistener""github.com/bytebase/bytebase/backend/runner/plancheck"+ sampleprojectinstancerunner "github.com/bytebase/bytebase/backend/runner/sampleprojectinstance""github.com/bytebase/bytebase/backend/runner/schemasync""github.com/bytebase/bytebase/backend/runner/taskrun""github.com/bytebase/bytebase/backend/store"@@ -58,18 +60,20 @@ const (// Server is the Bytebase server.type Server struct {// Asynchronous runners.- taskScheduler *taskrun.Scheduler- planCheckScheduler *plancheck.Scheduler- schemaSyncer *schemasync.Syncer- approvalRunner *review.Runner- notifyListener *notifylistener.Listener- dataCleaner *cleaner.DataCleaner- heartbeatRunner *heartbeat.Runner- runnerWG sync.WaitGroup+ taskScheduler *taskrun.Scheduler+ planCheckScheduler *plancheck.Scheduler+ schemaSyncer *schemasync.Syncer+ approvalRunner *review.Runner+ notifyListener *notifylistener.Listener+ dataCleaner *cleaner.DataCleaner+ heartbeatRunner *heartbeat.Runner+ sampleProjectRunner *sampleprojectinstancerunner.Runner+ runnerWG sync.WaitGroupwebhookManager *webhook.ManageriamManager *iam.ManagersampleInstanceManager *sampleinstance.Manager+ sampleProjectManager *sampleprojectinstance.ManagerlicenseService *enterprise.LicenseService@@ -219,6 +223,15 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {productMetrics = productmetrics.New(stores, s.licenseService)}s.schemaSyncer = schemasync.NewSyncer(stores, s.dbFactory, s.licenseService, productMetrics)+ if profile.SaaS {+ s.sampleProjectManager = sampleprojectinstance.NewManagerFromURL(+ stores,+ profile.SampleProjectInstancePgURL,+ s.schemaSyncer,+ sampleprojectinstance.ManagerOptions{ReplicaID: profile.ReplicaID},+ )+ s.sampleProjectRunner = sampleprojectinstancerunner.NewRunner(s.sampleProjectManager)+ }s.approvalRunner = review.NewRunner(stores, s.bus, s.webhookManager, s.licenseService)s.taskScheduler = taskrun.NewScheduler(stores, s.bus, s.webhookManager, s.licenseService, profile, productMetrics)@@ -243,7 +256,7 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {stripeWebhookHandler := stripeapi.NewWebhookHandler(s.store, s.licenseService, profile.StripeWebhookSecret)- internalMCPHandler, err := configureGrpcRouters(ctx, s.echoServer, s.store, sheetManager, s.dbFactory, s.licenseService, s.profile, s.bus, s.schemaSyncer, s.webhookManager, s.iamManager, secret, s.sampleInstanceManager)+ internalMCPHandler, err := configureGrpcRouters(ctx, s.echoServer, s.store, sheetManager, s.dbFactory, s.licenseService, s.profile, s.bus, s.schemaSyncer, s.webhookManager, s.iamManager, secret, s.sampleInstanceManager, s.sampleProjectManager)if err != nil {return nil, errors.Wrapf(err, "failed to configure gRPC routers")}@@ -278,6 +291,11 @@ func (s *Server) Run(ctx context.Context, port int) error {s.runnerWG.Add(1)go s.heartbeatRunner.Run(ctx, &s.runnerWG)+ if s.sampleProjectRunner != nil {+ s.runnerWG.Add(1)+ go s.sampleProjectRunner.Run(ctx, &s.runnerWG)+ }+s.runnerWG.Add(1)go s.notifyListener.Run(ctx, &s.runnerWG)diff --git a/backend/store/sample_project_instance.go b/backend/store/sample_project_instance.gonew file mode 100644index 0000000000..f4b6a868ef--- /dev/null+++ b/backend/store/sample_project_instance.go@@ -0,0 +1,444 @@+package store++import (+ "context"+ "database/sql"+ "time"++ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/common"+)++// SampleProjectInstanceMessage is the control-plane record for a sample+// Project Instance. It deliberately does not reference Bytebase metadata.+type SampleProjectInstanceMessage struct {+ WorkspaceID string+ ProjectID string+ InstanceID string+ DBName string+ RoleName string+ ReplicaID string+ CreatedAt time.Time+ ExpiresAt *time.Time+ DeletedAt *time.Time+}++// SampleProjectInstanceTx owns a cleanup-record transaction while physical+// cleanup runs. Preparation uses short Store operations instead.+type SampleProjectInstanceTx struct {+ tx *sql.Tx+ workspace string+ project string+ instance string+ replica string+}++// GetSampleProjectInstance returns the independent lifecycle record for a+// workspace without locking it.+func (s *Store) GetSampleProjectInstance(ctx context.Context, workspaceID string) (*SampleProjectInstanceMessage, error) {+ message, err := scanSampleProjectInstance(s.GetDB().QueryRowContext(ctx, `+ SELECT workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ FROM sample_project_instance+ WHERE workspace = $1+ `, workspaceID))+ if errors.Is(err, sql.ErrNoRows) {+ return nil, nil+ }+ if err != nil {+ return nil, errors.Wrap(err, "failed to get sample Project Instance")+ }+ return message, nil+}++// ReserveSampleProjectInstance consumes a workspace's lifetime entitlement.+// It commits before a subsequent lifecycle operation locks the reservation.+// It returns whether this call created the reservation.+func (s *Store) ReserveSampleProjectInstance(ctx context.Context, create *SampleProjectInstanceMessage) (*SampleProjectInstanceMessage, bool, error) {+ tx, err := s.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, false, errors.Wrap(err, "failed to begin sample Project Instance reservation transaction")+ }+ defer tx.Rollback()++ var deleted bool+ if err := tx.QueryRowContext(ctx, `+ SELECT deleted+ FROM workspace+ WHERE resource_id = $1+ FOR UPDATE+ `, create.WorkspaceID).Scan(&deleted); err != nil {+ if errors.Is(err, sql.ErrNoRows) {+ return nil, false, common.Errorf(common.NotFound, "workspace %s not found", create.WorkspaceID)+ }+ return nil, false, errors.Wrapf(err, "failed to lock workspace %s", create.WorkspaceID)+ }+ if deleted {+ return nil, false, common.Errorf(common.NotFound, "workspace %s is deleted", create.WorkspaceID)+ }++ existing, err := scanSampleProjectInstance(tx.QueryRowContext(ctx, `+ SELECT workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ FROM sample_project_instance+ WHERE workspace = $1+ `, create.WorkspaceID))+ if err == nil {+ if err := tx.Commit(); err != nil {+ return nil, false, errors.Wrap(err, "failed to commit sample Project Instance reservation lookup")+ }+ return existing, false, nil+ }+ if !errors.Is(err, sql.ErrNoRows) {+ return nil, false, errors.Wrap(err, "failed to inspect sample Project Instance reservation")+ }++ reserved, created, err := insertSampleProjectInstance(ctx, tx, create)+ if err != nil {+ return nil, false, err+ }+ if err := tx.Commit(); err != nil {+ return nil, false, errors.Wrap(err, "failed to commit sample Project Instance reservation")+ }+ if !created {+ reserved, err = s.GetSampleProjectInstance(ctx, create.WorkspaceID)+ if err != nil {+ return nil, false, err+ }+ if reserved == nil {+ return nil, false, errors.Errorf("sample Project Instance reservation for workspace %s disappeared", create.WorkspaceID)+ }+ }+ return reserved, created, nil+}++// ClaimSampleProjectInstance transfers a pending reservation to replicaID when+// the caller observed its exact current attempt. A replica may retry its own+// expired attempt; another replica must also observe that the owner heartbeat+// is stale or absent. The returned reservation has the new attempt timestamp.+func (s *Store) ClaimSampleProjectInstance(+ ctx context.Context,+ workspaceID, instanceID string,+ observedCreatedAt time.Time,+ replicaID string,+ attemptAge, heartbeatStaleness time.Duration,+) (*SampleProjectInstanceMessage, bool, error) {+ message, err := scanSampleProjectInstance(s.GetDB().QueryRowContext(ctx, `+ UPDATE sample_project_instance+ SET replica_id = $1,+ created_at = now()+ WHERE workspace = $2+ AND instance = $3+ AND created_at = $4+ AND expires_at IS NULL+ AND deleted_at IS NULL+ AND created_at <= now() - $5::INTERVAL+ AND (+ replica_id = $1+ OR NOT EXISTS (+ SELECT 1+ FROM replica_heartbeat+ WHERE replica_id = sample_project_instance.replica_id+ AND last_heartbeat >= now() - $6::INTERVAL+ )+ )+ RETURNING workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ `, replicaID, workspaceID, instanceID, observedCreatedAt, attemptAge.String(), heartbeatStaleness.String()))+ if errors.Is(err, sql.ErrNoRows) {+ return nil, false, nil+ }+ if err != nil {+ return nil, false, errors.Wrap(err, "failed to claim sample Project Instance reservation")+ }+ return message, true, nil+}++// ActivateSampleProjectInstance sets a pending reservation's immutable+// expiration while it is still owned by replicaID. It locks the lifecycle+// record before its Project and workspace, preserving child-to-parent order.+// A false result means another worker changed ownership or lifecycle state.+func (s *Store) ActivateSampleProjectInstance(+ ctx context.Context,+ workspaceID, instanceID, replicaID string,+ expiresAt time.Time,+) (bool, error) {+ tx, err := s.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return false, errors.Wrap(err, "failed to begin sample Project Instance activation transaction")+ }+ defer tx.Rollback()++ message, err := scanSampleProjectInstance(tx.QueryRowContext(ctx, `+ SELECT workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ FROM sample_project_instance+ WHERE workspace = $1+ AND instance = $2+ AND replica_id = $3+ AND expires_at IS NULL+ AND deleted_at IS NULL+ FOR UPDATE+ `, workspaceID, instanceID, replicaID))+ if errors.Is(err, sql.ErrNoRows) {+ if err := tx.Commit(); err != nil {+ return false, errors.Wrap(err, "failed to commit unchanged sample Project Instance activation")+ }+ return false, nil+ }+ if err != nil {+ return false, errors.Wrap(err, "failed to lock sample Project Instance activation")+ }++ var projectDeleted bool+ if err := tx.QueryRowContext(ctx, `+ SELECT deleted+ FROM project+ WHERE resource_id = $1 AND workspace = $2+ FOR UPDATE+ `, message.ProjectID, message.WorkspaceID).Scan(&projectDeleted); err != nil {+ if errors.Is(err, sql.ErrNoRows) {+ return false, common.Errorf(common.NotFound, "project %s not found", message.ProjectID)+ }+ return false, errors.Wrapf(err, "failed to lock project %s for sample Project Instance activation", message.ProjectID)+ }+ if projectDeleted {+ return false, common.Errorf(common.NotFound, "project %s is deleted", message.ProjectID)+ }++ var workspaceDeleted bool+ if err := tx.QueryRowContext(ctx, `+ SELECT deleted+ FROM workspace+ WHERE resource_id = $1+ FOR UPDATE+ `, message.WorkspaceID).Scan(&workspaceDeleted); err != nil {+ if errors.Is(err, sql.ErrNoRows) {+ return false, common.Errorf(common.NotFound, "workspace %s not found", message.WorkspaceID)+ }+ return false, errors.Wrapf(err, "failed to lock workspace %s for sample Project Instance activation", message.WorkspaceID)+ }+ if workspaceDeleted {+ return false, common.Errorf(common.NotFound, "workspace %s is deleted", message.WorkspaceID)+ }++ result, err := tx.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET expires_at = $1+ WHERE workspace = $2+ AND instance = $3+ AND replica_id = $4+ AND expires_at IS NULL+ AND deleted_at IS NULL+ `, expiresAt, workspaceID, instanceID, replicaID)+ if err != nil {+ return false, errors.Wrap(err, "failed to activate sample Project Instance")+ }+ rows, err := result.RowsAffected()+ if err != nil {+ return false, errors.Wrap(err, "failed to inspect sample Project Instance activation")+ }+ if err := tx.Commit(); err != nil {+ return false, errors.Wrap(err, "failed to commit sample Project Instance activation")+ }+ return rows == 1, nil+}++// DeletePendingSampleProjectInstance removes a pending reservation only if it+// is still owned by replicaID. A false result means it was superseded or has+// already transitioned to another lifecycle state.+func (s *Store) DeletePendingSampleProjectInstance(ctx context.Context, workspaceID, instanceID, replicaID string) (bool, error) {+ result, err := s.GetDB().ExecContext(ctx, `+ DELETE FROM sample_project_instance+ WHERE workspace = $1+ AND instance = $2+ AND replica_id = $3+ AND expires_at IS NULL+ AND deleted_at IS NULL+ `, workspaceID, instanceID, replicaID)+ if err != nil {+ return false, errors.Wrap(err, "failed to delete pending sample Project Instance reservation")+ }+ rows, err := result.RowsAffected()+ if err != nil {+ return false, errors.Wrap(err, "failed to inspect pending sample Project Instance reservation deletion")+ }+ return rows == 1, nil+}++// MarkDeleted marks an activated reservation as physically deleted.+func (tx *SampleProjectInstanceTx) MarkDeleted(ctx context.Context, deletedAt time.Time) error {+ result, err := tx.tx.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET deleted_at = $1+ WHERE workspace = $2+ AND instance = $3+ AND replica_id = $4+ AND expires_at IS NOT NULL+ AND deleted_at IS NULL+ `, deletedAt, tx.workspace, tx.instance, tx.replica)+ if err != nil {+ return errors.Wrap(err, "failed to mark sample Project Instance deleted")+ }+ rows, err := result.RowsAffected()+ if err != nil {+ return errors.Wrap(err, "failed to inspect sample Project Instance deletion update")+ }+ if rows != 1 {+ return errors.Errorf("sample Project Instance %s cannot be marked deleted", tx.workspace)+ }+ return nil+}++// DeleteReservation removes an unactivated reservation after failed+// provisioning.+func (tx *SampleProjectInstanceTx) DeleteReservation(ctx context.Context) error {+ result, err := tx.tx.ExecContext(ctx, `+ DELETE FROM sample_project_instance+ WHERE workspace = $1+ AND instance = $2+ AND replica_id = $3+ AND expires_at IS NULL+ AND deleted_at IS NULL+ `, tx.workspace, tx.instance, tx.replica)+ if err != nil {+ return errors.Wrap(err, "failed to delete sample Project Instance reservation")+ }+ rows, err := result.RowsAffected()+ if err != nil {+ return errors.Wrap(err, "failed to inspect sample Project Instance reservation deletion")+ }+ if rows != 1 {+ return errors.Errorf("sample Project Instance %s cannot be deleted", tx.workspace)+ }+ return nil+}++// CountSampleProjectInstancesForCleanup reports eligible expired or stale+// reservations without claiming them. It is used only for a validation-failure+// cleanup log.+func (s *Store) CountSampleProjectInstancesForCleanup(ctx context.Context, now, staleBefore time.Time) (int, error) {+ var count int+ if err := s.GetDB().QueryRowContext(ctx, `+ SELECT COUNT(*)+ FROM sample_project_instance+ WHERE deleted_at IS NULL+ AND (+ (expires_at IS NOT NULL AND expires_at <= $1)+ OR (expires_at IS NULL AND created_at <= $2)+ )+ `, now, staleBefore).Scan(&count); err != nil {+ return 0, errors.Wrap(err, "failed to count sample Project Instance cleanup records")+ }+ return count, nil+}++// SampleProjectInstanceCleanupResult reports the outcome of one cleanup+// attempt. CallbackErr does not roll back the transaction: the caller advances+// AfterWorkspace and may report the callback error after attempting later+// records.+type SampleProjectInstanceCleanupResult struct {+ WorkspaceID string+ Found bool+ CallbackErr error+}++// WithLockedSampleProjectInstanceCleanupRecord locks one expired or stale+// reservation after afterWorkspace in workspace order. The row lock is held+// only while callback runs. A successful callback updates the lifecycle record;+// a failed callback leaves it unchanged after committing and returns its error+// in the result so callers can continue from the returned workspace.+func (s *Store) WithLockedSampleProjectInstanceCleanupRecord(+ ctx context.Context,+ now time.Time,+ staleBefore time.Time,+ afterWorkspace string,+ callback func(context.Context, *SampleProjectInstanceTx, *SampleProjectInstanceMessage) error,+) (*SampleProjectInstanceCleanupResult, error) {+ tx, err := s.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, errors.Wrap(err, "failed to begin sample Project Instance cleanup transaction")+ }+ defer tx.Rollback()++ message, err := scanSampleProjectInstance(tx.QueryRowContext(ctx, `+ SELECT workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ FROM sample_project_instance+ WHERE deleted_at IS NULL+ AND (+ (expires_at IS NOT NULL AND expires_at <= $1)+ OR (expires_at IS NULL AND created_at <= $2)+ )+ AND workspace > $3+ ORDER BY workspace+ FOR UPDATE SKIP LOCKED+ LIMIT 1+ `, now, staleBefore, afterWorkspace))+ if errors.Is(err, sql.ErrNoRows) {+ if err := tx.Commit(); err != nil {+ return nil, errors.Wrap(err, "failed to commit empty sample Project Instance cleanup transaction")+ }+ return &SampleProjectInstanceCleanupResult{}, nil+ }+ if err != nil {+ return nil, errors.Wrap(err, "failed to lock sample Project Instance cleanup record")+ }++ result := &SampleProjectInstanceCleanupResult{+ WorkspaceID: message.WorkspaceID,+ Found: true,+ }+ recordTx := &SampleProjectInstanceTx{tx: tx, workspace: message.WorkspaceID, project: message.ProjectID, instance: message.InstanceID, replica: message.ReplicaID}+ if err := callback(ctx, recordTx, message); err != nil {+ result.CallbackErr = err+ } else if message.ExpiresAt == nil {+ if err := recordTx.DeleteReservation(ctx); err != nil {+ return nil, err+ }+ } else if err := recordTx.MarkDeleted(ctx, now); err != nil {+ return nil, err+ }+ if err := tx.Commit(); err != nil {+ return nil, errors.Wrap(err, "failed to commit sample Project Instance cleanup transaction")+ }+ return result, nil+}++func insertSampleProjectInstance(ctx context.Context, tx *sql.Tx, create *SampleProjectInstanceMessage) (*SampleProjectInstanceMessage, bool, error) {+ row := tx.QueryRowContext(ctx, `+ INSERT INTO sample_project_instance (workspace, project, instance, db_name, role_name, replica_id)+ VALUES ($1, $2, $3, $4, $5, $6)+ ON CONFLICT (workspace) DO NOTHING+ RETURNING workspace, project, instance, db_name, role_name, replica_id,+ created_at, expires_at, deleted_at+ `, create.WorkspaceID, create.ProjectID, create.InstanceID, create.DBName, create.RoleName, create.ReplicaID)+ message, err := scanSampleProjectInstance(row)+ if errors.Is(err, sql.ErrNoRows) {+ return nil, false, nil+ }+ return message, err == nil, err+}++type sampleProjectInstanceScanner interface {+ Scan(...any) error+}++func scanSampleProjectInstance(scanner sampleProjectInstanceScanner) (*SampleProjectInstanceMessage, error) {+ message := &SampleProjectInstanceMessage{}+ if err := scanner.Scan(+ &message.WorkspaceID,+ &message.ProjectID,+ &message.InstanceID,+ &message.DBName,+ &message.RoleName,+ &message.ReplicaID,+ &message.CreatedAt,+ &message.ExpiresAt,+ &message.DeletedAt,+ ); err != nil {+ return nil, err+ }+ return message, nil+}diff --git a/backend/store/sample_project_instance_test.go b/backend/store/sample_project_instance_test.gonew file mode 100644index 0000000000..0acb72366f--- /dev/null+++ b/backend/store/sample_project_instance_test.go@@ -0,0 +1,504 @@+package store_test++import (+ "context"+ "database/sql"+ "errors"+ "fmt"+ "testing"+ "time"++ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ "github.com/bytebase/bytebase/backend/migrator"+ "github.com/bytebase/bytebase/backend/store"+)++func newSampleProjectInstanceFixture(t *testing.T) (context.Context, *sql.DB, *store.Store) {+ t.Helper()+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)+ t.Cleanup(cancel)+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(context.Background()) })+ db := container.GetDB()+ require.NoError(t, migrator.MigrateSchema(ctx, db))+ _, err := db.ExecContext(ctx, `+ INSERT INTO workspace (resource_id) VALUES+ ('workspace-a'), ('workspace-b'), ('workspace-c'), ('workspace-d');+ INSERT INTO project (resource_id, workspace, name) VALUES+ ('project-workspace-a', 'workspace-a', 'Project A'),+ ('project-workspace-b', 'workspace-b', 'Project B'),+ ('project-workspace-c', 'workspace-c', 'Project C'),+ ('project-workspace-d', 'workspace-d', 'Project D');+ `)+ require.NoError(t, err)+ pgURL := fmt.Sprintf(+ "host=%s port=%s user=postgres password=root-password database=postgres",+ container.GetHost(), container.GetPort(),+ )+ s, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, s.Close()) })+ return ctx, db, s+}++func TestReserveSampleProjectInstanceSerializesWorkspaceEntitlement(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ lockTx, err := db.BeginTx(ctx, nil)+ require.NoError(t, err)+ defer lockTx.Rollback()+ var workspace string+ require.NoError(t, lockTx.QueryRowContext(ctx, `+ SELECT resource_id FROM workspace WHERE resource_id = 'workspace-a' FOR UPDATE+ `).Scan(&workspace))++ type result struct {+ created bool+ err error+ }+ results := make(chan result, 2)+ for range 2 {+ go func() {+ _, created, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ results <- result{created: created, err: err}+ }()+ }+ require.Eventually(t, func() bool {+ var waiting int+ err := db.QueryRowContext(ctx, `+ SELECT COUNT(*)+ FROM pg_stat_activity+ WHERE wait_event_type = 'Lock'+ AND query LIKE '%SELECT deleted%'+ `).Scan(&waiting)+ return err == nil && waiting == 2+ }, 5*time.Second, 10*time.Millisecond)+ require.NoError(t, lockTx.Commit())++ var successes, created, existing int+ for range 2 {+ result := <-results+ if result.err == nil {+ successes+++ if result.created {+ created+++ } else {+ existing+++ }+ }+ }+ require.Equal(t, 2, successes)+ require.Equal(t, 1, created)+ require.Equal(t, 1, existing)+}++func TestReserveSampleProjectInstanceRejectsMissingAndDeletedWorkspace(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ _, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("missing"))+ require.Error(t, err)+ require.NoError(t, db.QueryRowContext(ctx, `+ UPDATE workspace SET deleted = TRUE WHERE resource_id = 'workspace-b' RETURNING resource_id+ `).Scan(new(string)))+ _, _, err = s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-b"))+ require.Error(t, err)+}++func TestReserveSampleProjectInstanceRejectsOtherUniqueCollisions(t *testing.T) {+ ctx, _, s := newSampleProjectInstanceFixture(t)+ created, wasCreated, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, wasCreated)++ conflicting := sampleProjectInstance("workspace-b")+ conflicting.InstanceID = created.InstanceID+ _, wasCreated, err = s.ReserveSampleProjectInstance(ctx, conflicting)+ require.Error(t, err)+ require.False(t, wasCreated)+}++func TestActivateSampleProjectInstanceAppliesImmutableLifecycleState(t *testing.T) {+ ctx, _, s := newSampleProjectInstanceFixture(t)+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ expiresAt := time.Date(2026, time.August, 24, 9, 0, 0, 0, time.UTC)+ activateSampleProjectInstance(ctx, t, s, reservation, expiresAt)+ activated, err := s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, expiresAt.Add(time.Hour))+ require.NoError(t, err)+ require.False(t, activated)+}++func TestActivateSampleProjectInstanceSerializesWithWorkspaceDeletion(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ deleteTx, err := db.BeginTx(ctx, nil)+ require.NoError(t, err)+ deletionCommitted := false+ defer func() {+ if !deletionCommitted {+ _ = deleteTx.Rollback()+ }+ }()+ _, err = deleteTx.ExecContext(ctx, "UPDATE workspace SET deleted = TRUE WHERE resource_id = 'workspace-a'")+ require.NoError(t, err)++ result := make(chan error, 1)+ go func() {+ _, err := s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, time.Now().Add(time.Hour))+ result <- err+ }()+ require.Eventually(t, func() bool {+ var waiting bool+ err := db.QueryRowContext(ctx, `+ SELECT EXISTS (+ SELECT 1 FROM pg_stat_activity+ WHERE wait_event_type = 'Lock'+ AND query LIKE '%SELECT deleted%FROM workspace%FOR UPDATE%'+ )+ `).Scan(&waiting)+ return err == nil && waiting+ }, 5*time.Second, 10*time.Millisecond)+ require.NoError(t, deleteTx.Commit())+ deletionCommitted = true+ require.Equal(t, common.NotFound, common.ErrorCode(<-result))+}++func TestActivateSampleProjectInstanceSerializesWithProjectArchive(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ archiveTx, err := db.BeginTx(ctx, nil)+ require.NoError(t, err)+ archiveCommitted := false+ defer func() {+ if !archiveCommitted {+ _ = archiveTx.Rollback()+ }+ }()+ _, err = archiveTx.ExecContext(ctx, "UPDATE project SET deleted = TRUE WHERE resource_id = 'project-workspace-a' AND workspace = 'workspace-a'")+ require.NoError(t, err)++ result := make(chan error, 1)+ go func() {+ _, err := s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, time.Now().Add(time.Hour))+ result <- err+ }()+ require.Eventually(t, func() bool {+ var waiting bool+ err := db.QueryRowContext(ctx, `+ SELECT EXISTS (+ SELECT 1 FROM pg_stat_activity+ WHERE wait_event_type = 'Lock'+ AND query LIKE '%SELECT deleted%FROM project%FOR UPDATE%'+ )+ `).Scan(&waiting)+ return err == nil && waiting+ }, 5*time.Second, 10*time.Millisecond)+ require.NoError(t, archiveTx.Commit())+ archiveCommitted = true+ require.Equal(t, common.NotFound, common.ErrorCode(<-result))+}++func TestActivateSampleProjectInstanceRejectsMissingAndDeletedProject(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ expiresAt := time.Date(2026, time.August, 24, 9, 0, 0, 0, time.UTC)++ missing := sampleProjectInstance("workspace-a")+ missing.ProjectID = "missing"+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, missing)+ require.NoError(t, err)+ _, err = s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, expiresAt)+ require.Equal(t, common.NotFound, common.ErrorCode(err))++ reservation, _, err = s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-b"))+ require.NoError(t, err)+ _, err = db.ExecContext(ctx, "UPDATE project SET deleted = TRUE WHERE resource_id = 'project-workspace-b' AND workspace = 'workspace-b'")+ require.NoError(t, err)+ _, err = s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, expiresAt)+ require.Equal(t, common.NotFound, common.ErrorCode(err))+}++func TestCountSampleProjectInstancesForCleanupIncludesStaleReservation(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ now := time.Date(2026, time.August, 17, 9, 0, 0, 0, time.UTC)+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ _, err = db.ExecContext(ctx, "UPDATE sample_project_instance SET created_at = $1 WHERE workspace = $2 AND instance = $3", now, reservation.WorkspaceID, reservation.InstanceID)+ require.NoError(t, err)+ count, err := s.CountSampleProjectInstancesForCleanup(ctx, now.Add(time.Hour), now.Add(time.Minute))+ require.NoError(t, err)+ require.Equal(t, 1, count)+}++func TestWithLockedSampleProjectInstanceCleanupRecordIteratesAfterCallbackError(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ now := time.Date(2026, time.August, 17, 9, 0, 0, 0, time.UTC)+ for _, workspace := range []string{"workspace-a", "workspace-b", "workspace-d"} {+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance(workspace))+ require.NoError(t, err)+ if workspace == "workspace-b" {+ activateSampleProjectInstance(ctx, t, s, reservation, now.Add(time.Second))+ } else {+ activateSampleProjectInstance(ctx, t, s, reservation, now.Add(-time.Second))+ }+ }+ _, err := db.ExecContext(ctx, `+ INSERT INTO sample_project_instance (workspace, project, instance, db_name, role_name, replica_id, created_at)+ VALUES ('workspace-c', 'project-workspace-c', 'instance-workspace-c', 'database-workspace-c', 'role-workspace-c', 'replica-a', $1)+ `, now.Add(-time.Hour))+ require.NoError(t, err)++ var processed []string+ var callbackErr error+ afterWorkspace := ""+ for {+ result, err := s.WithLockedSampleProjectInstanceCleanupRecord(ctx, now, now.Add(-time.Hour), afterWorkspace, func(_ context.Context, _ *store.SampleProjectInstanceTx, message *store.SampleProjectInstanceMessage) error {+ processed = append(processed, message.WorkspaceID)+ if message.WorkspaceID == "workspace-a" {+ return errors.New("physical cleanup failed")+ }+ return nil+ })+ require.NoError(t, err)+ if !result.Found {+ break+ }+ afterWorkspace = result.WorkspaceID+ callbackErr = errors.Join(callbackErr, result.CallbackErr)+ }+ require.Error(t, callbackErr)+ require.Equal(t, []string{"workspace-a", "workspace-c", "workspace-d"}, processed)++ reservation, err := s.GetSampleProjectInstance(ctx, "workspace-a")+ require.NoError(t, err)+ require.Nil(t, reservation.DeletedAt)+ reservation, err = s.GetSampleProjectInstance(ctx, "workspace-b")+ require.NoError(t, err)+ require.Nil(t, reservation.DeletedAt)+ reservation, err = s.GetSampleProjectInstance(ctx, "workspace-c")+ require.NoError(t, err)+ require.Nil(t, reservation)+ reservation, err = s.GetSampleProjectInstance(ctx, "workspace-d")+ require.NoError(t, err)+ require.Equal(t, &now, reservation.DeletedAt)++ result, err := s.WithLockedSampleProjectInstanceCleanupRecord(ctx, now, now.Add(-time.Hour), "", func(_ context.Context, _ *store.SampleProjectInstanceTx, message *store.SampleProjectInstanceMessage) error {+ processed = append(processed, message.WorkspaceID)+ return nil+ })+ require.NoError(t, err)+ require.True(t, result.Found)+ require.Equal(t, "workspace-a", result.WorkspaceID)+ require.NoError(t, result.CallbackErr)+}++func TestWithLockedSampleProjectInstanceCleanupRecordLocksOnlySelectedRow(t *testing.T) {+ ctx, _, s := newSampleProjectInstanceFixture(t)+ now := time.Date(2026, time.August, 17, 9, 0, 0, 0, time.UTC)+ for _, workspace := range []string{"workspace-a", "workspace-b"} {+ reservation, _, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance(workspace))+ require.NoError(t, err)+ activateSampleProjectInstance(ctx, t, s, reservation, now.Add(-time.Second))+ }++ started := make(chan struct{})+ release := make(chan struct{})+ firstResult := make(chan *store.SampleProjectInstanceCleanupResult, 1)+ firstErr := make(chan error, 1)+ go func() {+ result, err := s.WithLockedSampleProjectInstanceCleanupRecord(ctx, now, now.Add(-time.Hour), "", func(context.Context, *store.SampleProjectInstanceTx, *store.SampleProjectInstanceMessage) error {+ select {+ case <-started:+ default:+ close(started)+ }+ <-release+ return nil+ })+ firstResult <- result+ firstErr <- err+ }()+ <-started++ result, err := s.WithLockedSampleProjectInstanceCleanupRecord(ctx, now, now.Add(-time.Hour), "", func(_ context.Context, _ *store.SampleProjectInstanceTx, message *store.SampleProjectInstanceMessage) error {+ require.Equal(t, "workspace-b", message.WorkspaceID)+ return nil+ })+ require.NoError(t, err)+ require.True(t, result.Found)+ require.Equal(t, "workspace-b", result.WorkspaceID)++ close(release)+ require.NoError(t, <-firstErr)+ require.Equal(t, "workspace-a", (<-firstResult).WorkspaceID)+}++func sampleProjectInstance(workspace string) *store.SampleProjectInstanceMessage {+ return &store.SampleProjectInstanceMessage{+ WorkspaceID: workspace,+ ProjectID: "project-" + workspace,+ InstanceID: "instance-" + workspace,+ DBName: "database-" + workspace,+ RoleName: "role-" + workspace,+ ReplicaID: "replica-a",+ }+}++func activateSampleProjectInstance(ctx context.Context, t *testing.T, s *store.Store, reservation *store.SampleProjectInstanceMessage, expiresAt time.Time) {+ t.Helper()+ activated, err := s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.ReplicaID, expiresAt)+ require.NoError(t, err)+ require.True(t, activated)+}++func TestReserveSampleProjectInstanceConsumesWorkspaceEntitlement(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ created, wasCreated, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, wasCreated)+ require.Equal(t, "workspace-a", created.WorkspaceID)+ require.False(t, created.CreatedAt.IsZero())+ require.Nil(t, created.ExpiresAt)+ require.Nil(t, created.DeletedAt)++ existing, wasCreated, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.False(t, wasCreated)+ require.Equal(t, created, existing)++ var count int+ require.NoError(t, db.QueryRowContext(ctx, `+ SELECT COUNT(*) FROM sample_project_instance WHERE workspace = 'workspace-a'+ `).Scan(&count))+ require.Equal(t, 1, count)+}++func TestClaimSampleProjectInstanceRequiresExpiredAttempt(t *testing.T) {+ ctx, _, s := newSampleProjectInstanceFixture(t)+ reservation, created, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, created)++ claimed, ok, err := s.ClaimSampleProjectInstance(+ ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt,+ "replica-b", time.Hour, time.Minute,+ )+ require.NoError(t, err)+ require.False(t, ok)+ require.Nil(t, claimed)++ current, err := s.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ require.NoError(t, err)+ require.Equal(t, "replica-a", current.ReplicaID)+}++func TestClaimSampleProjectInstanceAllowsOneStaleOwnerTakeover(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ reservation, created, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, created)+ _, err = db.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = now() - INTERVAL '4 minutes'+ WHERE workspace = $1 AND instance = $2+ `, reservation.WorkspaceID, reservation.InstanceID)+ require.NoError(t, err)+ reservation, err = s.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ require.NoError(t, err)++ type result struct {+ owner string+ claimed bool+ err error+ }+ results := make(chan result, 2)+ for _, owner := range []string{"replica-b", "replica-c"} {+ go func() {+ _, claimed, err := s.ClaimSampleProjectInstance(+ ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt,+ owner, 3*time.Minute, time.Minute,+ )+ results <- result{owner: owner, claimed: claimed, err: err}+ }()+ }++ var winner string+ for range 2 {+ result := <-results+ require.NoError(t, result.err)+ if result.claimed {+ require.Empty(t, winner)+ winner = result.owner+ }+ }+ require.NotEmpty(t, winner)+ current, err := s.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ require.NoError(t, err)+ require.Equal(t, winner, current.ReplicaID)+ require.True(t, current.CreatedAt.After(reservation.CreatedAt))+}++func TestClaimSampleProjectInstanceRequiresStaleOtherOwnerButAllowsSelfRetry(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ reservation, created, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, created)+ _, err = db.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = now() - INTERVAL '4 minutes'+ WHERE workspace = $1 AND instance = $2+ `, reservation.WorkspaceID, reservation.InstanceID)+ require.NoError(t, err)+ require.NoError(t, s.UpsertReplicaHeartbeat(ctx, reservation.ReplicaID))+ reservation, err = s.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ require.NoError(t, err)++ _, claimed, err := s.ClaimSampleProjectInstance(+ ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt,+ "replica-b", 3*time.Minute, time.Minute,+ )+ require.NoError(t, err)+ require.False(t, claimed)++ claimedReservation, claimed, err := s.ClaimSampleProjectInstance(+ ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt,+ reservation.ReplicaID, 3*time.Minute, time.Minute,+ )+ require.NoError(t, err)+ require.True(t, claimed)+ require.Equal(t, reservation.ReplicaID, claimedReservation.ReplicaID)+}++func TestOwnedSampleProjectInstanceTransitionsFenceFormerOwner(t *testing.T) {+ ctx, db, s := newSampleProjectInstanceFixture(t)+ reservation, created, err := s.ReserveSampleProjectInstance(ctx, sampleProjectInstance("workspace-a"))+ require.NoError(t, err)+ require.True(t, created)+ _, err = db.ExecContext(ctx, `+ UPDATE sample_project_instance+ SET created_at = now() - INTERVAL '4 minutes'+ WHERE workspace = $1 AND instance = $2+ `, reservation.WorkspaceID, reservation.InstanceID)+ require.NoError(t, err)+ reservation, err = s.GetSampleProjectInstance(ctx, reservation.WorkspaceID)+ require.NoError(t, err)+ _, claimed, err := s.ClaimSampleProjectInstance(+ ctx, reservation.WorkspaceID, reservation.InstanceID, reservation.CreatedAt,+ "replica-b", 3*time.Minute, time.Minute,+ )+ require.NoError(t, err)+ require.True(t, claimed)++ activated, err := s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, "replica-a", time.Now().Add(time.Hour))+ require.NoError(t, err)+ require.False(t, activated)+ deleted, err := s.DeletePendingSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, "replica-a")+ require.NoError(t, err)+ require.False(t, deleted)++ activated, err = s.ActivateSampleProjectInstance(ctx, reservation.WorkspaceID, reservation.InstanceID, "replica-b", time.Now().Add(time.Hour))+ require.NoError(t, err)+ require.True(t, activated)+}diff --git a/docs/adr/0004-sample-project-instance-lifecycle.md b/docs/adr/0004-sample-project-instance-lifecycle.mdnew file mode 100644index 0000000000..42d6a28675--- /dev/null+++ b/docs/adr/0004-sample-project-instance-lifecycle.md@@ -0,0 +1,15 @@+# Manage the Bytebase Cloud Sample Project Instance lifecycle++Bytebase Cloud needs a one-click database for product evaluation without requiring users to bring infrastructure. Cloud SQL provides only a restricted `postgres` administrator, while users need to own seeded application objects to exercise later DDL, and PostgreSQL does not provide a dependable database creation timestamp from which to derive expiration.++A **Sample Project Instance** is the temporary-evaluation aggregate prepared for one selected Project: one Bytebase Project Instance plus one dedicated database and non-superuser login role on Bytebase's shared, dedicated Cloud SQL PostgreSQL instance. Each Workspace receives one lifetime entitlement to prepare this aggregate. The aggregate is prepared synchronously so it is ready for use when returned.++The Cloud SQL control-plane user owns each physical database so it can reliably remove it, while the sample role owns every seeded and subsequently created application object. A new database denies connections until Bytebase has revoked default `PUBLIC` access and granted access to its dedicated role. Bytebase seeds directly as that role rather than cloning a template because cloned objects retain the template owner's identity, which the restricted administrator cannot reliably transfer.++An independent control-plane record without foreign keys preserves the single-use Workspace entitlement, persisted random instance ID, and its derived database and role names without depending on ordinary Workspace, Project, Project Instance, or Database lifecycle records. The random instance ID deterministically derives the persisted names in the `bb_sample_*` namespace. That namespace and every reserved instance, database, and role name belong exclusively to this reservation, including when its entitlement record is retained after cleanup. Pending records also store their owning replica. Lifecycle state is derived solely from `created_at`, `expires_at`, and `deleted_at`; seven-day eligibility is immutable and begins only after provisioning and seeding, Project Instance registration, and initial Database discovery all succeed.++The Manager owns provisioning compensation and cleanup. It reserves and commits ownership before external work; it never holds a metadata transaction while provisioning or compensating. A pending attempt may be claimed only after its three-minute lifecycle window has elapsed. A different replica additionally requires the previous owner's heartbeat to be missing or stale for one minute; the same replica may retry its own expired attempt. A successful claim starts a fresh three-minute lifecycle window, so time spent waiting for the previous attempt does not consume the new owner's provisioning and compensation budget. Every activation and pending deletion is fenced by Workspace, instance ID, and replica ID, so a superseded worker cannot finalize. An internal runner performs cleanup at startup and then hourly on every replica. It scans eligible records in Workspace order, claims one record at a time with `FOR UPDATE SKIP LOCKED` and a Workspace cursor, and commits each physical cleanup attempt before moving to the next record. This limits each external attempt to its own row lock while allowing failed records to remain eligible later. Pending rows survive a cleanup failure or process crash, so a later Manager attempt can compensate using the reservation's deterministically derived names. Cleanup removes only the physical Cloud SQL databases and roles and retains Workspace, Project, Project Instance, and Database metadata. The entitlement remains consumed after cleanup; the design provides neither an entitlement reset nor a separate user-visible expired state.++We rejected asynchronous preparation because the shared infrastructure is already provisioned and measured role creation, database creation, direct seeding, and Database discovery fit within a bounded request. We also rejected user ownership of the database because PostgreSQL reserves database deletion for its owner or a true superuser, which Cloud SQL does not provide to customers.++Operational requirements are in [Sample Project Instance operations](../operations/sample-project-instance.md). Detailed API, configuration, persistence, concurrency, recovery, cleanup, testing, and scope decisions are specified in [BOT-58](https://linear.app/bytebase/issue/BOT-58).diff --git a/docs/operations/sample-project-instance.md b/docs/operations/sample-project-instance.mdnew file mode 100644index 0000000000..986849d693--- /dev/null+++ b/docs/operations/sample-project-instance.md@@ -0,0 +1,39 @@+# Operate Bytebase Cloud Sample Project Instances++Sample Project Instances are SaaS-only temporary-evaluation aggregates. Each aggregate has one Bytebase Project Instance and one dedicated database and login role on the shared, dedicated Cloud SQL PostgreSQL instance. A Workspace receives one lifetime entitlement. Do not provide reset tooling or expose a separate user-visible expired state.++## Configure the target++Set `SAMPLE_PROJECT_INSTANCE_PG_URL` on every SaaS replica to the same direct PostgreSQL password URL for the dedicated Cloud SQL instance. The URL must use `sslmode=verify-full`; `sslmode=require` is rejected because it encrypts the connection without authenticating the server.++- Supply the password in the URL. File indirection and hot credential rotation are not supported for this setting.+- Optionally supply `sslrootcert` pointing to a mounted PEM CA bundle. Bytebase resolves that PEM while loading the target configuration and copies it into the generated sample data source so later connections use the same trust anchor.+- Use a hostname in the URL that resolves to the Cloud SQL instance and matches the server certificate. `sslmode=verify-full` requires both CA trust and hostname verification; ensure every SaaS replica has DNS access to that hostname.+- Keep the value out of source control, shell history, diagnostic dumps, and application logs. Use the deployment secret mechanism and rotate by replacing the deployment configuration uniformly across replicas.+- The configured control-plane role requires `CREATEDB`, `CREATEROLE`, and membership in `pg_signal_backend`.+- Maintain the isolation baseline: revoke `PUBLIC` access from `postgres` and `template1`, deny connections to `template0`, and do not leave any connectable database with `PUBLIC` access except Cloud SQL's exact provider-managed `cloudsqladmin` database.+- Bytebase must not modify `cloudsqladmin`: Cloud SQL documents its corresponding system user as non-modifiable and excludes the database from `pg_dumpall` exports because customer tooling cannot access it. All customer-managed databases remain hardened. See [Cloud SQL SSL/TLS configuration](https://cloud.google.com/sql/docs/postgres/configure-ssl-instance), [Cloud SQL system users](https://cloud.google.com/sql/docs/postgres/users), and [Cloud SQL dump exports](https://cloud.google.com/sql/docs/postgres/import-export/import-export-dmp).++An absent or invalid target configuration must not block server startup. Preparation is unavailable until configuration and the full privilege and isolation baseline validation succeed. Cleanup uses a separate 10-second connectivity and capability preflight so a partial database cannot block its own cleanup by violating the provisioning baseline. Startup and hourly cleanup still report structured, redacted errors for outstanding lifecycle records.++## Provisioning and readiness++The service provisions a new dedicated role and creates its database with connections disabled. It revokes `PUBLIC` database access, grants access to the dedicated role, and only then enables connections before hardening the `public` schema and seeding as that role. It then registers the Project Instance and synchronously discovers its database. Seven-day eligibility starts only after all of those readiness steps succeed.++The independent control-plane record is the Workspace's lifetime entitlement fence. It persists a random instance ID, its owning replica, and the database and role names deterministically derived from it in the `bb_sample_*` namespace. That namespace and every persisted instance, database, and role name are exclusively reserved for the reservation, including retained entitlement records after cleanup. Its lifecycle state is derived only from `created_at`, `expires_at`, and `deleted_at`. It has no foreign keys so that normal deletion or retention of Workspace, Project, Project Instance, and Database metadata cannot erase the cleanup obligation or restore entitlement.++The Manager owns compensation. It commits the pending reservation before contacting the target, so a provisioning attempt never monopolizes a metadata connection. If another request sees a healthy owner it waits with bounded backoff. After the three-minute lifecycle window, the same replica may retry its own attempt; a different replica may atomically take over only when the previous owner's heartbeat is stale or missing. A successful takeover receives a fresh three-minute lifecycle budget. The original owner cannot activate or delete after that takeover because those transitions are fenced by Workspace, instance ID, and replica ID. If preparation fails after reserving the entitlement, it removes partial Bytebase metadata and the physical resources allocated to that reservation, then removes the pending reservation when compensation succeeds. If compensation fails or the process crashes, the pending reservation remains and a later Manager preparation request or cleanup pass compensates using its deterministically derived names. Operators should investigate repeated reconciliation failures through redacted structured logs rather than editing entitlement records directly.++## Cleanup++Every replica runs cleanup once at startup and then hourly. Each pass scans eligible records in Workspace order, claiming one record at a time with `FOR UPDATE SKIP LOCKED` and a Workspace cursor. It releases that row lock after each physical cleanup attempt before claiming the next record, so overlapping scanners safely skip only records another scanner is actively attempting.++For an expired aggregate, cleanup fences the dedicated role with `NOLOGIN`, revokes its database access, terminates its sessions using the required `pg_signal_backend` capability, and waits for sessions to drain. Only then does it drop the database and finally the role. The cleanup record is marked complete only after physical removal succeeds; failures and crashes leave the expired row eligible for a later Manager pass without retaining a row lock between attempts.++Cleanup removes only the dedicated Cloud SQL database and role. It retains Bytebase Workspace, Project, Project Instance, and Database metadata, and it never resets the Workspace's lifetime entitlement.++## Logging and credential hygiene++Use structured logs to correlate lifecycle work by stable identifiers such as Workspace, Project, Project Instance, database, and role. Redact passwords, complete connection URLs, query parameters containing credentials, and other secret-bearing connection details. Do not copy credentials into tickets, dashboards, ad hoc scripts, or incident notes.++Treat the target URL and generated sample-role passwords as secrets. Limit access to deployment-secret administrators, avoid terminal output when validating configuration, and revoke or rotate infrastructure credentials through the deployment process rather than application-level hot reload.diff --git a/frontend/src/components/instance/CreateInstanceView.test.tsx b/frontend/src/components/instance/CreateInstanceView.test.tsxindex 5e67f91a69..14238618f8 100644--- a/frontend/src/components/instance/CreateInstanceView.test.tsx+++ b/frontend/src/components/instance/CreateInstanceView.test.tsx@@ -1,4 +1,5 @@import { act } from "react";+import { Code, ConnectError } from "@connectrpc/connect";import { createRoot } from "react-dom/client";import { beforeEach, describe, expect, test, vi } from "vitest";@@ -10,10 +11,16 @@ const mocks = vi.hoisted(() => ({useUnsavedChangesGuard: vi.fn(),onDismiss: vi.fn(),onCreated: vi.fn(),+ prepareSampleProjectInstance: vi.fn(),+ pushNotification: vi.fn(),+ isSaaSMode: false,+ instanceCountLimit: 10,+ activatedInstanceCount: 0,providerProps: undefined as Record<string, unknown> | undefined,instanceFormContext: {basicInfo: { engine: 0 },state: { isRequesting: false },+ setState: vi.fn(),valueChanged: false,},}));@@ -22,7 +29,27 @@ let CreateInstanceView: typeof import("./CreateInstanceView").CreateInstanceViewvi.mock("react-i18next", () => ({initReactI18next: { type: "3rdParty", init: () => {} },- useTranslation: () => ({ t: (key: string) => key }),+ useTranslation: () => ({+ t: (key: string, values?: { total?: number }) => {+ const translation =+ ({+ "instance.use-sample-instance":+ "Use sample instance (Available for 7 days)",+ "instance.preparing-sample-instance":+ "Preparing Sample Project Instance…",+ "instance.prepare-sample-instance-failed":+ "Failed to prepare Sample Project Instance.",+ "instance.sample-project-instance-description":+ "Use a Sample Project Instance to explore Bytebase with a ready-to-use database for 7 days.",+ "instance.sample-project-instance-title":+ "Try a Sample Project Instance",+ "subscription.usage.instance-count.title": "Instance quota reached",+ "subscription.usage.instance-count.runoutof":+ "You have reached the limit of {{total}} instances.",+ })[key] ?? key;+ return translation.replace("{{total}}", String(values?.total ?? ""));+ },+ }),}));vi.mock("@/hooks/useUnsavedChangesGuard", () => ({@@ -30,16 +57,23 @@ vi.mock("@/hooks/useUnsavedChangesGuard", () => ({}));vi.mock("@/stores/app", () => ({- useAppStore: {- getState: () => ({- instanceCountLimit: () => 10,- activatedInstanceCount: () => 0,- }),- },+ useAppStore: Object.assign(+ <T,>(selector: (state: Record<string, unknown>) => T) =>+ selector({+ isSaaSMode: () => mocks.isSaaSMode,+ prepareSampleProjectInstance: mocks.prepareSampleProjectInstance,+ }),+ {+ getState: () => ({+ instanceCountLimit: () => mocks.instanceCountLimit,+ activatedInstanceCount: () => mocks.activatedInstanceCount,+ }),+ }+ ),}));vi.mock("@/stores", () => ({- pushNotification: vi.fn(),+ pushNotification: mocks.pushNotification,}));vi.mock("@/components/instance", () => ({@@ -49,7 +83,14 @@ vi.mock("@/components/instance", () => ({InfoPanelContent: () => <div />,InstanceFormBody: () => <div data-testid="instance-form-body" />,InstanceFormButtons: ({ className }: { className?: string }) => (- <div data-testid="instance-form-buttons" className={className} />+ <button+ type="button"+ data-testid="instance-form-buttons"+ className={className}+ disabled={mocks.instanceFormContext.state.isRequesting}+ >+ Create+ </button>),InstanceFormProvider: ({children,@@ -77,8 +118,25 @@ vi.mock("@/components/instance", () => ({beforeEach(async () => {vi.clearAllMocks();+ mocks.isSaaSMode = false;+ mocks.instanceCountLimit = 10;+ mocks.activatedInstanceCount = 0;+ mocks.prepareSampleProjectInstance.mockResolvedValue({+ name: "projects/demo/instances/sample",+ });mocks.providerProps = undefined;mocks.instanceFormContext.state.isRequesting = false;+ mocks.instanceFormContext.setState.mockImplementation(+ (+ updater: (state: { isRequesting: boolean }) => {+ isRequesting: boolean;+ }+ ) => {+ mocks.instanceFormContext.state = updater(+ mocks.instanceFormContext.state+ );+ }+ );mocks.instanceFormContext.valueChanged = false;globalThis.ResizeObserver = class ResizeObserver {observe() {}@@ -219,4 +277,211 @@ describe("CreateInstanceView", () => {root.unmount();});});++ test("dismisses SaaS sample creation when the instance quota is reached", () => {+ mocks.isSaaSMode = true;+ mocks.instanceCountLimit = 1;+ mocks.activatedInstanceCount = 1;+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ expect(mocks.pushNotification).toHaveBeenCalledWith({+ module: "bytebase",+ style: "CRITICAL",+ title: "Instance quota reached",+ description: "You have reached the limit of 1 instances.",+ });+ expect(mocks.onDismiss).toHaveBeenCalledOnce();++ act(() => {+ root.unmount();+ });+ });++ test("prepares the sample instance and follows the existing created flow", async () => {+ mocks.isSaaSMode = true;+ const instance = { name: "projects/demo/instances/sample" };+ mocks.prepareSampleProjectInstance.mockResolvedValue(instance);+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ const button = [...container.querySelectorAll("button")].find((element) =>+ element.textContent?.includes("Use sample instance")+ ) as HTMLButtonElement;+ await act(async () => {+ button.click();+ });++ expect(mocks.prepareSampleProjectInstance).toHaveBeenCalledWith(+ "projects/demo"+ );+ expect(mocks.onCreated).toHaveBeenCalledWith(instance);++ act(() => {+ root.unmount();+ });+ });++ test("disables the sample action while preparation is running", async () => {+ mocks.isSaaSMode = true;+ let resolvePreparation: (instance: { name: string }) => void;+ mocks.prepareSampleProjectInstance.mockReturnValue(+ new Promise((resolve) => {+ resolvePreparation = resolve;+ })+ );+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ const button = [...container.querySelectorAll("button")].find((element) =>+ element.textContent?.includes("Use sample instance")+ ) as HTMLButtonElement;+ act(() => {+ button.click();+ });++ expect(button).toBeDisabled();+ expect(button).toHaveTextContent("Preparing Sample Project Instance…");+ expect(+ container.querySelector("[data-testid='instance-form-buttons']")+ ).toBeDisabled();++ await act(async () => {+ resolvePreparation!({ name: "projects/demo/instances/sample" });+ });++ act(() => {+ root.unmount();+ });+ });++ test("disables the sample action while regular creation is running", () => {+ mocks.isSaaSMode = true;+ mocks.instanceFormContext.state.isRequesting = true;+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ const button = [...container.querySelectorAll("button")].find((element) =>+ element.textContent?.includes("Use sample instance")+ ) as HTMLButtonElement;+ expect(button).toBeDisabled();++ act(() => {+ root.unmount();+ });+ });++ test("shows localized feedback when sample preparation fails", async () => {+ mocks.isSaaSMode = true;+ mocks.prepareSampleProjectInstance.mockRejectedValue(+ new ConnectError(+ "The sample instance cannot be provisioned. Try again later.",+ Code.Internal+ )+ );+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ const button = [...container.querySelectorAll("button")].find((element) =>+ element.textContent?.includes("Use sample instance")+ ) as HTMLButtonElement;+ await act(async () => {+ button.click();+ });++ expect(mocks.pushNotification).toHaveBeenCalledWith({+ module: "bytebase",+ style: "CRITICAL",+ title: "Failed to prepare Sample Project Instance.",+ description:+ "[internal] The sample instance cannot be provisioned. Try again later.",+ });++ act(() => {+ root.unmount();+ });+ });++ test("keeps sample instance creation out of self-hosted project and SaaS workspace creation", () => {+ const container = document.createElement("div");+ const root = createRoot(container);++ act(() => {+ root.render(+ <CreateInstanceView+ parent="projects/demo"+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ expect(container.textContent).not.toContain("Use sample instance");++ mocks.isSaaSMode = true;+ act(() => {+ root.render(+ <CreateInstanceView+ onDismiss={mocks.onDismiss}+ onCreated={mocks.onCreated}+ />+ );+ });++ expect(container.textContent).not.toContain("Use sample instance");++ act(() => {+ root.unmount();+ });+ });});diff --git a/frontend/src/components/instance/CreateInstanceView.tsx b/frontend/src/components/instance/CreateInstanceView.tsxindex d3656d85ba..e3032a62a7 100644--- a/frontend/src/components/instance/CreateInstanceView.tsx+++ b/frontend/src/components/instance/CreateInstanceView.tsx@@ -9,11 +9,15 @@ import {useInstanceFormContext,} from "@/components/instance";import type { InfoSection } from "@/components/instance/info-content";+import { Alert } from "@/components/ui/alert";+import { Button } from "@/components/ui/button";import { useUnsavedChangesGuard } from "@/hooks/useUnsavedChangesGuard";import { pushNotification } from "@/stores";import { useAppStore } from "@/stores/app";import type { Instance } from "@/types/proto-es/v1/instance_service_pb";import type { Project } from "@/types/proto-es/v1/project_service_pb";+import { isValidProjectName } from "@/types/v1/project";+import { extractGrpcErrorMessage } from "@/utils/connect";const MIN_DOCKED_MAIN_WIDTH = 700;const DOCKED_INFO_RAIL_WIDTH = 500;@@ -35,6 +39,9 @@ export function CreateInstanceView({onCreated,}: CreateInstanceViewProps) {const { t } = useTranslation();+ const isSaaSMode = useAppStore((state) => state.isSaaSMode());+ const canPrepareSampleProjectInstance =+ isSaaSMode && !!parent && isValidProjectName(parent);// Check instance limit on mountuseEffect(() => {@@ -50,7 +57,7 @@ export function CreateInstanceView({});onDismiss();}- }, [onDismiss, t]);+ }, [canPrepareSampleProjectInstance, onDismiss, t]);return (<div className="h-full overflow-hidden">@@ -59,20 +66,35 @@ export function CreateInstanceView({project={project}onDismiss={onDismiss}>- <CreateInstanceFormInner onCreated={onCreated} />+ <CreateInstanceFormInner+ canPrepareSampleProjectInstance={canPrepareSampleProjectInstance}+ onCreated={onCreated}+ parent={parent}+ /></InstanceFormProvider></div>);}function CreateInstanceFormInner({+ canPrepareSampleProjectInstance,onCreated,+ parent,}: {+ canPrepareSampleProjectInstance: boolean;onCreated: (instance: Instance) => void;+ parent?: string;}) {const { t } = useTranslation();- const ctx = useInstanceFormContext();- const currentEngine = ctx.basicInfo.engine;+ const { basicInfo, state, setState } = useInstanceFormContext();+ const currentEngine = basicInfo.engine;+ const prepareSampleProjectInstance = useAppStore(+ (state) => state.prepareSampleProjectInstance+ );+ const [+ isPreparingSampleProjectInstance,+ setIsPreparingSampleProjectInstance,+ ] = useState(false);const [activeInfoSection, setActiveInfoSection] = useState<InfoSection | undefined@@ -138,6 +160,35 @@ function CreateInstanceFormInner({setActiveInfoSection(section);}, []);+ const handlePrepareSampleProjectInstance = useCallback(async () => {+ if (!parent || isPreparingSampleProjectInstance || state.isRequesting) {+ return;+ }+ setIsPreparingSampleProjectInstance(true);+ setState((prev) => ({ ...prev, isRequesting: true }));+ try {+ onCreated(await prepareSampleProjectInstance(parent));+ } catch (error) {+ pushNotification({+ module: "bytebase",+ style: "CRITICAL",+ title: t("instance.prepare-sample-instance-failed"),+ description: extractGrpcErrorMessage(error),+ });+ } finally {+ setIsPreparingSampleProjectInstance(false);+ setState((prev) => ({ ...prev, isRequesting: false }));+ }+ }, [+ isPreparingSampleProjectInstance,+ onCreated,+ parent,+ prepareSampleProjectInstance,+ setState,+ state.isRequesting,+ t,+ ]);+return (<divref={layoutRef}@@ -149,6 +200,24 @@ function CreateInstanceFormInner({{/* Body */}<div className="flex-1 min-h-0 overflow-auto"><div className="px-4 py-4 sm:px-6">+ {canPrepareSampleProjectInstance && (+ <Alert+ title={t("instance.sample-project-instance-title")}+ description={t("instance.sample-project-instance-description")}+ >+ <Button+ className="mt-3"+ disabled={+ isPreparingSampleProjectInstance || state.isRequesting+ }+ onClick={handlePrepareSampleProjectInstance}+ >+ {isPreparingSampleProjectInstance+ ? t("instance.preparing-sample-instance")+ : t("instance.use-sample-instance")}+ </Button>+ </Alert>+ )}<InstanceFormBody onOpenInfoPanel={handleOpenInfoPanel} /></div></div>diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.jsonindex 5a67b17e3c..18a23ac12d 100644--- a/frontend/src/locales/en-US.json+++ b/frontend/src/locales/en-US.json@@ -1210,11 +1210,15 @@},"password-write-only": "YOUR_DB_PWD - write only","port": "Port",+ "prepare-sample-instance-failed": "Failed to prepare Sample Project Instance.",+ "preparing-sample-instance": "Preparing Sample Project Instance…","project-id": "Project ID","restore-instance-instance-name-to-normal-state": "Restore instance '{{0}}' to normal state?","role-arn": "Role ARN","role-arn-description": "IAM role to assume for cross-account access. Leave empty for same-account access.","role-arn-placeholder": "arn:aws:iam::123456789012:role/CrossAccountRole",+ "sample-project-instance-description": "Use a Sample Project Instance to explore Bytebase with a ready-to-use database for 7 days.",+ "sample-project-instance-title": "Try a Sample Project Instance","scan-interval": {"default-never": "Default (never)","description": "Bytebase periodically syncs instance schema and detects anomalies.",@@ -1309,6 +1313,7 @@"token-write-only": "YOUR_TOKEN - write only","type-or-paste-credentials-write-only": "Type or paste CREDENTIALS - write only","unable-to-connect": "Bytebase couldn't connect with these settings. Review the guidance above, or continue and update the connection later.\n\nTechnical details: {{0}}",+ "use-sample-instance": "Use sample instance (Available for 7 days)","users": "Users","your-snowflake-account-locator": "Your Snowflake account locator"},diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.jsonindex 55013b1f7a..e080c446a1 100644--- a/frontend/src/locales/es-ES.json+++ b/frontend/src/locales/es-ES.json@@ -1210,11 +1210,15 @@},"password-write-only": "SU_DB_PWD - solo escritura","port": "Puerto",+ "prepare-sample-instance-failed": "No se pudo preparar la instancia de proyecto de muestra.",+ "preparing-sample-instance": "Preparando la instancia de proyecto de muestra…","project-id": "ID del proyecto","restore-instance-instance-name-to-normal-state": "¿Restaurar la instancia '{{0}}' al estado normal?","role-arn": "ARN del rol","role-arn-description": "Rol IAM para asumir en acceso entre cuentas. Dejar vacío para acceso en la misma cuenta.","role-arn-placeholder": "arn:aws:iam::123456789012:role/CrossAccountRole",+ "sample-project-instance-description": "Use una instancia de proyecto de muestra para explorar Bytebase con una base de datos lista para usar durante 7 días.",+ "sample-project-instance-title": "Pruebe una instancia de proyecto de muestra","scan-interval": {"default-never": "Predeterminado (nunca)","description": "Bytebase sincroniza periódicamente el esquema de instancia y detecta anomalías.",@@ -1309,6 +1313,7 @@"token-write-only": "TU_TOKEN - solo escritura","type-or-paste-credentials-write-only": "Escriba o pegue las CREDENCIALES - solo escritura","unable-to-connect": "Bytebase no pudo conectarse con esta configuración. Revisa las indicaciones anteriores o continúa y actualiza la conexión más tarde.\n\nDetalles técnicos: {{0}}",+ "use-sample-instance": "Usar instancia de ejemplo (Disponible durante 7 días)","users": "Usuarios","your-snowflake-account-locator": "Su localizador de cuentas Snowflake"},diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.jsonindex 65bb72ec97..6d591dda06 100644--- a/frontend/src/locales/ja-JP.json+++ b/frontend/src/locales/ja-JP.json@@ -1210,11 +1210,15 @@},"password-write-only": "YOUR_DB_PWD - 書き込み専用","port": "ポート",+ "prepare-sample-instance-failed": "サンプルプロジェクトインスタンスの準備に失敗しました。",+ "preparing-sample-instance": "サンプルプロジェクトインスタンスを準備しています…","project-id": "プロジェクトID","restore-instance-instance-name-to-normal-state": "インスタンス '{{0}}' を通常の状態に復元しますか?","role-arn": "ロール ARN","role-arn-description": "クロスアカウントアクセス用の IAM ロール。同一アカウントアクセスの場合は空のままにしてください。","role-arn-placeholder": "arn:aws:iam::123456789012:role/CrossAccountRole",+ "sample-project-instance-description": "すぐに使えるデータベースを備えたサンプルプロジェクトインスタンスを 7 日間使用して、Bytebase を試すことができます。",+ "sample-project-instance-title": "サンプルプロジェクトインスタンスを試す","scan-interval": {"default-never": "デフォルト (なし)","description": "Bytebase は定期的にインスタンスのスキーマを同期し、異常検出を実行します。",@@ -1309,6 +1313,7 @@"token-write-only": "YOUR_TOKEN - 書き込み専用","type-or-paste-credentials-write-only": "資格情報を入力または貼り付けます - 書き込みのみ","unable-to-connect": "この設定では Bytebase から接続できませんでした。上のガイダンスを確認するか、そのまま続行して後で接続を更新してください。\n\n技術的な詳細: {{0}}",+ "use-sample-instance": "サンプルインスタンスを使用する(7日間利用可能)","users": "ユーザー","your-snowflake-account-locator": "Snowflake アカウント ロケーター"},diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.jsonindex c458d79c5b..efc03f1a0e 100644--- a/frontend/src/locales/vi-VN.json+++ b/frontend/src/locales/vi-VN.json@@ -1210,11 +1210,15 @@},"password-write-only": "YOUR_DB_PWD - chỉ ghi","port": "Cổng",+ "prepare-sample-instance-failed": "Không thể chuẩn bị Phiên bản dự án mẫu.",+ "preparing-sample-instance": "Đang chuẩn bị Phiên bản dự án mẫu…","project-id": "ID dự án","restore-instance-instance-name-to-normal-state": "Khôi phục phiên bản '{{0}}' về trạng thái bình thường?","role-arn": "ARN vai trò","role-arn-description": "Vai trò IAM để đảm nhận cho truy cập xuyên tài khoản. Để trống cho truy cập cùng tài khoản.","role-arn-placeholder": "arn:aws:iam::123456789012:role/CrossAccountRole",+ "sample-project-instance-description": "Sử dụng Phiên bản dự án mẫu để khám phá Bytebase với cơ sở dữ liệu sẵn sàng sử dụng trong 7 ngày.",+ "sample-project-instance-title": "Dùng thử Phiên bản dự án mẫu","scan-interval": {"default-never": "Mặc định (không bao giờ)","description": "Bytebase định kỳ đồng bộ lược đồ phiên bản và phát hiện bất thường.",@@ -1309,6 +1313,7 @@"token-write-only": "YOUR_TOKEN - chỉ ghi","type-or-paste-credentials-write-only": "Nhập hoặc dán THÔNG TIN XÁC THỰC - chỉ ghi","unable-to-connect": "Bytebase không thể kết nối với các cài đặt này. Hãy xem hướng dẫn ở trên hoặc tiếp tục và cập nhật kết nối sau.\n\nChi tiết kỹ thuật: {{0}}",+ "use-sample-instance": "Sử dụng phiên bản mẫu (Có sẵn trong 7 ngày)","users": "Người dùng","your-snowflake-account-locator": "Định vị tài khoản Snowflake của bạn"},diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.jsonindex 851b319908..0ab5f050a2 100644--- a/frontend/src/locales/zh-CN.json+++ b/frontend/src/locales/zh-CN.json@@ -1210,11 +1210,15 @@},"password-write-only": "YOUR_DB_PWD - 仅写入","port": "端口",+ "prepare-sample-instance-failed": "准备示例项目实例失败。",+ "preparing-sample-instance": "正在准备示例项目实例…","project-id": "项目 ID","restore-instance-instance-name-to-normal-state": "恢复实例'{{0}}'到正常状态?","role-arn": "角色 ARN","role-arn-description": "用于跨账户访问的 IAM 角色。同账户访问请留空。","role-arn-placeholder": "arn:aws:iam::123456789012:role/CrossAccountRole",+ "sample-project-instance-description": "使用示例项目实例探索 Bytebase,并在 7 天内使用预配置的数据库。",+ "sample-project-instance-title": "试用示例项目实例","scan-interval": {"default-never": "默认(永不)","description": "Bytebase 会定期同步实例的 schema 以及进行异常检测。",@@ -1309,6 +1313,7 @@"token-write-only": "YOUR_TOKEN - 仅写入","type-or-paste-credentials-write-only": "输入或粘贴 CREDENTIALS - 仅写入","unable-to-connect": "Bytebase 无法使用这些设置连接数据库。请检查上方指引,或继续操作并稍后更新连接。\n\n技术详情:{{0}}",+ "use-sample-instance": "使用示例实例(可用 7 天)","users": "用户","your-snowflake-account-locator": "您的 Snowflake 账户定位符"},diff --git a/frontend/src/stores/app/instance.ts b/frontend/src/stores/app/instance.tsindex 9e58036745..2958ea2b81 100644--- a/frontend/src/stores/app/instance.ts+++ b/frontend/src/stores/app/instance.ts@@ -14,6 +14,7 @@ import {type Instance,ListInstanceDatabaseRequestSchema,ListInstancesRequestSchema,+ PrepareSampleProjectInstanceRequestSchema,RemoveDataSourceRequestSchema,SyncInstanceRequestSchema,UndeleteInstanceRequestSchema,@@ -204,6 +205,14 @@ export const createInstanceSlice: AppSliceCreator<InstanceSlice> = (return response;},+ prepareSampleProjectInstance: async (parent) => {+ const response =+ await instanceServiceClientConnect.prepareSampleProjectInstance(+ createProto(PrepareSampleProjectInstanceRequestSchema, { parent })+ );+ return upsertInstances([response])[0];+ },+updateInstance: async (instance, updateMask) => {const response = await instanceServiceClientConnect.updateInstance(createProto(UpdateInstanceRequestSchema, {diff --git a/frontend/src/stores/app/types.ts b/frontend/src/stores/app/types.tsindex b6beb20bea..278a3dc600 100644--- a/frontend/src/stores/app/types.ts+++ b/frontend/src/stores/app/types.ts@@ -457,6 +457,7 @@ export type InstanceSlice = {validateOnly?: boolean,options?: { parent?: string }) => Promise<Instance>;+ prepareSampleProjectInstance: (parent: string) => Promise<Instance>;updateInstance: (instance: Instance,updateMask: string[]diff --git a/frontend/src/types/proto-es/v1/instance_service_pb.d.ts b/frontend/src/types/proto-es/v1/instance_service_pb.d.tsindex 5e04761c90..4246d69cca 100644--- a/frontend/src/types/proto-es/v1/instance_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/instance_service_pb.d.ts@@ -205,6 +205,25 @@ export declare type CreateInstanceRequest = Message<"bytebase.v1.CreateInstanceR*/export declare const CreateInstanceRequestSchema: GenMessage<CreateInstanceRequest>;+/**+ * @generated from message bytebase.v1.PrepareSampleProjectInstanceRequest+ */+export declare type PrepareSampleProjectInstanceRequest = Message<"bytebase.v1.PrepareSampleProjectInstanceRequest"> & {+ /**+ * The project that owns the sample instance.+ * Format: projects/{project}+ *+ * @generated from field: string parent = 1;+ */+ parent: string;+};++/**+ * Describes the message bytebase.v1.PrepareSampleProjectInstanceRequest.+ * Use `create(PrepareSampleProjectInstanceRequestSchema)` to create a new message.+ */+export declare const PrepareSampleProjectInstanceRequestSchema: GenMessage<PrepareSampleProjectInstanceRequest>;+/*** @generated from message bytebase.v1.UpdateInstanceRequest*/@@ -1801,6 +1820,17 @@ export declare const InstanceService: GenService<{input: typeof CreateInstanceRequestSchema;output: typeof InstanceSchema;},+ /**+ * Prepares a Sample Project Instance for a project.+ * Permissions required: bb.instances.create+ *+ * @generated from rpc bytebase.v1.InstanceService.PrepareSampleProjectInstance+ */+ prepareSampleProjectInstance: {+ methodKind: "unary";+ input: typeof PrepareSampleProjectInstanceRequestSchema;+ output: typeof InstanceSchema;+ },/*** Updates a database instance.* Permissions required: bb.instances.updatediff --git a/frontend/src/types/proto-es/v1/instance_service_pb.js b/frontend/src/types/proto-es/v1/instance_service_pb.jsindex 892f61050a..307fffd56b 100644--- a/frontend/src/types/proto-es/v1/instance_service_pb.js+++ b/frontend/src/types/proto-es/v1/instance_service_pb.js@@ -17,7 +17,7 @@ import { file_v1_instance_role_service } from "./instance_role_service_pb";* Describes the file v1/instance_service.proto.*/export const file_v1_instance_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_role_service]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_role_service]);/*** Describes the message bytebase.v1.GetInstanceRequest.@@ -47,137 +47,144 @@ export const ListInstancesResponseSchema = /*@__PURE__*/export const CreateInstanceRequestSchema = /*@__PURE__*/messageDesc(file_v1_instance_service, 3);+/**+ * Describes the message bytebase.v1.PrepareSampleProjectInstanceRequest.+ * Use `create(PrepareSampleProjectInstanceRequestSchema)` to create a new message.+ */+export const PrepareSampleProjectInstanceRequestSchema = /*@__PURE__*/+ messageDesc(file_v1_instance_service, 4);+/*** Describes the message bytebase.v1.UpdateInstanceRequest.* Use `create(UpdateInstanceRequestSchema)` to create a new message.*/export const UpdateInstanceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 4);+ messageDesc(file_v1_instance_service, 5);/*** Describes the message bytebase.v1.DeleteInstanceRequest.* Use `create(DeleteInstanceRequestSchema)` to create a new message.*/export const DeleteInstanceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 5);+ messageDesc(file_v1_instance_service, 6);/*** Describes the message bytebase.v1.UndeleteInstanceRequest.* Use `create(UndeleteInstanceRequestSchema)` to create a new message.*/export const UndeleteInstanceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 6);+ messageDesc(file_v1_instance_service, 7);/*** Describes the message bytebase.v1.SyncInstanceRequest.* Use `create(SyncInstanceRequestSchema)` to create a new message.*/export const SyncInstanceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 7);+ messageDesc(file_v1_instance_service, 8);/*** Describes the message bytebase.v1.ListInstanceDatabaseRequest.* Use `create(ListInstanceDatabaseRequestSchema)` to create a new message.*/export const ListInstanceDatabaseRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 8);+ messageDesc(file_v1_instance_service, 9);/*** Describes the message bytebase.v1.ListInstanceDatabaseResponse.* Use `create(ListInstanceDatabaseResponseSchema)` to create a new message.*/export const ListInstanceDatabaseResponseSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 9);+ messageDesc(file_v1_instance_service, 10);/*** Describes the message bytebase.v1.SyncInstanceResponse.* Use `create(SyncInstanceResponseSchema)` to create a new message.*/export const SyncInstanceResponseSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 10);+ messageDesc(file_v1_instance_service, 11);/*** Describes the message bytebase.v1.BatchSyncInstancesRequest.* Use `create(BatchSyncInstancesRequestSchema)` to create a new message.*/export const BatchSyncInstancesRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 11);+ messageDesc(file_v1_instance_service, 12);/*** Describes the message bytebase.v1.BatchSyncInstancesResponse.* Use `create(BatchSyncInstancesResponseSchema)` to create a new message.*/export const BatchSyncInstancesResponseSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 12);+ messageDesc(file_v1_instance_service, 13);/*** Describes the message bytebase.v1.BatchUpdateInstancesRequest.* Use `create(BatchUpdateInstancesRequestSchema)` to create a new message.*/export const BatchUpdateInstancesRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 13);+ messageDesc(file_v1_instance_service, 14);/*** Describes the message bytebase.v1.BatchUpdateInstancesResponse.* Use `create(BatchUpdateInstancesResponseSchema)` to create a new message.*/export const BatchUpdateInstancesResponseSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 14);+ messageDesc(file_v1_instance_service, 15);/*** Describes the message bytebase.v1.AddDataSourceRequest.* Use `create(AddDataSourceRequestSchema)` to create a new message.*/export const AddDataSourceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 15);+ messageDesc(file_v1_instance_service, 16);/*** Describes the message bytebase.v1.RemoveDataSourceRequest.* Use `create(RemoveDataSourceRequestSchema)` to create a new message.*/export const RemoveDataSourceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 16);+ messageDesc(file_v1_instance_service, 17);/*** Describes the message bytebase.v1.UpdateDataSourceRequest.* Use `create(UpdateDataSourceRequestSchema)` to create a new message.*/export const UpdateDataSourceRequestSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 17);+ messageDesc(file_v1_instance_service, 18);/*** Describes the message bytebase.v1.SyncDatabases.* Use `create(SyncDatabasesSchema)` to create a new message.*/export const SyncDatabasesSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 18);+ messageDesc(file_v1_instance_service, 19);/*** Describes the message bytebase.v1.Instance.* Use `create(InstanceSchema)` to create a new message.*/export const InstanceSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 19);+ messageDesc(file_v1_instance_service, 20);/*** Describes the message bytebase.v1.DataSourceExternalSecret.* Use `create(DataSourceExternalSecretSchema)` to create a new message.*/export const DataSourceExternalSecretSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 20);+ messageDesc(file_v1_instance_service, 21);/*** Describes the message bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption.* Use `create(DataSourceExternalSecret_AppRoleAuthOptionSchema)` to create a new message.*/export const DataSourceExternalSecret_AppRoleAuthOptionSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 20, 0);+ messageDesc(file_v1_instance_service, 21, 0);/*** Describes the enum bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption.SecretType.*/export const DataSourceExternalSecret_AppRoleAuthOption_SecretTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 20, 0, 0);+ enumDesc(file_v1_instance_service, 21, 0, 0);/*** @generated from enum bytebase.v1.DataSourceExternalSecret.AppRoleAuthOption.SecretType@@ -189,7 +196,7 @@ export const DataSourceExternalSecret_AppRoleAuthOption_SecretType = /*@__PURE__* Describes the enum bytebase.v1.DataSourceExternalSecret.SecretType.*/export const DataSourceExternalSecret_SecretTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 20, 0);+ enumDesc(file_v1_instance_service, 21, 0);/*** @generated from enum bytebase.v1.DataSourceExternalSecret.SecretType@@ -201,7 +208,7 @@ export const DataSourceExternalSecret_SecretType = /*@__PURE__*/* Describes the enum bytebase.v1.DataSourceExternalSecret.AuthType.*/export const DataSourceExternalSecret_AuthTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 20, 1);+ enumDesc(file_v1_instance_service, 21, 1);/*** @generated from enum bytebase.v1.DataSourceExternalSecret.AuthType@@ -213,7 +220,7 @@ export const DataSourceExternalSecret_AuthType = /*@__PURE__*/* Describes the enum bytebase.v1.DataSourceExternalSecret.TokenType.*/export const DataSourceExternalSecret_TokenTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 20, 2);+ enumDesc(file_v1_instance_service, 21, 2);/*** @generated from enum bytebase.v1.DataSourceExternalSecret.TokenType@@ -226,41 +233,41 @@ export const DataSourceExternalSecret_TokenType = /*@__PURE__*/* Use `create(DataSourceSchema)` to create a new message.*/export const DataSourceSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 21);+ messageDesc(file_v1_instance_service, 22);/*** Describes the message bytebase.v1.DataSource.AzureCredential.* Use `create(DataSource_AzureCredentialSchema)` to create a new message.*/export const DataSource_AzureCredentialSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 21, 0);+ messageDesc(file_v1_instance_service, 22, 0);/*** Describes the message bytebase.v1.DataSource.AWSCredential.* Use `create(DataSource_AWSCredentialSchema)` to create a new message.*/export const DataSource_AWSCredentialSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 21, 1);+ messageDesc(file_v1_instance_service, 22, 1);/*** Describes the message bytebase.v1.DataSource.GCPCredential.* Use `create(DataSource_GCPCredentialSchema)` to create a new message.*/export const DataSource_GCPCredentialSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 21, 2);+ messageDesc(file_v1_instance_service, 22, 2);/*** Describes the message bytebase.v1.DataSource.Address.* Use `create(DataSource_AddressSchema)` to create a new message.*/export const DataSource_AddressSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 21, 3);+ messageDesc(file_v1_instance_service, 22, 3);/*** Describes the enum bytebase.v1.DataSource.AuthenticationType.*/export const DataSource_AuthenticationTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 21, 0);+ enumDesc(file_v1_instance_service, 22, 0);/*** @generated from enum bytebase.v1.DataSource.AuthenticationType@@ -272,7 +279,7 @@ export const DataSource_AuthenticationType = /*@__PURE__*/* Describes the enum bytebase.v1.DataSource.CloudSQLIPType.*/export const DataSource_CloudSQLIPTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 21, 1);+ enumDesc(file_v1_instance_service, 22, 1);/*** CloudSQLIPType selects which Cloud SQL IP to dial for Google Cloud SQL IAM connections.@@ -286,7 +293,7 @@ export const DataSource_CloudSQLIPType = /*@__PURE__*/* Describes the enum bytebase.v1.DataSource.RedisType.*/export const DataSource_RedisTypeSchema = /*@__PURE__*/- enumDesc(file_v1_instance_service, 21, 2);+ enumDesc(file_v1_instance_service, 22, 2);/*** @generated from enum bytebase.v1.DataSource.RedisType@@ -299,21 +306,21 @@ export const DataSource_RedisType = /*@__PURE__*/* Use `create(InstanceResourceSchema)` to create a new message.*/export const InstanceResourceSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 22);+ messageDesc(file_v1_instance_service, 23);/*** Describes the message bytebase.v1.SASLConfig.* Use `create(SASLConfigSchema)` to create a new message.*/export const SASLConfigSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 23);+ messageDesc(file_v1_instance_service, 24);/*** Describes the message bytebase.v1.KerberosConfig.* Use `create(KerberosConfigSchema)` to create a new message.*/export const KerberosConfigSchema = /*@__PURE__*/- messageDesc(file_v1_instance_service, 24);+ messageDesc(file_v1_instance_service, 25);/*** Describes the enum bytebase.v1.DataSourceType.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 5380aae069..6268f4dbb6 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -10562,6 +10562,29 @@ paths:application/json:schema:$ref: '#/components/schemas/bytebase.v1.BatchUpdateInstancesResponse'+ /v1/projects/{project}/instances:prepareSampleProjectInstance:+ post:+ tags:+ - InstanceService+ summary: PrepareSampleProjectInstance+ description: |-+ Prepares a Sample Project Instance for a project.+ Permissions required: bb.instances.create+ operationId: InstanceService_PrepareSampleProjectInstance+ parameters:+ - name: project+ in: path+ description: The project id.+ required: true+ schema:+ type: string+ responses:+ "200":+ description: Success+ content:+ application/json:+ schema:+ $ref: '#/components/schemas/bytebase.v1.Instance'/v1/projects/{project}/issues:get:tags:@@ -27142,6 +27165,19 @@ components:- If only line is known, set line and leave column as 0 (e.g., line=5, column=0)- If only column is known (rare), set column and leave line as 0Frontends should check for nil/undefined/zero values and handle them appropriately.+ bytebase.v1.PrepareSampleProjectInstanceRequest:+ type: object+ properties:+ parent:+ type: string+ title: parent+ description: |-+ The project that owns the sample instance.+ Format: projects/{project}+ title: PrepareSampleProjectInstanceRequest+ required:+ - parent+ additionalProperties: falsebytebase.v1.PreviewTaskRunRollbackRequest:type: objectproperties:diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 84a3b9ce72..cccf4538de 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -424,6 +424,7 @@- [ListInstanceDatabaseResponse](#bytebase-v1-ListInstanceDatabaseResponse)- [ListInstancesRequest](#bytebase-v1-ListInstancesRequest)- [ListInstancesResponse](#bytebase-v1-ListInstancesResponse)+ - [PrepareSampleProjectInstanceRequest](#bytebase-v1-PrepareSampleProjectInstanceRequest)- [RemoveDataSourceRequest](#bytebase-v1-RemoveDataSourceRequest)- [SASLConfig](#bytebase-v1-SASLConfig)- [SyncDatabases](#bytebase-v1-SyncDatabases)@@ -7085,6 +7086,21 @@ For example: name == "sample instance" name.contains("sample") r+<a name="bytebase-v1-PrepareSampleProjectInstanceRequest"></a>++### PrepareSampleProjectInstanceRequest++++| Field | Type | Label | Description |+| ----- | ---- | ----- | ----------- |+| parent | [string](#string) | | The project that owns the sample instance. Format: projects/{project} |++++++<a name="bytebase-v1-RemoveDataSourceRequest"></a>### RemoveDataSourceRequest@@ -7342,6 +7358,7 @@ InstanceService manages database instances and their connections.| GetInstance | [GetInstanceRequest](#bytebase-v1-GetInstanceRequest) | [Instance](#bytebase-v1-Instance) | Gets a database instance by name. Permissions required: bb.instances.get || ListInstances | [ListInstancesRequest](#bytebase-v1-ListInstancesRequest) | [ListInstancesResponse](#bytebase-v1-ListInstancesResponse) | Lists database instances, optionally within a project. Permissions required: bb.instances.list || CreateInstance | [CreateInstanceRequest](#bytebase-v1-CreateInstanceRequest) | [Instance](#bytebase-v1-Instance) | Creates a new database instance. Permissions required: bb.instances.create |+| PrepareSampleProjectInstance | [PrepareSampleProjectInstanceRequest](#bytebase-v1-PrepareSampleProjectInstanceRequest) | [Instance](#bytebase-v1-Instance) | Prepares a Sample Project Instance for a project. Permissions required: bb.instances.create || UpdateInstance | [UpdateInstanceRequest](#bytebase-v1-UpdateInstanceRequest) | [Instance](#bytebase-v1-Instance) | Updates a database instance. Permissions required: bb.instances.update || DeleteInstance | [DeleteInstanceRequest](#bytebase-v1-DeleteInstanceRequest) | [.google.protobuf.Empty](#google-protobuf-Empty) | Deletes or soft-deletes a database instance. Soft-delete requests fail with FAILED_PRECONDITION while any task run targeting the instance is pending, available, or running. Permissions required: bb.instances.delete || UndeleteInstance | [UndeleteInstanceRequest](#bytebase-v1-UndeleteInstanceRequest) | [Instance](#bytebase-v1-Instance) | Restores a soft-deleted database instance. Restore requests fail with FAILED_PRECONDITION while any task run targeting the instance is pending, available, or running. Permissions required: bb.instances.undelete |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex d5db70f452..9aa77f9ea8 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -1790,6 +1790,10 @@<a href="#bytebase.v1.ListInstancesResponse"><span class="badge">M</span>ListInstancesResponse</a></li>+ <li>+ <a href="#bytebase.v1.PrepareSampleProjectInstanceRequest"><span class="badge">M</span>PrepareSampleProjectInstanceRequest</a>+ </li>+<li><a href="#bytebase.v1.RemoveDataSourceRequest"><span class="badge">M</span>RemoveDataSourceRequest</a></li>@@ -20079,6 +20083,31 @@ If this field is omitted, there are no subsequent pages. </p></td>+ <h3 id="bytebase.v1.PrepareSampleProjectInstanceRequest">PrepareSampleProjectInstanceRequest</h3>+ <p></p>+++ <table class="field-table">+ <thead>+ <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>+ </thead>+ <tbody>++ <tr>+ <td>parent</td>+ <td><a href="#string">string</a></td>+ <td></td>+ <td><p>The project that owns the sample instance.+Format: projects/{project} </p></td>+ </tr>++ </tbody>+ </table>+++++<h3 id="bytebase.v1.RemoveDataSourceRequest">RemoveDataSourceRequest</h3><p></p>@@ -20654,6 +20683,14 @@ Permissions required: bb.instances.list</p></td>Permissions required: bb.instances.create</p></td></tr>+ <tr>+ <td>PrepareSampleProjectInstance</td>+ <td><a href="#bytebase.v1.PrepareSampleProjectInstanceRequest">PrepareSampleProjectInstanceRequest</a></td>+ <td><a href="#bytebase.v1.Instance">Instance</a></td>+ <td><p>Prepares a Sample Project Instance for a project.+Permissions required: bb.instances.create</p></td>+ </tr>+<tr><td>UpdateInstance</td><td><a href="#bytebase.v1.UpdateInstanceRequest">UpdateInstanceRequest</a></td>@@ -20809,6 +20846,16 @@ Permissions required: bb.instances.update</p></td>+ <tr>+ <td>PrepareSampleProjectInstance</td>+ <td>POST</td>+ <td>/v1/{parent=projects/*}/instances:prepareSampleProjectInstance</td>+ <td>*</td>+ </tr>++++<tr><td>UpdateInstance</td><td>PATCH</td>diff --git a/proto/v1/v1/instance_service.proto b/proto/v1/v1/instance_service.protoindex f2f389662a..fc23723f89 100644--- a/proto/v1/v1/instance_service.proto+++ b/proto/v1/v1/instance_service.proto@@ -64,6 +64,21 @@ service InstanceService {option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}+ // Prepares a Sample Project Instance for a project.+ // Permissions required: bb.instances.create+ rpc PrepareSampleProjectInstance(PrepareSampleProjectInstanceRequest) returns (Instance) {+ option (google.api.http) = {+ post: "/v1/{parent=projects/*}/instances:prepareSampleProjectInstance"+ body: "*"+ };+ option (google.api.method_signature) = "parent";+ option (bytebase.v1.permission) = "bb.instances.create";+ option (bytebase.v1.auth_method) = IAM;+ option (bytebase.v1.audit) = true;+ option (bytebase.v1.mcp_method_class) = EXCLUDED;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;+ }+// Updates a database instance.// Permissions required: bb.instances.updaterpc UpdateInstance(UpdateInstanceRequest) returns (Instance) {@@ -353,6 +368,15 @@ message CreateInstanceRequest {bool validate_only = 3;}+message PrepareSampleProjectInstanceRequest {+ // The project that owns the sample instance.+ // Format: projects/{project}+ string parent = 1 [+ (google.api.field_behavior) = REQUIRED,+ (google.api.resource_reference) = {type: "bytebase.com/Project"}+ ];+}+message UpdateInstanceRequest {// The instance to update.//