Skip to content

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

refactor: unify self-host and SaaS sample instance management (#21238)

ecmadaoba4d9f67b7e3
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yaml
index a74de510e7..fdbc13caa3 100644
--- a/backend/api/mcp/gen/openapi.yaml
+++ b/backend/api/mcp/gen/openapi.yaml
@@ -18170,6 +18170,18 @@ components:
type: boolean
title: available
description: Whether sample setup is currently available.
+ instances:
+ type: array
+ items:
+ $ref: '#/components/schemas/bytebase.v1.SampleInfo.Instance'
+ title: instances
+ description: The provisioned sample instances.
+ title: SampleInfo
+ additionalProperties: false
+ description: SampleInfo describes sample setup availability and provisioned resources.
+ bytebase.v1.SampleInfo.Instance:
+ type: object
+ properties:
instance:
type: string
title: instance
@@ -18178,11 +18190,11 @@ components:
Format: instances/{instance}
expireTime:
title: expire_time
- description: The time when the provisioned sample resources expire.
+ description: The time when the provisioned sample instance expires.
$ref: '#/components/schemas/google.protobuf.Timestamp'
- title: SampleInfo
+ title: Instance
additionalProperties: false
- description: SampleInfo describes sample setup availability and provisioned resources.
+ description: Instance describes one provisioned sample instance.
bytebase.v1.SavedQuery:
type: object
properties:
diff --git a/backend/api/v1/actuator_service.go b/backend/api/v1/actuator_service.go
index 6a0367436e..5d21ebb7f5 100644
--- a/backend/api/v1/actuator_service.go
+++ b/backend/api/v1/actuator_service.go
@@ -16,8 +16,7 @@ import (
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/component/config"
- "github.com/bytebase/bytebase/backend/component/sampleinstance"
- "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"
+ "github.com/bytebase/bytebase/backend/component/sample"
"github.com/bytebase/bytebase/backend/enterprise"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
@@ -29,12 +28,11 @@ import (
// ActuatorService implements the Connect RPC interface for ActuatorService.
type ActuatorService struct {
v1connect.UnimplementedActuatorServiceHandler
- store *store.Store
- profile *config.Profile
- licenseService *enterprise.LicenseService
- schemaSyncer *schemasync.Syncer
- sampleInstanceManager *sampleinstance.Manager
- sampleProjectInstanceManager *sampleprojectinstance.Manager
+ store *store.Store
+ profile *config.Profile
+ licenseService *enterprise.LicenseService
+ schemaSyncer *schemasync.Syncer
+ sampleManager sample.Manager
activeVCSUserCountSnapshot *expirable.LRU[string, int]
}
@@ -47,17 +45,15 @@ func NewActuatorService(
profile *config.Profile,
schemaSyncer *schemasync.Syncer,
licenseService *enterprise.LicenseService,
- sampleInstanceManager *sampleinstance.Manager,
- sampleProjectInstanceManager *sampleprojectinstance.Manager,
+ sampleManager sample.Manager,
) *ActuatorService {
return &ActuatorService{
- store: store,
- profile: profile,
- licenseService: licenseService,
- schemaSyncer: schemaSyncer,
- sampleInstanceManager: sampleInstanceManager,
- sampleProjectInstanceManager: sampleProjectInstanceManager,
- activeVCSUserCountSnapshot: expirable.NewLRU[string, int](1024, nil, activeVCSUserCountSnapshotTTL),
+ store: store,
+ profile: profile,
+ licenseService: licenseService,
+ schemaSyncer: schemaSyncer,
+ sampleManager: sampleManager,
+ activeVCSUserCountSnapshot: expirable.NewLRU[string, int](1024, nil, activeVCSUserCountSnapshotTTL),
}
}
@@ -99,8 +95,22 @@ func (s *ActuatorService) SetupSample(
return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))
}
- if s.sampleInstanceManager != nil {
- if err := s.sampleInstanceManager.GenerateOnboardingData(ctx, common.GetWorkspaceIDFromContext(ctx), user, s.schemaSyncer); err != nil {
+ if s.sampleManager != nil {
+ workspaceID := common.GetWorkspaceIDFromContext(ctx)
+ projectID := "project-sample"
+ project, err := s.store.GetProject(ctx, &store.FindProjectMessage{Workspace: workspaceID, ResourceID: &projectID})
+ if err == nil && project == nil {
+ project, err = s.store.CreateProject(ctx, &store.ProjectMessage{
+ Workspace: workspaceID,
+ ResourceID: projectID,
+ Title: "Sample Project",
+ Setting: &storepb.Project{},
+ }, user)
+ }
+ if err == nil {
+ _, err = s.sampleManager.SetupSample(ctx, sample.SetupRequest{WorkspaceID: workspaceID, ProjectID: project.ResourceID})
+ }
+ if err != nil {
// When running inside docker on mac, we sometimes get database does not exist error.
// This is due to the docker overlay storage incompatibility with mac OS file system.
// Onboarding error is not critical, so we just emit an error log.
@@ -124,21 +134,19 @@ func (s *ActuatorService) getServerInfo(ctx context.Context, workspaceID string)
if workspaceID != "" {
serverInfo.Workspace = common.FormatWorkspace(workspaceID)
- if s.profile.SaaS {
- sample, err := s.store.GetSampleProjectInstance(ctx, workspaceID)
+ if s.sampleManager != nil {
+ sampleInfo, err := s.sampleManager.Info(ctx, workspaceID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get sample information"))
}
- serverInfo.Sample.Available = s.sampleProjectInstanceManager != nil && s.sampleProjectInstanceManager.Available(ctx)
- if sample != nil {
- serverInfo.Sample.Instance = common.FormatInstance(sample.InstanceID)
+ serverInfo.Sample.Available = sampleInfo.Available
+ for _, instance := range sampleInfo.Instances {
+ item := &v1pb.SampleInfo_Instance{Instance: instance.Instance}
+ if instance.ExpireTime != nil {
+ item.ExpireTime = timestamppb.New(*instance.ExpireTime)
+ }
+ serverInfo.Sample.Instances = append(serverInfo.Sample.Instances, item)
}
- if sample != nil && sample.ExpiresAt != nil && sample.DeletedAt == nil {
- serverInfo.Sample.ExpireTime = timestamppb.New(*sample.ExpiresAt)
- }
- } else {
- hasSampleInstances, _ := s.store.HasSampleInstances(ctx, workspaceID)
- serverInfo.Sample.Available = hasSampleInstances
}
defaultProjectID, err := s.store.GetDefaultProjectID(ctx, workspaceID)
diff --git a/backend/api/v1/actuator_service_test.go b/backend/api/v1/actuator_service_test.go
index 88687172e6..a023da360b 100644
--- a/backend/api/v1/actuator_service_test.go
+++ b/backend/api/v1/actuator_service_test.go
@@ -9,12 +9,14 @@ import (
"connectrpc.com/connect"
"github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/encoding/protojson"
"google.golang.org/protobuf/reflect/protoreflect"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/testcontainer"
"github.com/bytebase/bytebase/backend/component/config"
- "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"
+ "github.com/bytebase/bytebase/backend/component/sample"
+ "github.com/bytebase/bytebase/backend/component/sample/saas"
"github.com/bytebase/bytebase/backend/enterprise"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
@@ -40,14 +42,14 @@ func TestAuthenticationInfoAndActuatorBoundary(t *testing.T) {
GitCommit: "sensitive-commit",
ExternalURL: "https://bytebase.example.com",
}
- sampleProjectManager, err := sampleprojectinstance.NewManagerFromURL(
- nil,
+ sampleManager, err := saas.NewManager(
+ stores,
fmt.Sprintf("postgresql://postgres:root-password@%s:%s/postgres?sslmode=disable", container.GetHost(), container.GetPort()),
nil,
- sampleprojectinstance.ManagerOptions{},
+ sample.ManagerOptions{ReplicaID: "replica-a"},
)
require.NoError(t, err)
- actuatorService := NewActuatorService(stores, profile, nil, licenseService, nil, sampleProjectManager)
+ actuatorService := NewActuatorService(stores, profile, nil, licenseService, sampleManager)
authService := NewAuthService(stores, "test-secret", licenseService, profile, nil)
publicResponse, err := authService.GetAuthenticationRestriction(ctx, connect.NewRequest(&v1pb.GetAuthenticationRestrictionRequest{}))
@@ -99,11 +101,13 @@ func TestAuthenticationInfoAndActuatorBoundary(t *testing.T) {
require.NoError(t, err)
authenticatedCtx := context.WithValue(ctx, common.UserContextKey, user)
authenticatedCtx = context.WithValue(authenticatedCtx, common.WorkspaceIDContextKey, workspaceID)
+ actuatorService.sampleManager = nil
nonSaaSResponse, err := actuatorService.GetActuatorInfo(authenticatedCtx, connect.NewRequest(&v1pb.GetActuatorInfoRequest{}))
require.NoError(t, err)
require.False(t, nonSaaSResponse.Msg.Sample.Available)
profile.SaaS = true
+ actuatorService.sampleManager = sampleManager
availableResponse, err := actuatorService.GetActuatorInfo(authenticatedCtx, connect.NewRequest(&v1pb.GetActuatorInfoRequest{}))
require.NoError(t, err)
@@ -111,18 +115,25 @@ func TestAuthenticationInfoAndActuatorBoundary(t *testing.T) {
defaultProjectID, err := stores.GetDefaultProjectID(ctx, workspaceID)
require.NoError(t, err)
- reservation, created, err := stores.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{
+ projectID := defaultProjectID
+ payload, err := protojson.Marshal(&storepb.SaaSSampleInstanceSetupPayload{
+ ProjectId: projectID,
+ InstanceId: "sample-instance",
+ Title: "Sample Project Instance",
+ DatabaseName: "sample-database",
+ RoleName: "sample-role",
+ })
+ require.NoError(t, err)
+ reservation, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
WorkspaceID: workspaceID,
- ProjectID: defaultProjectID,
- InstanceID: "sample-instance",
- DBName: "sample-database",
- RoleName: "sample-role",
ReplicaID: "replica-a",
+ Payload: payload,
})
require.NoError(t, err)
require.True(t, created)
expiresAt := time.Now().Add(7 * 24 * time.Hour).Truncate(time.Microsecond)
- activated, err := stores.ActivateSampleProjectInstance(ctx, workspaceID, reservation.InstanceID, reservation.ReplicaID, expiresAt)
+ activatedAt := expiresAt.Add(-7 * 24 * time.Hour)
+ activated, err := stores.ActivateSampleInstanceSetup(ctx, workspaceID, reservation.ReplicaID, []string{projectID}, activatedAt, &expiresAt)
require.NoError(t, err)
require.True(t, activated)
privateResponse, err := actuatorService.GetActuatorInfo(authenticatedCtx, connect.NewRequest(&v1pb.GetActuatorInfoRequest{}))
@@ -132,17 +143,18 @@ func TestAuthenticationInfoAndActuatorBoundary(t *testing.T) {
require.Equal(t, common.FormatWorkspace(workspaceID), privateResponse.Msg.Workspace)
require.NotEmpty(t, privateResponse.Msg.DefaultProject)
require.True(t, privateResponse.Msg.Sample.Available)
- require.Equal(t, common.FormatInstance(reservation.InstanceID), privateResponse.Msg.Sample.Instance)
- require.True(t, expiresAt.Equal(privateResponse.Msg.Sample.ExpireTime.AsTime()))
+ require.Len(t, privateResponse.Msg.Sample.Instances, 1)
+ require.Equal(t, common.FormatInstance("sample-instance"), privateResponse.Msg.Sample.Instances[0].Instance)
+ require.True(t, expiresAt.Equal(privateResponse.Msg.Sample.Instances[0].ExpireTime.AsTime()))
cleanupNow := expiresAt.Add(time.Second)
- cleanupResult, err := stores.WithLockedSampleProjectInstanceCleanupRecord(
+ cleanupResult, err := stores.WithLockedSampleInstanceSetupForCleanup(
ctx,
cleanupNow,
cleanupNow.Add(-time.Hour),
"",
- func(context.Context, *store.SampleProjectInstanceTx, *store.SampleProjectInstanceMessage) error {
- return nil
+ func(ctx context.Context, tx *store.SampleInstanceSetupTx, _ *store.SampleInstanceSetupMessage) error {
+ return tx.MarkDeleted(ctx, cleanupNow)
},
)
require.NoError(t, err)
@@ -150,5 +162,76 @@ func TestAuthenticationInfoAndActuatorBoundary(t *testing.T) {
deletedResponse, err := actuatorService.GetActuatorInfo(authenticatedCtx, connect.NewRequest(&v1pb.GetActuatorInfoRequest{}))
require.NoError(t, err)
require.True(t, deletedResponse.Msg.Sample.Available)
- require.Equal(t, common.FormatInstance(reservation.InstanceID), deletedResponse.Msg.Sample.Instance)
+ require.Len(t, deletedResponse.Msg.Sample.Instances, 1)
+ require.Equal(t, common.FormatInstance("sample-instance"), deletedResponse.Msg.Sample.Instances[0].Instance)
+ require.Nil(t, deletedResponse.Msg.Sample.Instances[0].ExpireTime)
+}
+
+func TestSetupSampleUsesUnifiedManagerAndAcceptsPair(t *testing.T) {
+ ctx := context.Background()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
+ require.NoError(t, migrator.MigrateSchema(ctx, container.GetDB()))
+
+ stores, err := store.New(ctx, fmt.Sprintf(
+ "host=%s port=%s user=postgres password=root-password database=postgres",
+ container.GetHost(), container.GetPort(),
+ ), false)
+ require.NoError(t, err)
+ t.Cleanup(func() { require.NoError(t, stores.Close()) })
+ const workspaceID = "setup-sample"
+ _, err = stores.CreateWorkspace(ctx, &store.WorkspaceMessage{
+ ResourceID: workspaceID,
+ Payload: &storepb.WorkspacePayload{Title: "Setup sample"},
+ require.NoError(t, err)
+ user, err := stores.CreateUser(ctx, &store.UserMessage{
+ Email: "[email protected]",
+ Name: "Admin",
+ Profile: &storepb.UserProfile{},
+ })
+ require.NoError(t, err)
+
+ manager := &actuatorSampleManagerStub{}
+ service := &ActuatorService{
+ store: stores,
+ profile: &config.Profile{},
+ sampleManager: manager,
+ }
+ requestCtx := context.WithValue(ctx, common.WorkspaceIDContextKey, workspaceID)
+ requestCtx = context.WithValue(requestCtx, common.UserContextKey, user)
+ _, err = service.SetupSample(requestCtx, connect.NewRequest(&v1pb.SetupSampleRequest{}))
+ require.NoError(t, err)
+ require.Equal(t, []sample.SetupRequest{{WorkspaceID: workspaceID, ProjectID: "project-sample"}}, manager.requests)
+ projectID := "project-sample"
+ project, err := stores.GetProject(ctx, &store.FindProjectMessage{Workspace: workspaceID, ResourceID: &projectID})
+ require.NoError(t, err)
+ require.NotNil(t, project)
+}
+
+type actuatorSampleManagerStub struct {
+ requests []sample.SetupRequest
+}
+
+func (s *actuatorSampleManagerStub) SetupSample(_ context.Context, request sample.SetupRequest) (*sample.SetupResult, error) {
+ s.requests = append(s.requests, request)
+ return &sample.SetupResult{Instances: []*store.InstanceMessage{{ResourceID: "sample-one"}, {ResourceID: "sample-two"}}}, nil
}
+
+func (*actuatorSampleManagerStub) Info(context.Context, string) (*sample.Info, error) {
+ return &sample.Info{}, nil
+}
+
+func (*actuatorSampleManagerStub) Start(context.Context, string) error { return nil }
+
+func (*actuatorSampleManagerStub) Cleanup(context.Context) error { return nil }
+
+func (*actuatorSampleManagerStub) ValidateInstanceRestore(context.Context, string, string) error {
+ return nil
+}
+
+func (*actuatorSampleManagerStub) HandleInstanceLifecycle(context.Context, string, string, bool) error {
+ return nil
+}
+
+func (*actuatorSampleManagerStub) Stop() {}
diff --git a/backend/api/v1/audit_redact_inventory_test.go b/backend/api/v1/audit_redact_inventory_test.go
index 7818c42a53..1d93c661bb 100644
--- a/backend/api/v1/audit_redact_inventory_test.go
+++ b/backend/api/v1/audit_redact_inventory_test.go
@@ -837,7 +837,7 @@ var auditRecordedFields = []string{
"bytebase.v1.SQLReviewRule.NamingRulePayload.format",
"bytebase.v1.SQLReviewRule.StringArrayRulePayload.list",
"bytebase.v1.SQLReviewRule.StringRulePayload.value",
- "bytebase.v1.SampleInfo.instance",
+ "bytebase.v1.SampleInfo.Instance.instance",
"bytebase.v1.SavedQuery.creator",
"bytebase.v1.SavedQuery.database",
"bytebase.v1.SavedQuery.folder",
diff --git a/backend/api/v1/instance_service.go b/backend/api/v1/instance_service.go
index 96e8bd1266..b6f5c1eee2 100644
--- a/backend/api/v1/instance_service.go
+++ b/backend/api/v1/instance_service.go
@@ -25,9 +25,7 @@ import (
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/component/config"
"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/component/sample"
"github.com/bytebase/bytebase/backend/enterprise"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
@@ -40,13 +38,18 @@ import (
// InstanceService implements the instance service.
type InstanceService struct {
v1connect.UnimplementedInstanceServiceHandler
- store *store.Store
- profile *config.Profile
- licenseService instanceLicenseService
- dbFactory *dbfactory.DBFactory
- schemaSyncer *schemasync.Syncer
- sampleInstanceManager *sampleinstance.Manager
- sampleProjectManager *sampleprojectinstance.Manager
+ store *store.Store
+ profile *config.Profile
+ licenseService instanceLicenseService
+ dbFactory *dbfactory.DBFactory
+ schemaSyncer *schemasync.Syncer
+ sampleManager instanceSampleManager
+}
+
+type instanceSampleManager interface {
+ SetupSample(context.Context, sample.SetupRequest) (*sample.SetupResult, error)
+ ValidateInstanceRestore(context.Context, string, string) error
+ HandleInstanceLifecycle(context.Context, string, string, bool) error
}
type instanceLicenseService interface {
@@ -200,15 +203,14 @@ 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, sampleProjectManager *sampleprojectinstance.Manager) *InstanceService {
+func NewInstanceService(store *store.Store, profile *config.Profile, licenseService *enterprise.LicenseService, dbFactory *dbfactory.DBFactory, schemaSyncer *schemasync.Syncer, sampleManager instanceSampleManager) *InstanceService {
return &InstanceService{
- store: store,
- profile: profile,
- licenseService: licenseService,
- dbFactory: dbFactory,
- schemaSyncer: schemaSyncer,
- sampleInstanceManager: sampleInstanceManager,
- sampleProjectManager: sampleProjectManager,
+ store: store,
+ profile: profile,
+ licenseService: licenseService,
+ dbFactory: dbFactory,
+ schemaSyncer: schemaSyncer,
+ sampleManager: sampleManager,
}
}
@@ -480,77 +482,53 @@ func (s *InstanceService) PrepareSampleProjectInstance(ctx context.Context, req
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 {
+ if s.profile == nil || !s.profile.SaaS || s.sampleManager == 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{
+ if err := s.instanceCountGuard(ctx); err != nil {
+ return nil, err
+ }
+ result, err := s.sampleManager.SetupSample(ctx, sample.SetupRequest{
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 len(result.Instances) != 1 {
+ return nil, connect.NewError(connect.CodeInternal, errors.New("Sample Project Instance preparation must return exactly one instance"))
}
- 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, _ 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)
- }
- return sampleprojectinstance.CreatePolicyResult{}, nil
+ return connect.NewResponse(s.convertToV1Instance(ctx, result.Instances[0])), nil
}
func sampleProjectInstanceConnectError(err error) error {
- switch sampleprojectinstance.FailureKindOf(err) {
- case sampleprojectinstance.FailureFailedPrecondition:
+ switch sample.FailureKindOf(err) {
+ case sample.FailureFailedPrecondition:
return connect.NewError(connect.CodeFailedPrecondition, err)
- case sampleprojectinstance.FailureUnavailable:
+ case sample.FailureUnavailable:
return connect.NewError(connect.CodeUnavailable, err)
- case sampleprojectinstance.FailureDeadlineExceeded:
+ case sample.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)
+ _, parseErr := common.GetProjectID(*parent)
if parseErr != nil {
return nil, err
}
- reservation, storeErr := s.store.GetSampleProjectInstance(ctx, common.GetWorkspaceIDFromContext(ctx))
+ reservation, storeErr := s.store.GetSampleInstanceSetup(ctx, common.GetWorkspaceIDFromContext(ctx))
if storeErr != nil {
return nil, connect.NewError(connect.CodeInternal, storeErr)
}
- if reservation != nil && reservation.ProjectID == missingProjectID {
+ if reservation != nil {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("Sample Project Instance entitlement is already consumed"))
}
return nil, err
@@ -1068,8 +1046,8 @@ func (s *InstanceService) DeleteInstance(ctx context.Context, req *connect.Reque
}
// Handle sample instance deletion if applicable
- if !alreadyDeleted && s.sampleInstanceManager != nil {
- if err := s.sampleInstanceManager.HandleInstanceDeletion(ctx, common.GetWorkspaceIDFromContext(ctx), instance.ResourceID); err != nil {
+ if !alreadyDeleted && s.sampleManager != nil {
+ if err := s.sampleManager.HandleInstanceLifecycle(ctx, common.GetWorkspaceIDFromContext(ctx), instance.ResourceID, true); err != nil {
slog.Warn("failed to handle sample instance deletion", log.BBError(err), slog.String("instance", instance.ResourceID))
}
}
@@ -1088,6 +1066,11 @@ func (s *InstanceService) UndeleteInstance(ctx context.Context, req *connect.Req
result := s.convertToV1Instance(ctx, instance)
return connect.NewResponse(result), nil
}
+ if s.sampleManager != nil {
+ if err := s.sampleManager.ValidateInstanceRestore(ctx, instance.Workspace, instance.ResourceID); err != nil {
+ return nil, sampleProjectInstanceConnectError(err)
+ }
+ }
activeTaskRunCount, err := s.store.GetActiveTaskRunCountForInstance(ctx, instance.ResourceID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
@@ -1115,8 +1098,8 @@ func (s *InstanceService) UndeleteInstance(ctx context.Context, req *connect.Req
}
// Handle sample instance undelete (restart) if applicable
- if s.sampleInstanceManager != nil {
- if err := s.sampleInstanceManager.HandleInstanceCreation(ctx, ins.ResourceID); err != nil {
+ if s.sampleManager != nil {
+ if err := s.sampleManager.HandleInstanceLifecycle(ctx, ins.Workspace, ins.ResourceID, false); err != nil {
slog.Warn("failed to handle sample instance undelete", log.BBError(err), slog.String("instance", ins.ResourceID))
}
}
diff --git a/backend/api/v1/instance_service_test.go b/backend/api/v1/instance_service_test.go
index a7a77aae26..ebc8ecb6f1 100644
--- a/backend/api/v1/instance_service_test.go
+++ b/backend/api/v1/instance_service_test.go
@@ -9,10 +9,11 @@ import (
"connectrpc.com/connect"
"github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/encoding/protojson"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/component/config"
- "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"
+ "github.com/bytebase/bytebase/backend/component/sample"
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"
@@ -26,10 +27,10 @@ func TestPrepareSampleProjectInstanceValidatesParentAndDeployment(t *testing.T)
ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)
service = &InstanceService{
- store: stores,
- profile: &config.Profile{},
- licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
- sampleProjectManager: &sampleprojectinstance.Manager{},
+ store: stores,
+ profile: &config.Profile{},
+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
+ sampleManager: &instanceSampleManagerStub{},
}
_, err = service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
Parent: common.FormatProject(projectID),
@@ -43,16 +44,77 @@ func TestPrepareSampleProjectInstanceValidatesParentAndDeployment(t *testing.T)
require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
}
+func TestPrepareSampleProjectInstanceRequiresSingleManagerResult(t *testing.T) {
+ ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)
+ manager := &instanceSampleManagerStub{
+ setupResult: &sample.SetupResult{Instances: []*store.InstanceMessage{
+ {ResourceID: "sample-one"},
+ {ResourceID: "sample-two"},
+ }},
+ }
+ service := &InstanceService{
+ store: stores,
+ profile: &config.Profile{SaaS: true},
+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
+ sampleManager: manager,
+ }
+
+ _, err := service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
+ Parent: common.FormatProject(projectID),
+ }))
+ require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
+ require.Len(t, manager.setupRequests, 1)
+}
+
+func TestSampleInstanceLifecycleHooksWrapMetadataUpdate(t *testing.T) {
+ ctx, stores, projectID, instanceID, _ := setupProjectInstanceLifecycleAPITest(t)
+ manager := &instanceSampleManagerStub{}
+ manager.validate = func(ctx context.Context, workspaceID, gotInstanceID string) error {
+ require.Equal(t, "default", workspaceID)
+ require.Equal(t, instanceID, gotInstanceID)
+ instance, err := stores.GetInstance(ctx, &store.FindInstanceMessage{Workspace: workspaceID, ResourceID: &gotInstanceID, ShowDeleted: true})
+ require.NoError(t, err)
+ require.True(t, instance.Deleted)
+ return nil
+ }
+ manager.lifecycle = func(ctx context.Context, workspaceID, gotInstanceID string, deleted bool) error {
+ instance, err := stores.GetInstance(ctx, &store.FindInstanceMessage{Workspace: workspaceID, ResourceID: &gotInstanceID, ShowDeleted: true})
+ require.NoError(t, err)
+ require.Equal(t, deleted, instance.Deleted)
+ return nil
+ }
+ service := &InstanceService{
+ store: stores,
+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
+ sampleManager: manager,
+ }
+ instanceName := common.FormatProjectInstance(projectID, instanceID)
+
+ _, err := service.DeleteInstance(ctx, connect.NewRequest(&v1pb.DeleteInstanceRequest{Name: instanceName}))
+ require.NoError(t, err)
+ require.Equal(t, []bool{true}, manager.lifecycleCalls)
+
+ _, err = service.UndeleteInstance(ctx, connect.NewRequest(&v1pb.UndeleteInstanceRequest{Name: instanceName}))
+ require.NoError(t, err)
+ require.Equal(t, 1, manager.validateCalls)
+ require.Equal(t, []bool{true, false}, manager.lifecycleCalls)
+}
+
func TestPrepareSampleProjectInstanceRejectsConsumedEntitlementAfterProjectDeletion(t *testing.T) {
ctx, stores, projectID, _, _ := setupProjectInstanceLifecycleAPITest(t)
workspaceID := common.GetWorkspaceIDFromContext(ctx)
- _, _, err := stores.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{
+ payload, err := protojson.Marshal(&storepb.SaaSSampleInstanceSetupPayload{
+ ProjectId: projectID,
+ InstanceId: "sample-deleted-project",
+ Title: "Sample Project Instance",
+ DatabaseName: "bb_sample_deleted_project",
+ RoleName: "bb_sample_role_deleted_project",
+ })
+ require.NoError(t, err)
+ _, _, err = stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
WorkspaceID: workspaceID,
- ProjectID: projectID,
- InstanceID: "sample-deleted-project",
- DBName: "bb_sample_deleted_project",
- RoleName: "bb_sample_role_deleted_project",
ReplicaID: "replica-a",
+ Payload: payload,
})
require.NoError(t, err)
_, err = stores.GetDB().ExecContext(ctx, `
@@ -62,10 +124,10 @@ func TestPrepareSampleProjectInstanceRejectsConsumedEntitlementAfterProjectDelet
`, workspaceID, projectID)
require.NoError(t, err)
service := &InstanceService{
- store: stores,
- profile: &config.Profile{SaaS: true},
- licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
- sampleProjectManager: &sampleprojectinstance.Manager{},
+ store: stores,
+ profile: &config.Profile{SaaS: true},
+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 10},
+ sampleManager: &instanceSampleManagerStub{},
}
_, err = service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
@@ -79,36 +141,56 @@ func TestSampleProjectInstanceConnectErrorMapsUnknownFailure(t *testing.T) {
require.Equal(t, connect.CodeInternal, connect.CodeOf(err))
}
-func TestSampleProjectInstanceCreatePolicyMapsCapacityDenial(t *testing.T) {
+func TestSampleProjectInstanceCapacityGuardMapsCapacityDenial(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))
+ err := service.instanceCountGuard(ctx)
+ require.Equal(t, connect.CodeResourceExhausted, connect.CodeOf(err))
}
-func TestSampleProjectInstanceCreatePolicyDoesNotConsumeActivationQuota(t *testing.T) {
+func TestSampleProjectInstanceCapacityGuardDoesNotConsumeActivationQuota(t *testing.T) {
ctx, stores, _, _, _ := setupProjectInstanceLifecycleAPITest(t)
service := &InstanceService{
store: stores,
profile: &config.Profile{SaaS: true},
licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 0},
}
- policy, err := service.sampleProjectInstanceCreatePolicy(ctx, common.GetWorkspaceIDFromContext(ctx))
- require.NoError(t, err)
- require.Nil(t, policy.DeniedReason)
+ require.NoError(t, service.instanceCountGuard(ctx))
+}
+
+type instanceSampleManagerStub struct {
+ setupResult *sample.SetupResult
+ setupErr error
+ setupRequests []sample.SetupRequest
+ validate func(context.Context, string, string) error
+ lifecycle func(context.Context, string, string, bool) error
+ validateCalls int
+ lifecycleCalls []bool
+}
+
+func (s *instanceSampleManagerStub) SetupSample(_ context.Context, request sample.SetupRequest) (*sample.SetupResult, error) {
+ s.setupRequests = append(s.setupRequests, request)
+ return s.setupResult, s.setupErr
}
-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 (s *instanceSampleManagerStub) ValidateInstanceRestore(ctx context.Context, workspaceID, instanceID string) error {
+ s.validateCalls++
+ if s.validate != nil {
+ return s.validate(ctx, workspaceID, instanceID)
+ }
+ return nil
+}
+
+func (s *instanceSampleManagerStub) HandleInstanceLifecycle(ctx context.Context, workspaceID, instanceID string, deleted bool) error {
+ s.lifecycleCalls = append(s.lifecycleCalls, deleted)
+ if s.lifecycle != nil {
+ return s.lifecycle(ctx, workspaceID, instanceID, deleted)
+ }
+ return nil
}
func TestValidateIAMCredentialForSaaS(t *testing.T) {
diff --git a/backend/api/v1/sample_project_instance_integration_test.go b/backend/api/v1/sample_project_instance_integration_test.go
index 5b3cb940e2..7b3a79850a 100644
--- a/backend/api/v1/sample_project_instance_integration_test.go
+++ b/backend/api/v1/sample_project_instance_integration_test.go
@@ -8,6 +8,8 @@ import (
"fmt"
"net/http/httptest"
"net/url"
+ "os"
+ "strings"
"sync"
"testing"
"time"
@@ -15,6 +17,7 @@ import (
"connectrpc.com/connect"
"github.com/jackc/pgx/v5"
"github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/encoding/protojson"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/permission"
@@ -22,14 +25,15 @@ import (
"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/component/sample"
+ "github.com/bytebase/bytebase/backend/component/sample/saas"
"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"
+ samplerunner "github.com/bytebase/bytebase/backend/runner/sample"
"github.com/bytebase/bytebase/backend/runner/schemasync"
"github.com/bytebase/bytebase/backend/store"
)
@@ -37,9 +41,7 @@ import (
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 },
- })
+ runner := samplerunner.NewRunner(fixture.manager)
prepared, err := fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
Parent: common.FormatProject(fixture.projectID),
@@ -105,16 +107,40 @@ func TestPrepareSampleProjectInstanceLifecycle(t *testing.T) {
})
require.NoError(t, err)
require.NotNil(t, instance)
- require.False(t, instance.Deleted)
+ require.True(t, instance.Deleted)
+ instances, err := fixture.store.ListInstances(ctx, &store.FindInstanceMessage{
+ Workspace: fixture.workspaceID,
+ ResourceID: &record.instance,
+ })
+ require.NoError(t, err)
+ require.Empty(t, instances)
+ databases, err := fixture.store.ListDatabases(ctx, &store.FindDatabaseMessage{
+ Workspace: fixture.workspaceID,
+ ProjectID: &fixture.projectID,
+ InstanceID: &record.instance,
+ DatabaseName: &record.database,
+ })
+ require.NoError(t, err)
+ require.Empty(t, databases)
database, err = fixture.store.GetDatabase(ctx, &store.FindDatabaseMessage{
Workspace: fixture.workspaceID,
ProjectID: &fixture.projectID,
InstanceID: &record.instance,
DatabaseName: &record.database,
+ ShowDeleted: true,
})
require.NoError(t, err)
require.NotNil(t, database)
require.False(t, database.Deleted)
+ _, err = fixture.service.UndeleteInstance(ctx, connect.NewRequest(&v1pb.UndeleteInstanceRequest{Name: prepared.Msg.Name}))
+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
+ archived, err := fixture.store.GetInstance(ctx, &store.FindInstanceMessage{
+ Workspace: fixture.workspaceID,
+ ResourceID: &record.instance,
+ ShowDeleted: true,
+ })
+ require.NoError(t, err)
+ require.True(t, archived.Deleted)
_, err = fixture.service.PrepareSampleProjectInstance(ctx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
Parent: common.FormatProject(fixture.projectID),
@@ -125,9 +151,7 @@ func TestPrepareSampleProjectInstanceLifecycle(t *testing.T) {
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 },
- })
+ runner := samplerunner.NewRunner(fixture.manager)
t.Run("ACL denies callers without project permission", func(t *testing.T) {
iamManager, err := iam.NewManager(fixture.store, nil, true)
@@ -165,6 +189,23 @@ func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(t *testing.T) {
fixture.service.profile.SaaS = true
})
+ t.Run("workspace without environments still prepares a sample", func(t *testing.T) {
+ workspaceID := "sample-workspace-no-environment"
+ projectID := "sample-project-no-environment"
+ _, err := fixture.store.GetDB().ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ($1)`, workspaceID)
+ require.NoError(t, err)
+ _, err = fixture.store.GetDB().ExecContext(ctx, `
+ INSERT INTO project (resource_id, workspace, name) VALUES ($1, $2, 'No environment sample')
+ `, projectID, workspaceID)
+ require.NoError(t, err)
+ requestCtx := context.WithValue(ctx, common.WorkspaceIDContextKey, workspaceID)
+ prepared, err := fixture.service.PrepareSampleProjectInstance(requestCtx, connect.NewRequest(&v1pb.PrepareSampleProjectInstanceRequest{
+ Parent: common.FormatProject(projectID),
+ }))
+ require.NoError(t, err)
+ require.Empty(t, prepared.Msg.GetEnvironment())
+ })
+
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
@@ -205,7 +246,7 @@ func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(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")
+ record, err := fixture.store.GetSampleInstanceSetup(staleCtx, "sample-workspace-stale")
require.NoError(t, err)
require.Nil(t, record)
require.False(t, fixture.target.databaseExists(staleCtx, allocation.Database))
@@ -226,7 +267,7 @@ func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(t *testing.T) {
}))
require.NoError(t, err)
record := fixture.sampleRecordFor(missingCtx, t, "sample-workspace-missing")
- require.NoError(t, fixture.target.dropResources(missingCtx, sampleprojectinstance.Allocation{
+ require.NoError(t, fixture.target.dropResources(missingCtx, testAllocation{
Database: record.database,
Role: record.role,
}))
@@ -243,7 +284,7 @@ func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(t *testing.T) {
}))
require.NoError(t, err)
record := fixture.sampleRecordFor(sessionCtx, t, "sample-workspace-external-session")
- allocation := sampleprojectinstance.Allocation{
+ allocation := testAllocation{
Database: record.database,
Role: record.role,
Password: fixture.allocationFor(sessionCtx, t, "sample-workspace-external-session").Password,
@@ -260,13 +301,12 @@ func TestPrepareSampleProjectInstanceAdditionalLifecycleCoverage(t *testing.T) {
}
type sampleProjectInstanceFixture struct {
- store *store.Store
- service *InstanceService
- manager *sampleprojectinstance.Manager
- sampleTarget *sampleprojectinstance.Target
- target *sampleTargetInspector
- workspaceID string
- projectID string
+ store *store.Store
+ service *InstanceService
+ manager *saas.Manager
+ target *sampleTargetInspector
+ workspaceID string
+ projectID string
}
func newSampleProjectInstanceFixture(t *testing.T, clock func() time.Time) (context.Context, *sampleProjectInstanceFixture) {
@@ -298,31 +338,28 @@ func newSampleProjectInstanceFixture(t *testing.T, clock func() time.Time) (cont
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, err := sampleprojectinstance.NewManagerFromURL(
+ manager, err := saas.NewManager(
stores,
targetURL,
syncer,
- sampleprojectinstance.ManagerOptions{Clock: clock, ReplicaID: "replica-a"},
+ sample.ManagerOptions{Clock: clock, ReplicaID: "replica-a"},
)
require.NoError(t, err)
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: 0},
- dbFactory: dbFactory,
- schemaSyncer: syncer,
- sampleProjectManager: manager,
+ store: stores,
+ profile: &config.Profile{SaaS: true},
+ licenseService: &instanceLicenseServiceStub{instanceLimit: 10, activatedInstanceLimit: 0},
+ dbFactory: dbFactory,
+ schemaSyncer: syncer,
+ sampleManager: manager,
},
- manager: manager,
- sampleTarget: sampleTarget,
- target: inspector,
- workspaceID: "sample-workspace",
- projectID: "sample-project",
+ manager: manager,
+ target: inspector,
+ workspaceID: "sample-workspace",
+ projectID: "sample-project",
}
}
@@ -359,21 +396,22 @@ func (f *sampleProjectInstanceFixture) sampleRecord(ctx context.Context, t *test
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,
- ))
+ setup, err := f.store.GetSampleInstanceSetup(ctx, workspaceID)
+ require.NoError(t, err)
+ require.NotNil(t, setup)
+ payload := &storepb.SaaSSampleInstanceSetupPayload{}
+ require.NoError(t, common.ProtojsonUnmarshaler.Unmarshal(setup.Payload, payload))
+ require.NotNil(t, setup.ExpiresAt)
+ record := sampleProjectInstanceRecord{
+ workspace: workspaceID,
+ project: payload.ProjectId,
+ instance: payload.InstanceId,
+ database: payload.DatabaseName,
+ role: payload.RoleName,
+ createdAt: setup.CreatedAt,
+ expiresAt: *setup.ExpiresAt,
+ deletedAt: setup.DeletedAt,
+ }
return record
}
@@ -384,7 +422,7 @@ func (f *sampleProjectInstanceFixture) sampleRecordCount(ctx context.Context, 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"
+ query := "SELECT COUNT(*) FROM sample_instance_setup"
args := []any{}
if workspaceID != "" {
query += " WHERE workspace = $1"
@@ -394,7 +432,14 @@ func (f *sampleProjectInstanceFixture) sampleRecordCountFor(ctx context.Context,
return count
}
-func (f *sampleProjectInstanceFixture) allocation(ctx context.Context, t *testing.T) sampleprojectinstance.Allocation {
+type testAllocation struct {
+ InstanceID string
+ Database string
+ Role string
+ Password string
+}
+
+func (f *sampleProjectInstanceFixture) allocation(ctx context.Context, t *testing.T) testAllocation {
return f.allocationFor(ctx, t, f.workspaceID)
}
@@ -402,7 +447,7 @@ func (f *sampleProjectInstanceFixture) allocationFor(
ctx context.Context,
t *testing.T,
workspaceID string,
-) sampleprojectinstance.Allocation {
+) testAllocation {
record := f.sampleRecordFor(ctx, t, workspaceID)
instance, err := f.store.GetInstance(ctx, &store.FindInstanceMessage{
Workspace: workspaceID,
@@ -413,15 +458,16 @@ func (f *sampleProjectInstanceFixture) allocationFor(
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(),
+ return testAllocation{
+ InstanceID: record.instance,
+ Database: record.database,
+ Role: record.role,
+ Password: dataSource.GetPassword(),
}
}
}
require.FailNow(t, "sample instance has no admin data source")
- return sampleprojectinstance.Allocation{}
+ return testAllocation{}
}
func (f *sampleProjectInstanceFixture) newWorkspaceProject(ctx context.Context, t *testing.T, suffix string) (context.Context, string) {
@@ -480,39 +526,47 @@ func (f *sampleProjectInstanceFixture) createPartialReservation(
t *testing.T,
workspaceID, projectID string,
createdAt time.Time,
-) sampleprojectinstance.Allocation {
+) testAllocation {
t.Helper()
- record, created, err := f.store.ReserveSampleProjectInstance(ctx, &store.SampleProjectInstanceMessage{
+ payload := &storepb.SaaSSampleInstanceSetupPayload{
+ ProjectId: projectID,
+ InstanceId: sampleInstanceID(workspaceID),
+ Title: "Sample Project Instance",
+ EnvironmentId: ptr("test"),
+ DatabaseName: sampleDatabaseName(workspaceID),
+ RoleName: sampleRoleName(workspaceID),
+ }
+ encoded, err := protojson.Marshal(payload)
+ require.NoError(t, err)
+ _, created, err := f.store.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
WorkspaceID: workspaceID,
- ProjectID: projectID,
- InstanceID: sampleInstanceID(workspaceID),
- DBName: sampleDatabaseName(workspaceID),
- RoleName: sampleRoleName(workspaceID),
ReplicaID: "replica-a",
+ Payload: encoded,
})
require.NoError(t, err)
require.True(t, created)
- allocation := sampleprojectinstance.Allocation{
- Database: record.DBName,
- Role: record.RoleName,
- Password: "sample-partial-password",
+ allocation := testAllocation{
+ InstanceID: payload.InstanceId,
+ Database: payload.DatabaseName,
+ Role: payload.RoleName,
+ Password: "sample-partial-password",
}
- require.NoError(t, f.sampleTarget.Provision(ctx, allocation))
- config, err := f.sampleTarget.InstanceConfig(allocation)
- require.NoError(t, err)
+ require.NoError(t, f.target.provision(ctx, allocation))
instance, err := f.store.CreateInstance(ctx, &store.InstanceMessage{
Workspace: workspaceID,
ProjectID: &projectID,
EnvironmentID: ptr("test"),
- ResourceID: record.InstanceID,
+ ResourceID: payload.InstanceId,
Metadata: &storepb.Instance{
Title: "Sample Project Instance",
Engine: storepb.Engine_POSTGRES,
Activation: false,
- DataSources: []*storepb.DataSource{
- config.AdminDataSource,
- },
- SyncDatabases: &storepb.SyncDatabases{Databases: config.SyncDatabaseNames},
+ DataSources: []*storepb.DataSource{{
+ Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: f.target.config.Host,
+ Port: fmt.Sprint(f.target.config.Port), Database: allocation.Database,
+ Username: allocation.Role, Password: allocation.Password, UseSsl: true, VerifyTlsCertificate: true, SslCa: f.target.sslCA,
+ }},
+ SyncDatabases: &storepb.SyncDatabases{Databases: []string{allocation.Database}},
},
})
require.NoError(t, err)
@@ -520,8 +574,8 @@ func (f *sampleProjectInstanceFixture) createPartialReservation(
require.NoError(t, err)
require.Len(t, databases, 1)
_, err = f.store.GetDB().ExecContext(ctx, `
- UPDATE sample_project_instance
- SET created_at = $1
+ UPDATE sample_instance_setup
+ SET updated_at = $1
WHERE workspace = $2
`, createdAt, workspaceID)
require.NoError(t, err)
@@ -547,13 +601,18 @@ func sampleRoleName(workspaceID string) string {
type sampleTargetInspector struct {
config *pgx.ConnConfig
+ sslCA string
}
func newSampleTargetInspector(t *testing.T, targetURL string) *sampleTargetInspector {
t.Helper()
config, err := pgx.ParseConfig(targetURL)
require.NoError(t, err)
- return &sampleTargetInspector{config: config}
+ parsed, err := url.Parse(targetURL)
+ require.NoError(t, err)
+ sslCA, err := os.ReadFile(parsed.Query().Get("sslrootcert"))
+ require.NoError(t, err)
+ return &sampleTargetInspector{config: config, sslCA: string(sslCA)}
}
func prepareSampleTargetBaseline(ctx context.Context, db *sql.DB) error {
@@ -600,14 +659,53 @@ func (t *sampleTargetInspector) databaseExists(ctx context.Context, database str
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 {
+func (t *sampleTargetInspector) provision(ctx context.Context, allocation testAllocation) error {
+ admin, err := t.connect(ctx, "", "", "")
+ if err != nil {
+ return err
+ }
+ defer admin.Close(ctx)
+ if _, err := admin.Exec(ctx, fmt.Sprintf(
+ "CREATE ROLE %s LOGIN PASSWORD %s",
+ pgx.Identifier{allocation.Role}.Sanitize(),
+ quoteTestLiteral(allocation.Password),
+ )); err != nil {
+ return err
+ }
+ if _, err := admin.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{allocation.Database}.Sanitize())); err != nil {
+ return err
+ }
+ if _, err := admin.Exec(ctx, fmt.Sprintf(
+ "GRANT CONNECT, CREATE, TEMPORARY ON DATABASE %s TO %s",
+ pgx.Identifier{allocation.Database}.Sanitize(),
+ pgx.Identifier{allocation.Role}.Sanitize(),
+ )); err != nil {
+ return err
+ }
+ database, err := t.connect(ctx, allocation.Database, "", "")
+ if err != nil {
+ return err
+ }
+ defer database.Close(ctx)
+ _, err = database.Exec(ctx, fmt.Sprintf(
+ "GRANT USAGE, CREATE ON SCHEMA public TO %s",
+ pgx.Identifier{allocation.Role}.Sanitize(),
+ ))
+ return err
+}
+
+func quoteTestLiteral(value string) string {
+ return "'" + strings.ReplaceAll(value, "'", "''") + "'"
+}
+
+func (t *sampleTargetInspector) sampleConnection(ctx context.Context, tst *testing.T, allocation testAllocation) *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 {
+func (t *sampleTargetInspector) sampleEmployeeCount(ctx context.Context, allocation testAllocation, 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")
@@ -623,7 +721,7 @@ func (t *sampleTargetInspector) sampleEmployeeCount(ctx context.Context, allocat
func (t *sampleTargetInspector) assertSeededOwnershipAndDDL(
ctx context.Context,
tst *testing.T,
- allocation sampleprojectinstance.Allocation,
+ allocation testAllocation,
) {
tst.Helper()
sample := t.sampleConnection(ctx, tst, allocation)
@@ -652,7 +750,7 @@ func (t *sampleTargetInspector) assertSeededOwnershipAndDDL(
}
}
-func (t *sampleTargetInspector) assertIsolation(ctx context.Context, tst *testing.T, allocation sampleprojectinstance.Allocation) {
+func (t *sampleTargetInspector) assertIsolation(ctx context.Context, tst *testing.T, allocation testAllocation) {
tst.Helper()
admin, err := t.connect(ctx, "", "", "")
require.NoError(tst, err)
@@ -695,7 +793,7 @@ func (t *sampleTargetInspector) assertIsolation(ctx context.Context, tst *testin
require.True(tst, publicCreate)
}
-func (t *sampleTargetInspector) dropResources(ctx context.Context, allocation sampleprojectinstance.Allocation) error {
+func (t *sampleTargetInspector) dropResources(ctx context.Context, allocation testAllocation) error {
admin, err := t.connect(ctx, "", "", "")
if err != nil {
return err
@@ -714,7 +812,7 @@ func (t *sampleTargetInspector) dropResources(ctx context.Context, allocation sa
return nil
}
-func (t *sampleTargetInspector) externalRoleConnection(ctx context.Context, tst *testing.T, allocation sampleprojectinstance.Allocation) *pgx.Conn {
+func (t *sampleTargetInspector) externalRoleConnection(ctx context.Context, tst *testing.T, allocation testAllocation) *pgx.Conn {
tst.Helper()
admin, err := t.connect(ctx, "", "", "")
require.NoError(tst, err)
diff --git a/backend/component/sample/manager.go b/backend/component/sample/manager.go
new file mode 100644
index 0000000000..01185b198f
--- /dev/null
+++ b/backend/component/sample/manager.go
@@ -0,0 +1,18 @@
+package sample
+
+import (
+ "context"
+ "time"
+)
+
+// SleepContext waits for duration or returns the context error.
+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
+ }
+}
diff --git a/backend/component/sample/metadata.go b/backend/component/sample/metadata.go
new file mode 100644
index 0000000000..edd0ce4148
--- /dev/null
+++ b/backend/component/sample/metadata.go
@@ -0,0 +1,152 @@
+package sample
+
+import (
+ "context"
+
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+// Registration contains the ordinary Instance metadata for one sample.
+type Registration struct {
+ WorkspaceID string
+ InstanceProjectID *string
+ EnvironmentID *string
+ InstanceID string
+ Title string
+ AdminDataSource *storepb.DataSource
+ SyncDatabaseNames []string
+}
+
+// MetadataLookup identifies one implementation-owned Instance and database.
+type MetadataLookup struct {
+ WorkspaceID string
+ InstanceProjectID *string
+ DatabaseProjectID string
+ InstanceID string
+ DatabaseName string
+}
+
+// MetadataState is the current ordinary Instance/database state.
+type MetadataState struct {
+ ProjectActive bool
+ InstanceMatches bool
+ Instance *store.InstanceMessage
+ Database *store.DatabaseMessage
+}
+
+// Active reports whether all expected metadata is active.
+func (s MetadataState) Active() bool {
+ return s.ProjectActive && s.InstanceMatches && s.Instance != nil && !s.Instance.Deleted && s.Database != nil && !s.Database.Deleted
+}
+
+// LookupMetadata returns the metadata matching lookup.
+func LookupMetadata(ctx context.Context, stores *store.Store, lookup MetadataLookup) (MetadataState, error) {
+ project, err := stores.GetProject(ctx, &store.FindProjectMessage{
+ ResourceID: &lookup.DatabaseProjectID,
+ Workspace: lookup.WorkspaceID,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return MetadataState{}, errors.Wrap(err, "get sample database project")
+ }
+ state := MetadataState{ProjectActive: project != nil && !project.Deleted}
+ instance, err := stores.GetInstance(ctx, &store.FindInstanceMessage{
+ Workspace: lookup.WorkspaceID,
+ ResourceID: &lookup.InstanceID,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return MetadataState{}, errors.Wrap(err, "get sample instance")
+ }
+ state.Instance = instance
+ state.InstanceMatches = instance != nil && sameOptionalString(instance.ProjectID, lookup.InstanceProjectID)
+ database, err := stores.GetDatabase(ctx, &store.FindDatabaseMessage{
+ Workspace: lookup.WorkspaceID,
+ ProjectID: &lookup.DatabaseProjectID,
+ InstanceID: &lookup.InstanceID,
+ DatabaseName: &lookup.DatabaseName,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return MetadataState{}, errors.Wrap(err, "get sample database")
+ }
+ state.Database = database
+ return state, nil
+}
+
+func sameOptionalString(a, b *string) bool {
+ if a == nil || b == nil {
+ return a == nil && b == nil
+ }
+ return *a == *b
+}
+
+// CreateMetadata registers an ordinary Bytebase Instance.
+func CreateMetadata(ctx context.Context, stores *store.Store, registration Registration) (*store.InstanceMessage, error) {
+ return stores.CreateInstance(ctx, &store.InstanceMessage{
+ Workspace: registration.WorkspaceID,
+ ProjectID: registration.InstanceProjectID,
+ EnvironmentID: registration.EnvironmentID,
+ ResourceID: registration.InstanceID,
+ Metadata: &storepb.Instance{
+ Title: registration.Title,
+ Engine: storepb.Engine_POSTGRES,
+ Activation: false,
+ DataSources: []*storepb.DataSource{
+ registration.AdminDataSource,
+ },
+ SyncDatabases: &storepb.SyncDatabases{Databases: registration.SyncDatabaseNames},
+ },
+ })
+}
+
+// TransferDatabase transfers one discovered sample database.
+func TransferDatabase(ctx context.Context, stores *store.Store, projectID, instanceID, databaseName string) error {
+ _, err := stores.UpdateDatabase(ctx, &store.UpdateDatabaseMessage{
+ InstanceID: instanceID,
+ DatabaseName: databaseName,
+ ProjectID: &projectID,
+ })
+ return errors.Wrap(err, "transfer sample database")
+}
+
+// ArchiveMetadata soft-deletes an implementation-owned sample Instance.
+func ArchiveMetadata(ctx context.Context, stores *store.Store, workspaceID string, instanceProjectID *string, instanceID string) (bool, error) {
+ instance, err := stores.GetInstance(ctx, &store.FindInstanceMessage{
+ Workspace: workspaceID,
+ ResourceID: &instanceID,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return false, errors.Wrap(err, "get sample instance for archive")
+ }
+ if instance == nil {
+ return false, nil
+ }
+ if !sameOptionalString(instance.ProjectID, instanceProjectID) {
+ return false, errors.Errorf("sample instance %q belongs to a different project", instanceID)
+ }
+ if !instance.Deleted {
+ deleted := true
+ if _, err := stores.UpdateInstance(ctx, &store.UpdateInstanceMessage{
+ ResourceID: &instanceID,
+ Workspace: workspaceID,
+ Deleted: &deleted,
+ }); err != nil {
+ return false, errors.Wrap(err, "soft delete sample instance")
+ }
+ }
+ return true, nil
+}
+
+// PurgePartialMetadata removes metadata created by an unactivated setup.
+func PurgePartialMetadata(ctx context.Context, stores *store.Store, workspaceID string, instanceProjectID *string, instanceID string) error {
+ found, err := ArchiveMetadata(ctx, stores, workspaceID, instanceProjectID, instanceID)
+ if err != nil || !found {
+ return err
+ }
+ return errors.Wrap(stores.DeleteInstance(ctx, workspaceID, instanceID), "delete partial sample instance")
+}
diff --git a/backend/component/sample/saas/manager.go b/backend/component/sample/saas/manager.go
new file mode 100644
index 0000000000..b1dffa8f07
--- /dev/null
+++ b/backend/component/sample/saas/manager.go
@@ -0,0 +1,527 @@
+// Package saas manages project-level sample instances backed by an external
+// PostgreSQL target.
+package saas
+
+import (
+ "context"
+ "crypto/rand"
+ "crypto/sha256"
+ "encoding/base64"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "io"
+ "log/slog"
+ "sync"
+ "time"
+
+ "google.golang.org/protobuf/encoding/protojson"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/component/sample"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/runner/schemasync"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+const (
+ sampleTitle = "Sample Project Instance"
+ sampleLifetime = 7 * 24 * time.Hour
+ prepareDeadline = 3 * time.Minute
+ provisionDeadline = 2 * time.Minute
+ compensationDeadline = time.Minute
+ cleanupValidationDeadline = 10 * time.Second
+ targetAvailabilityDeadline = 3 * time.Second
+ targetAvailabilityCacheTTL = time.Minute
+ cleanupAttemptDeadline = time.Minute
+ staleReservationAge = time.Hour
+ replicaHeartbeatStaleness = time.Minute
+ pollInitialDelay = 10 * time.Millisecond
+ pollMaxDelay = time.Second
+)
+
+// Manager is the SaaS sample implementation.
+type Manager struct {
+ store *store.Store
+ target *postgresTarget
+ syncer *schemasync.Syncer
+ clock func() time.Time
+ random io.Reader
+ logger *slog.Logger
+ replicaID string
+
+ availabilityMu sync.Mutex
+ availabilityCheckedAt time.Time
+ available bool
+}
+
+// NewManager creates a SaaS sample manager from a PostgreSQL target URL.
+func NewManager(stores *store.Store, targetURL string, syncer *schemasync.Syncer, options sample.ManagerOptions) (*Manager, error) {
+ target, err := newPostgresTarget(targetURL)
+ if err != nil {
+ return nil, err
+ }
+ 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: stores,
+ target: target,
+ syncer: syncer,
+ clock: options.Clock,
+ random: options.Random,
+ logger: options.Logger,
+ replicaID: options.ReplicaID,
+ }, nil
+}
+
+func sampleNames(instanceID string) (string, string) {
+ sum := sha256.Sum256([]byte(instanceID))
+ token := fmt.Sprintf("%x", sum[:8])
+ return "bb_sample_" + token, "bb_sample_role_" + token
+}
+
+// Available reports cached target readiness, refreshing stale state with a
+// short probe.
+func (m *Manager) Available(ctx context.Context) bool {
+ if m == nil || m.target == nil {
+ return false
+ }
+ m.availabilityMu.Lock()
+ defer m.availabilityMu.Unlock()
+ now := m.clock()
+ if !m.availabilityCheckedAt.IsZero() && now.Before(m.availabilityCheckedAt.Add(targetAvailabilityCacheTTL)) {
+ return m.available
+ }
+ validationCtx, cancel := context.WithTimeout(ctx, targetAvailabilityDeadline)
+ defer cancel()
+ m.available = m.target.validate(validationCtx) == nil
+ m.availabilityCheckedAt = m.clock()
+ return m.available
+}
+
+func (m *Manager) recordAvailability(available bool) {
+ m.availabilityMu.Lock()
+ defer m.availabilityMu.Unlock()
+ m.available = available
+ m.availabilityCheckedAt = m.clock()
+}
+
+// SetupSample provisions and registers one seven-day sample instance.
+func (m *Manager) SetupSample(ctx context.Context, request sample.SetupRequest) (*sample.SetupResult, error) {
+ if m == nil || m.store == nil || m.target == nil || m.syncer == nil || m.replicaID == "" {
+ return nil, errors.New("SaaS sample manager is not configured")
+ }
+ if request.WorkspaceID == "" || request.ProjectID == "" {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("SaaS sample requires workspace and project"))
+ }
+ lifecycleCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), prepareDeadline)
+ defer cancel()
+ setup, created, err := m.reserve(lifecycleCtx, request)
+ if err != nil {
+ return nil, err
+ }
+ delay := pollInitialDelay
+ for {
+ payload, err := decodePayload(setup)
+ if err != nil {
+ return nil, err
+ }
+ if payload.ProjectId != request.ProjectID || setup.DeletedAt != nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("sample setup entitlement is already consumed"))
+ }
+ if created {
+ return m.prepareOwned(lifecycleCtx, setup, payload, false)
+ }
+ if setup.ActivatedAt != nil {
+ return m.activeSetup(lifecycleCtx, setup, payload)
+ }
+ claimed, ok, err := m.store.ClaimSampleInstanceSetup(
+ lifecycleCtx,
+ setup.WorkspaceID,
+ setup.UpdatedAt,
+ m.replicaID,
+ prepareDeadline,
+ replicaHeartbeatStaleness,
+ )
+ if err != nil {
+ return nil, errors.Join(errors.New("failed to claim abandoned SaaS sample setup"), err)
+ }
+ if ok {
+ claimedPayload, err := decodePayload(claimed)
+ if err != nil {
+ return nil, err
+ }
+ return m.prepareOwned(lifecycleCtx, claimed, claimedPayload, true)
+ }
+ if err := sample.SleepContext(lifecycleCtx, delay); err != nil {
+ return nil, sample.NewFailure(sample.FailureDeadlineExceeded, err)
+ }
+ if delay < pollMaxDelay {
+ delay *= 2
+ if delay > pollMaxDelay {
+ delay = pollMaxDelay
+ }
+ }
+ setup, err = m.store.GetSampleInstanceSetup(lifecycleCtx, request.WorkspaceID)
+ if err != nil {
+ return nil, errors.Join(errors.New("failed to poll SaaS sample setup"), err)
+ }
+ created = false
+ if setup == nil {
+ setup, created, err = m.reserve(lifecycleCtx, request)
+ if err != nil {
+ return nil, err
+ }
+ }
+ }
+}
+
+func (m *Manager) reserve(ctx context.Context, request sample.SetupRequest) (*store.SampleInstanceSetupMessage, bool, error) {
+ instanceID, err := randomInstanceID(m.random)
+ if err != nil {
+ return nil, false, errors.Join(errors.New("failed to generate SaaS sample instance ID"), err)
+ }
+ database, role := sampleNames(instanceID)
+ payload := &storepb.SaaSSampleInstanceSetupPayload{
+ ProjectId: request.ProjectID,
+ InstanceId: instanceID,
+ Title: sampleTitle,
+ DatabaseName: database,
+ RoleName: role,
+ }
+ environments, err := m.store.GetEnvironment(ctx, request.WorkspaceID)
+ if err != nil {
+ return nil, false, errors.Join(errors.New("failed to list SaaS sample environments"), err)
+ }
+ if values := environments.GetEnvironments(); len(values) > 0 {
+ payload.EnvironmentId = &values[0].Id
+ }
+ encoded, err := protojson.Marshal(payload)
+ if err != nil {
+ return nil, false, errors.Join(errors.New("failed to encode SaaS sample setup"), err)
+ }
+ return m.store.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: request.WorkspaceID,
+ ReplicaID: m.replicaID,
+ Payload: encoded,
+ })
+}
+
+func decodePayload(setup *store.SampleInstanceSetupMessage) (*storepb.SaaSSampleInstanceSetupPayload, error) {
+ if setup == nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("sample setup is missing"))
+ }
+ payload := &storepb.SaaSSampleInstanceSetupPayload{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal(setup.Payload, payload); err != nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("invalid SaaS sample setup payload"))
+ }
+ if payload.ProjectId == "" || payload.InstanceId == "" || payload.DatabaseName == "" || payload.RoleName == "" {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("incomplete SaaS sample setup payload"))
+ }
+ return payload, nil
+}
+
+func (m *Manager) prepareOwned(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SaaSSampleInstanceSetupPayload, takeover bool) (*sample.SetupResult, error) {
+ workCtx, cancel := preparationWorkContext(ctx)
+ defer cancel()
+ if takeover {
+ if err := m.reconcile(workCtx, setup, payload); err != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, err)
+ }
+ }
+ validationCtx, validationCancel := context.WithTimeout(workCtx, cleanupValidationDeadline)
+ err := m.target.validate(validationCtx)
+ validationCancel()
+ m.recordAvailability(err == nil)
+ if err != nil {
+ return nil, m.discardReservation(ctx, setup, mapTargetError(err))
+ }
+
+ password, err := randomPassword(m.random)
+ if err != nil {
+ return nil, m.discardReservation(ctx, setup, err)
+ }
+ physical := allocation{database: payload.DatabaseName, role: payload.RoleName, password: password}
+ config, err := m.target.instanceConfig(physical)
+ if err != nil {
+ return nil, m.discardReservation(ctx, setup, mapTargetError(err))
+ }
+ provisionCtx, provisionCancel := context.WithTimeout(workCtx, provisionDeadline)
+ err = m.target.provision(provisionCtx, physical)
+ timedOut := errors.Is(provisionCtx.Err(), context.DeadlineExceeded)
+ provisionCancel()
+ if err != nil {
+ if timedOut {
+ err = sample.NewFailure(sample.FailureDeadlineExceeded, context.DeadlineExceeded)
+ } else {
+ err = mapTargetError(err)
+ }
+ return m.compensate(ctx, setup, payload, err)
+ }
+ projectID := payload.ProjectId
+ registered, err := sample.CreateMetadata(workCtx, m.store, sample.Registration{
+ WorkspaceID: setup.WorkspaceID,
+ InstanceProjectID: &projectID,
+ EnvironmentID: payload.EnvironmentId,
+ InstanceID: payload.InstanceId,
+ Title: payload.Title,
+ AdminDataSource: config.adminDataSource,
+ SyncDatabaseNames: config.syncDatabaseNames,
+ })
+ if err != nil {
+ return m.compensate(ctx, setup, payload, errors.Join(errors.New("failed to create SaaS sample metadata"), err))
+ }
+ synced, _, databases, err := m.syncer.SyncInstance(workCtx, registered)
+ if err != nil {
+ return m.compensate(ctx, setup, payload, errors.Join(errors.New("failed to discover SaaS sample database"), err))
+ }
+ if len(databases) != 1 || databases[0].DatabaseName != payload.DatabaseName || databases[0].Deleted {
+ return m.compensate(ctx, setup, payload, errors.New("SaaS sample database discovery invariant failed"))
+ }
+ if err := sample.TransferDatabase(workCtx, m.store, payload.ProjectId, payload.InstanceId, payload.DatabaseName); err != nil {
+ return m.compensate(ctx, setup, payload, err)
+ }
+ activatedAt := m.clock()
+ expiresAt := activatedAt.Add(sampleLifetime)
+ activated, err := m.store.ActivateSampleInstanceSetup(
+ workCtx,
+ setup.WorkspaceID,
+ m.replicaID,
+ []string{payload.ProjectId},
+ activatedAt,
+ &expiresAt,
+ )
+ if err != nil || !activated {
+ return m.handleActivationFailure(ctx, setup, payload, errors.Join(errors.New("failed to activate SaaS sample setup"), err))
+ }
+ m.syncer.SyncDatabasesAsync(databases)
+ return &sample.SetupResult{Instances: []*store.InstanceMessage{synced}}, nil
+}
+
+func (m *Manager) activeSetup(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SaaSSampleInstanceSetupPayload) (*sample.SetupResult, error) {
+ projectID := payload.ProjectId
+ state, err := sample.LookupMetadata(ctx, m.store, sample.MetadataLookup{
+ WorkspaceID: setup.WorkspaceID,
+ InstanceProjectID: &projectID,
+ DatabaseProjectID: payload.ProjectId,
+ InstanceID: payload.InstanceId,
+ DatabaseName: payload.DatabaseName,
+ })
+ if err != nil {
+ return nil, err
+ }
+ if !state.Active() {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("SaaS sample metadata is not active"))
+ }
+ return &sample.SetupResult{Instances: []*store.InstanceMessage{state.Instance}}, nil
+}
+
+func (m *Manager) reconcile(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SaaSSampleInstanceSetupPayload) error {
+ projectID := payload.ProjectId
+ metadataErr := sample.PurgePartialMetadata(ctx, m.store, setup.WorkspaceID, &projectID, payload.InstanceId)
+ targetErr := m.target.remove(ctx, allocation{database: payload.DatabaseName, role: payload.RoleName})
+ return errors.Join(metadataErr, targetErr)
+}
+
+func (m *Manager) compensate(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SaaSSampleInstanceSetupPayload, original error) (*sample.SetupResult, error) {
+ compensationCtx, cancel := context.WithTimeout(ctx, compensationDeadline)
+ defer cancel()
+ current, err := m.store.GetSampleInstanceSetup(compensationCtx, setup.WorkspaceID)
+ if err != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ if current != nil && current.ActivatedAt != nil && current.DeletedAt == nil {
+ currentPayload, err := decodePayload(current)
+ if err != nil {
+ return nil, err
+ }
+ return m.activeSetup(compensationCtx, current, currentPayload)
+ }
+ if current == nil || current.ReplicaID != m.replicaID || current.DeletedAt != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, errors.Join(original, errors.New("SaaS sample setup ownership changed before compensation")))
+ }
+ if err := m.reconcile(compensationCtx, current, payload); err != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ deleted, err := m.store.DeletePendingSampleInstanceSetup(compensationCtx, setup.WorkspaceID, m.replicaID)
+ if err != nil || !deleted {
+ return nil, sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ return nil, original
+}
+
+func (m *Manager) discardReservation(ctx context.Context, setup *store.SampleInstanceSetupMessage, original error) error {
+ deleted, err := m.store.DeletePendingSampleInstanceSetup(ctx, setup.WorkspaceID, m.replicaID)
+ if err != nil || !deleted {
+ return sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ return original
+}
+
+func (m *Manager) handleActivationFailure(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SaaSSampleInstanceSetupPayload, original error) (*sample.SetupResult, error) {
+ current, err := m.store.GetSampleInstanceSetup(ctx, setup.WorkspaceID)
+ if err != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ if current != nil && current.ActivatedAt != nil && current.DeletedAt == nil {
+ currentPayload, err := decodePayload(current)
+ if err != nil {
+ return nil, err
+ }
+ return m.activeSetup(ctx, current, currentPayload)
+ }
+ if current == nil || current.ReplicaID != m.replicaID || current.DeletedAt != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, original)
+ }
+ return m.compensate(ctx, setup, payload, original)
+}
+
+// Info returns target readiness and the provisioned SaaS instance.
+func (m *Manager) Info(ctx context.Context, workspaceID string) (*sample.Info, error) {
+ if m == nil {
+ return &sample.Info{}, nil
+ }
+ info := &sample.Info{Available: m.Available(ctx)}
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil || setup == nil || setup.ActivatedAt == nil {
+ return info, err
+ }
+ payload, err := decodePayload(setup)
+ if err != nil {
+ return nil, err
+ }
+ instance := sample.InstanceInfo{Instance: common.FormatInstance(payload.InstanceId)}
+ if setup.DeletedAt == nil {
+ instance.ExpireTime = setup.ExpiresAt
+ }
+ info.Instances = append(info.Instances, instance)
+ return info, nil
+}
+
+// Start is a no-op because the external PostgreSQL server is already running.
+func (*Manager) Start(context.Context, string) error { return nil }
+
+// Cleanup removes stale pending and expired SaaS sample setups.
+func (m *Manager) Cleanup(ctx context.Context) error {
+ if m == nil || m.store == nil || m.target == nil {
+ return errors.New("SaaS sample manager is not configured")
+ }
+ now := m.clock()
+ staleBefore := now.Add(-staleReservationAge)
+ count, err := m.store.CountSampleInstanceSetupsForCleanup(ctx, now, staleBefore)
+ if err != nil || count == 0 {
+ return err
+ }
+ validationCtx, cancel := context.WithTimeout(ctx, cleanupValidationDeadline)
+ err = m.target.validateForCleanup(validationCtx)
+ cancel()
+ if err != nil {
+ return mapTargetError(err)
+ }
+ var cleanupErr error
+ for afterWorkspace := ""; ; {
+ result, err := m.store.WithLockedSampleInstanceSetupForCleanup(
+ ctx,
+ now,
+ staleBefore,
+ afterWorkspace,
+ func(callbackCtx context.Context, tx *store.SampleInstanceSetupTx, setup *store.SampleInstanceSetupMessage) error {
+ attemptCtx, attemptCancel := context.WithTimeout(callbackCtx, cleanupAttemptDeadline)
+ defer attemptCancel()
+ payload, err := decodePayload(setup)
+ if err != nil {
+ return err
+ }
+ if setup.ActivatedAt == nil {
+ if err := m.reconcile(attemptCtx, setup, payload); err != nil {
+ return err
+ }
+ return tx.DeleteReservation(attemptCtx)
+ }
+ if err := m.target.remove(attemptCtx, allocation{database: payload.DatabaseName, role: payload.RoleName}); err != nil {
+ return err
+ }
+ projectID := payload.ProjectId
+ if _, err := sample.ArchiveMetadata(attemptCtx, m.store, setup.WorkspaceID, &projectID, payload.InstanceId); err != nil {
+ return err
+ }
+ return tx.MarkDeleted(attemptCtx, now)
+ },
+ )
+ if err != nil {
+ return errors.Join(cleanupErr, err)
+ }
+ if !result.Found {
+ return cleanupErr
+ }
+ afterWorkspace = result.WorkspaceID
+ cleanupErr = errors.Join(cleanupErr, result.CallbackErr)
+ }
+}
+
+// ValidateInstanceRestore rejects restoring a physically deleted sample.
+func (m *Manager) ValidateInstanceRestore(ctx context.Context, workspaceID, instanceID string) error {
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil || setup == nil {
+ return err
+ }
+ payload, err := decodePayload(setup)
+ if err != nil {
+ return err
+ }
+ if payload.InstanceId == instanceID && setup.DeletedAt != nil {
+ return sample.NewFailure(sample.FailureFailedPrecondition, errors.New("expired sample instance cannot be restored"))
+ }
+ return nil
+}
+
+// HandleInstanceLifecycle is a no-op because user archive/restore does not
+// change external PostgreSQL resources before expiration.
+func (*Manager) HandleInstanceLifecycle(context.Context, string, string, bool) error { return nil }
+
+// Stop is a no-op for the external target.
+func (*Manager) Stop() {}
+
+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 randomPassword(reader io.Reader) (string, error) {
+ value := make([]byte, 32)
+ if _, err := io.ReadFull(reader, value); err != nil {
+ return "", err
+ }
+ return base64.RawURLEncoding.EncodeToString(value), nil
+}
+
+func randomInstanceID(reader io.Reader) (string, error) {
+ value := make([]byte, 8)
+ if _, err := io.ReadFull(reader, value); err != nil {
+ return "", err
+ }
+ return "sample-" + hex.EncodeToString(value), nil
+}
+
+func mapTargetError(err error) error {
+ if errors.Is(err, context.DeadlineExceeded) {
+ return sample.NewFailure(sample.FailureDeadlineExceeded, err)
+ }
+ if isStaticTargetError(err) {
+ return sample.NewFailure(sample.FailureFailedPrecondition, err)
+ }
+ return sample.NewFailure(sample.FailureUnavailable, err)
+}
diff --git a/backend/component/sample/saas/manager_test.go b/backend/component/sample/saas/manager_test.go
new file mode 100644
index 0000000000..0cd85936a4
--- /dev/null
+++ b/backend/component/sample/saas/manager_test.go
@@ -0,0 +1,13 @@
+package saas
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestSampleNamesAreStableAndShort(t *testing.T) {
+ database, role := sampleNames("sample-0123456789abcdef")
+ require.Equal(t, "bb_sample_d3bc52190e66d2ca", database)
+ require.Equal(t, "bb_sample_role_d3bc52190e66d2ca", role)
+}
diff --git a/backend/component/sampleprojectinstance/target.go b/backend/component/sample/saas/postgres.go
similarity index 69%
rename from backend/component/sampleprojectinstance/target.go
rename to backend/component/sample/saas/postgres.go
index b32795915e..be52b462ac 100644
--- a/backend/component/sampleprojectinstance/target.go
+++ b/backend/component/sample/saas/postgres.go
@@ -1,6 +1,4 @@
-// Package sampleprojectinstance manages Cloud PostgreSQL targets for sample
-// project instances.
-package sampleprojectinstance
+package saas
import (
"context"
@@ -13,28 +11,23 @@ import (
"github.com/jackc/pgx/v5"
"github.com/pkg/errors"
+ "github.com/bytebase/bytebase/backend/component/sample"
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
+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
+type instanceConfig struct {
+ adminDataSource *storepb.DataSource
+ syncDatabaseNames []string
}
-// Target manages direct PostgreSQL operations for sample project instances.
-type Target struct {
+type postgresTarget struct {
config *pgx.ConnConfig
useSSL bool
verifyTLS bool
@@ -55,18 +48,10 @@ type staticTargetFailure struct {
err error
}
-func (e *staticTargetFailure) Error() string {
- return e.err.Error()
-}
-
-func (e *staticTargetFailure) Unwrap() error {
- return e.err
-}
+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) {
+func newPostgresTarget(targetURL string) (*postgresTarget, 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")
@@ -116,62 +101,54 @@ func NewTarget(targetURL string) (*Target, error) {
}
var sslCA string
if path := query.Get("sslrootcert"); path != "" {
- resolved, err := util.ResolveTLSMaterial(&storepb.DataSource{
- UseSsl: true,
- SslCaPath: 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, sslMode == "verify-full", sslCA), nil
+ return newPostgresTargetFromConfig(config, sslMode == "verify-full", sslCA), nil
+}
+
+func newPostgresTargetFromConfig(config *pgx.ConnConfig, verifyTLS bool, sslCA string) *postgresTarget {
+ return &postgresTarget{
+ config: config,
+ useSSL: config.TLSConfig != nil,
+ verifyTLS: verifyTLS,
+ sslCA: sslCA,
+ }
}
-// InstanceConfig builds the persisted admin datasource and its exact discovery
-// filter for an allocation.
-func (t *Target) InstanceConfig(allocation Allocation) (*InstanceConfig, error) {
+func (t *postgresTarget) instanceConfig(allocation allocation) (*instanceConfig, error) {
if err := validateProvisionAllocation(allocation); err != nil {
return nil, err
}
- return &InstanceConfig{
- AdminDataSource: &storepb.DataSource{
+ 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,
+ Database: allocation.database,
+ Username: allocation.role,
+ Password: allocation.password,
UseSsl: t.useSSL,
VerifyTlsCertificate: t.verifyTLS,
SslCa: t.sslCA,
},
- SyncDatabaseNames: []string{allocation.Database},
+ syncDatabaseNames: []string{allocation.database},
}, nil
}
-func newTargetFromConfig(config *pgx.ConnConfig, verifyTLS bool, sslCA string) *Target {
- return &Target{
- config: config,
- useSSL: config.TLSConfig != nil,
- verifyTLS: verifyTLS,
- sslCA: sslCA,
- }
-}
-
-// Validate verifies the target is reachable and can allocate sample databases.
-func (t *Target) Validate(ctx context.Context) error {
+func (t *postgresTarget) validate(ctx context.Context) error {
return t.validateCapabilities(ctx, true)
}
-// ValidateForCleanup verifies the connectivity and target capabilities needed
-// to remove existing allocations. Cleanup does not require CREATEDB.
-func (t *Target) ValidateForCleanup(ctx context.Context) error {
+func (t *postgresTarget) validateForCleanup(ctx context.Context) error {
return t.validateCapabilities(ctx, false)
}
-func (t *Target) validateCapabilities(ctx context.Context, requireCreateDB bool) error {
+func (t *postgresTarget) 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")
@@ -195,14 +172,10 @@ func (t *Target) validateCapabilities(ctx context.Context, requireCreateDB bool)
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 {
+func (t *postgresTarget) 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")
@@ -211,35 +184,33 @@ func (t *Target) Provision(ctx context.Context, allocation Allocation) error {
if _, err := admin.Exec(ctx, fmt.Sprintf(
"CREATE ROLE %s LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOREPLICATION NOBYPASSRLS PASSWORD %s",
- quoteIdentifier(allocation.Role),
- quoteLiteral(allocation.Password),
+ 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 {
+ 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 {
+ 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),
+ 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 {
+ 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, "", "")
+ sampleAdmin, err := t.connect(ctx, allocation.database, "", "")
if err != nil {
return errors.New("failed to connect to sample project instance database")
}
@@ -247,21 +218,20 @@ func (t *Target) Provision(ctx context.Context, allocation Allocation) error {
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 {
+ 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)
+ sampleConn, 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()
+ defer sampleConn.Close(ctx)
+ seed, err := sample.LoadSeedData()
if err != nil {
return errors.New("failed to load sample project instance seed data")
}
- tx, err := sample.Begin(ctx)
+ tx, err := sampleConn.Begin(ctx)
if err != nil {
return errors.New("failed to begin sample project instance seed transaction")
}
@@ -275,45 +245,41 @@ func (t *Target) Provision(ctx context.Context, allocation Allocation) error {
return nil
}
-func (t *Target) runProvisionHook(stage provisionStage) error {
+func (t *postgresTarget) 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 {
+func (t *postgresTarget) remove(ctx context.Context, allocation allocation) error {
if err := validateCleanupAllocation(allocation); err != nil {
return err
}
- if allocation.Database != "" && t.config.Database == allocation.Database {
+ 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)
+ 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 {
+ 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)
+ 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 {
+ 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")
}
}
@@ -324,7 +290,7 @@ func (t *Target) Remove(ctx context.Context, allocation Allocation) error {
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", quoteIdentifier(allocation.Database))); err != nil {
+ if _, err := admin.Exec(ctx, fmt.Sprintf("DROP DATABASE %s", quoteIdentifier(allocation.database))); err != nil {
return errors.New("failed to drop sample project instance database")
}
}
@@ -332,14 +298,14 @@ func (t *Target) Remove(ctx context.Context, allocation Allocation) error {
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 {
+ 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) {
+func (t *postgresTarget) connect(ctx context.Context, database, user, password string) (*pgx.Conn, error) {
config := t.config.Copy()
if database != "" {
config.Database = database
@@ -351,28 +317,24 @@ func (t *Target) connect(ctx context.Context, database, user, password string) (
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) {
+func validateProvisionAllocation(value allocation) error {
+ if value.database == "" || value.role == "" || strings.ContainsRune(value.database, 0) || strings.ContainsRune(value.role, 0) {
return staticTargetError("sample project instance provisioning requires database and role")
}
- if allocation.Password == "" || strings.ContainsRune(allocation.Password, 0) {
+ if value.password == "" || strings.ContainsRune(value.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) {
+func validateCleanupAllocation(value allocation) error {
+ if (value.database == "" && value.role == "") || strings.ContainsRune(value.database, 0) || strings.ContainsRune(value.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 quoteIdentifier(value string) string { return pgx.Identifier{value}.Sanitize() }
func quoteLiteral(value string) string {
return "E'" + strings.NewReplacer(`\`, `\\`, `'`, `\'`).Replace(value) + "'"
@@ -399,14 +361,12 @@ func databaseExists(ctx context.Context, conn *pgx.Conn, database string) (bool,
return exists, err
}
-func terminateAndDrain(ctx context.Context, conn *pgx.Conn, allocation Allocation) error {
+func terminateAndDrain(ctx context.Context, conn *pgx.Conn, value 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)
+ SELECT pid FROM pg_stat_activity
+ WHERE (usename = $1 OR datname = $2) AND pid <> pg_backend_pid()
+ `, value.role, value.database)
if err != nil {
return errors.New("failed to list sample project instance sessions")
}
@@ -432,7 +392,6 @@ func terminateAndDrain(ctx context.Context, conn *pgx.Conn, allocation Allocatio
return errors.New("failed to terminate sample project instance session")
}
}
-
timer := time.NewTimer(250 * time.Millisecond)
select {
case <-ctx.Done():
diff --git a/backend/component/sample/seed.go b/backend/component/sample/seed.go
new file mode 100644
index 0000000000..d80a6043af
--- /dev/null
+++ b/backend/component/sample/seed.go
@@ -0,0 +1,36 @@
+package sample
+
+import (
+ "embed"
+ "io/fs"
+ "slices"
+ "strings"
+
+ "github.com/pkg/errors"
+)
+
+// Sample data is from https://github.com/bytebase/employee-sample-database/tree/main/postgres/dataset_small.
+//
+//go:embed seed
+var seedFS embed.FS
+
+// LoadSeedData returns the ordered employee sample SQL.
+func LoadSeedData() (string, error) {
+ names, err := fs.Glob(seedFS, "seed/*.sql")
+ if err != nil {
+ return "", err
+ }
+ slices.Sort(names)
+
+ var builder strings.Builder
+ for _, name := range names {
+ content, err := fs.ReadFile(seedFS, name)
+ if err != nil {
+ return "", errors.Wrapf(err, "failed to read sample database data: %s", name)
+ }
+ if _, err := builder.Write(content); err != nil {
+ return "", err
+ }
+ }
+ return builder.String(), nil
+}
diff --git a/backend/resources/postgres/sample/0001##schema.sql b/backend/component/sample/seed/0001##schema.sql
similarity index 100%
rename from backend/resources/postgres/sample/0001##schema.sql
rename to backend/component/sample/seed/0001##schema.sql
diff --git a/backend/resources/postgres/sample/0002##department.sql b/backend/component/sample/seed/0002##department.sql
similarity index 100%
rename from backend/resources/postgres/sample/0002##department.sql
rename to backend/component/sample/seed/0002##department.sql
diff --git a/backend/resources/postgres/sample/0003##employee.sql b/backend/component/sample/seed/0003##employee.sql
similarity index 100%
rename from backend/resources/postgres/sample/0003##employee.sql
rename to backend/component/sample/seed/0003##employee.sql
diff --git a/backend/resources/postgres/sample/0004##dept_emp.sql b/backend/component/sample/seed/0004##dept_emp.sql
similarity index 100%
rename from backend/resources/postgres/sample/0004##dept_emp.sql
rename to backend/component/sample/seed/0004##dept_emp.sql
diff --git a/backend/resources/postgres/sample/0005##dept_manager.sql b/backend/component/sample/seed/0005##dept_manager.sql
similarity index 100%
rename from backend/resources/postgres/sample/0005##dept_manager.sql
rename to backend/component/sample/seed/0005##dept_manager.sql
diff --git a/backend/resources/postgres/sample/0006##title.sql b/backend/component/sample/seed/0006##title.sql
similarity index 100%
rename from backend/resources/postgres/sample/0006##title.sql
rename to backend/component/sample/seed/0006##title.sql
diff --git a/backend/resources/postgres/sample/0007##salary.sql b/backend/component/sample/seed/0007##salary.sql
similarity index 100%
rename from backend/resources/postgres/sample/0007##salary.sql
rename to backend/component/sample/seed/0007##salary.sql
diff --git a/backend/component/sample/seed_test.go b/backend/component/sample/seed_test.go
new file mode 100644
index 0000000000..73e12e4a98
--- /dev/null
+++ b/backend/component/sample/seed_test.go
@@ -0,0 +1,14 @@
+package sample
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestLoadSeedData(t *testing.T) {
+ data, err := LoadSeedData()
+ require.NoError(t, err)
+ require.Contains(t, data, "CREATE TABLE employee")
+ require.Contains(t, data, "INSERT INTO employee")
+}
diff --git a/backend/component/sample/selfhost/legacy.go b/backend/component/sample/selfhost/legacy.go
new file mode 100644
index 0000000000..6e9502bee4
--- /dev/null
+++ b/backend/component/sample/selfhost/legacy.go
@@ -0,0 +1,136 @@
+package selfhost
+
+import (
+ "context"
+ "log/slog"
+ "path/filepath"
+ "sync"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/log"
+ "github.com/bytebase/bytebase/backend/component/config"
+ "github.com/bytebase/bytebase/backend/component/sample"
+ "github.com/bytebase/bytebase/backend/resources/postgres"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+const (
+ legacyTestInstanceID = "test-sample-instance"
+ legacyProdInstanceID = "prod-sample-instance"
+)
+
+type legacyAdapter struct {
+ store *store.Store
+ profile *config.Profile
+ mu sync.Mutex
+ running bool
+ stops []func()
+}
+
+func newLegacyAdapter(stores *store.Store, profile *config.Profile) *legacyAdapter {
+ return &legacyAdapter{store: stores, profile: profile}
+}
+
+func isLegacyInstanceID(instanceID string) bool {
+ return instanceID == legacyTestInstanceID || instanceID == legacyProdInstanceID
+}
+
+func (a *legacyAdapter) instances(ctx context.Context, workspaceID string) ([]*store.InstanceMessage, error) {
+ var result []*store.InstanceMessage
+ for _, id := range []string{legacyTestInstanceID, legacyProdInstanceID} {
+ instance, err := a.store.GetInstance(ctx, &store.FindInstanceMessage{
+ Workspace: workspaceID,
+ ResourceID: &id,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return nil, err
+ }
+ if instance != nil {
+ result = append(result, instance)
+ }
+ }
+ return result, nil
+}
+
+func (a *legacyAdapter) exists(ctx context.Context, workspaceID string) (bool, error) {
+ instances, err := a.instances(ctx, workspaceID)
+ return len(instances) > 0, err
+}
+
+func (a *legacyAdapter) start(ctx context.Context) {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ if a.running {
+ return
+ }
+ seedData, err := sample.LoadSeedData()
+ if err != nil {
+ slog.Error("failed to load legacy sample data", log.BBError(err))
+ return
+ }
+ for index, entry := range []struct {
+ name string
+ database string
+ }{
+ {name: "test", database: sampleDatabaseTest},
+ {name: "prod", database: sampleDatabaseProd},
+ } {
+ stop, err := postgres.StartEmbeddedInstance(ctx, postgres.EmbeddedInstanceConfig{
+ DataDir: filepath.Join(a.profile.DataDir, "pgdata-sample", entry.name),
+ Port: a.profile.Port + 3 + index,
+ User: sampleUser,
+ DatabaseName: entry.database,
+ SeedData: seedData,
+ })
+ if err != nil {
+ slog.Error("failed to start legacy sample instance", slog.String("instance", entry.name), log.BBError(err))
+ continue
+ }
+ a.stops = append(a.stops, stop)
+ }
+ a.running = len(a.stops) > 0
+}
+
+func (a *legacyAdapter) stop() {
+ a.mu.Lock()
+ defer a.mu.Unlock()
+ for _, stop := range a.stops {
+ stop()
+ }
+ a.stops = nil
+ a.running = false
+}
+
+func (a *legacyAdapter) handleLifecycle(ctx context.Context, workspaceID, instanceID string, deleted bool) error {
+ if !isLegacyInstanceID(instanceID) {
+ return nil
+ }
+ if !deleted {
+ a.start(ctx)
+ return nil
+ }
+ instances, err := a.instances(ctx, workspaceID)
+ if err != nil {
+ return err
+ }
+ for _, instance := range instances {
+ if !instance.Deleted {
+ return nil
+ }
+ }
+ a.stop()
+ return nil
+}
+
+func (a *legacyAdapter) info(ctx context.Context, workspaceID string) ([]sampleInstanceInfo, error) {
+ instances, err := a.instances(ctx, workspaceID)
+ if err != nil {
+ return nil, err
+ }
+ result := make([]sampleInstanceInfo, 0, len(instances))
+ for _, instance := range instances {
+ result = append(result, sampleInstanceInfo{instance: common.FormatInstance(instance.ResourceID)})
+ }
+ return result, nil
+}
diff --git a/backend/component/sample/selfhost/manager.go b/backend/component/sample/selfhost/manager.go
new file mode 100644
index 0000000000..fbbbace08e
--- /dev/null
+++ b/backend/component/sample/selfhost/manager.go
@@ -0,0 +1,569 @@
+// Package selfhost manages the two workspace-level embedded PostgreSQL sample
+// instances used by self-hosted Bytebase.
+package selfhost
+
+import (
+ "context"
+ "crypto/rand"
+ "encoding/hex"
+ "errors"
+ "io"
+ "path/filepath"
+ "strconv"
+ "sync"
+ "time"
+
+ pkgerrors "github.com/pkg/errors"
+ "google.golang.org/protobuf/encoding/protojson"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/component/config"
+ "github.com/bytebase/bytebase/backend/component/sample"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/resources/postgres"
+ "github.com/bytebase/bytebase/backend/runner/schemasync"
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+const (
+ prepareDeadline = 3 * time.Minute
+ staleReservationAge = time.Hour
+ replicaHeartbeatStaleness = time.Minute
+ pollInitialDelay = 10 * time.Millisecond
+ pollMaxDelay = time.Second
+ sampleUser = "bbsample"
+ sampleDatabaseTest = "hr_test"
+ sampleDatabaseProd = "hr_prod"
+)
+
+type sampleInstanceInfo struct {
+ instance string
+}
+
+// Manager is the self-host sample implementation.
+type Manager struct {
+ store *store.Store
+ profile *config.Profile
+ syncer *schemasync.Syncer
+ clock func() time.Time
+ random io.Reader
+ replicaID string
+ legacy *legacyAdapter
+
+ mu sync.Mutex
+ stoppers map[string]func()
+}
+
+// NewManager creates the self-host sample manager.
+func NewManager(stores *store.Store, profile *config.Profile, syncer *schemasync.Syncer, options sample.ManagerOptions) *Manager {
+ if options.Clock == nil {
+ options.Clock = time.Now
+ }
+ if options.Random == nil {
+ options.Random = rand.Reader
+ }
+ return &Manager{
+ store: stores,
+ profile: profile,
+ syncer: syncer,
+ clock: options.Clock,
+ random: options.Random,
+ replicaID: options.ReplicaID,
+ legacy: newLegacyAdapter(stores, profile),
+ stoppers: map[string]func(){},
+ }
+}
+
+func managedEntry(instanceID, title string, portOffset int32, database string) *storepb.SelfHostSampleInstanceSetupPayload_Instance {
+ return &storepb.SelfHostSampleInstanceSetupPayload_Instance{
+ InstanceId: instanceID,
+ Title: title,
+ PortOffset: portOffset,
+ DatabaseName: database,
+ RoleName: sampleUser,
+ }
+}
+
+func newPayload(reader io.Reader, projectID string, testEnvironment, prodEnvironment *string) (*storepb.SelfHostSampleInstanceSetupPayload, error) {
+ testID, err := randomInstanceID(reader)
+ if err != nil {
+ return nil, err
+ }
+ prodID, err := randomInstanceID(reader)
+ if err != nil {
+ return nil, err
+ }
+ test := managedEntry(testID, "Test Sample Instance", 0, sampleDatabaseTest)
+ prod := managedEntry(prodID, "Prod Sample Instance", 1, sampleDatabaseProd)
+ test.EnvironmentId = testEnvironment
+ prod.EnvironmentId = prodEnvironment
+ return &storepb.SelfHostSampleInstanceSetupPayload{
+ DatabaseProjectId: projectID,
+ Instances: []*storepb.SelfHostSampleInstanceSetupPayload_Instance{test, prod},
+ }, nil
+}
+
+func randomInstanceID(reader io.Reader) (string, error) {
+ value := make([]byte, 8)
+ if _, err := io.ReadFull(reader, value); err != nil {
+ return "", err
+ }
+ return "sample-" + hex.EncodeToString(value), nil
+}
+
+func sampleConfig(profile *config.Profile, entry *storepb.SelfHostSampleInstanceSetupPayload_Instance) postgres.EmbeddedInstanceConfig {
+ return postgres.EmbeddedInstanceConfig{
+ DataDir: filepath.Join(profile.DataDir, "pgdata-sample-managed", entry.InstanceId),
+ Port: profile.Port + 3 + int(entry.PortOffset),
+ User: entry.RoleName,
+ DatabaseName: entry.DatabaseName,
+ }
+}
+
+func decode(setup *store.SampleInstanceSetupMessage) (*storepb.SelfHostSampleInstanceSetupPayload, error) {
+ if setup == nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("sample setup is missing"))
+ }
+ payload := &storepb.SelfHostSampleInstanceSetupPayload{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal(setup.Payload, payload); err != nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("invalid self-host sample setup payload"))
+ }
+ if payload.DatabaseProjectId == "" || len(payload.Instances) != 2 {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("incomplete self-host sample setup payload"))
+ }
+ for _, entry := range payload.Instances {
+ if entry.InstanceId == "" || entry.Title == "" || entry.DatabaseName == "" || entry.RoleName == "" {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("incomplete self-host sample instance payload"))
+ }
+ }
+ return payload, nil
+}
+
+// SetupSample creates two permanent workspace-level embedded sample instances.
+func (m *Manager) SetupSample(ctx context.Context, request sample.SetupRequest) (*sample.SetupResult, error) {
+ if m == nil || m.store == nil || m.profile == nil || m.syncer == nil || m.replicaID == "" {
+ return nil, errors.New("self-host sample manager is not configured")
+ }
+ if request.WorkspaceID == "" || request.ProjectID == "" {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("self-host sample requires workspace and project"))
+ }
+ legacy, err := m.legacy.exists(ctx, request.WorkspaceID)
+ if err != nil {
+ return nil, err
+ }
+ if legacy {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("legacy self-host sample instances already exist"))
+ }
+ lifecycleCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), prepareDeadline)
+ defer cancel()
+ setup, created, err := m.reserve(lifecycleCtx, request)
+ if err != nil {
+ return nil, err
+ }
+ delay := pollInitialDelay
+ for {
+ payload, err := decode(setup)
+ if err != nil {
+ return nil, err
+ }
+ if payload.DatabaseProjectId != request.ProjectID || setup.DeletedAt != nil {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("sample setup entitlement is already consumed"))
+ }
+ if created {
+ return m.prepareOwned(lifecycleCtx, setup, payload, false)
+ }
+ if setup.ActivatedAt != nil {
+ return m.activeSetup(lifecycleCtx, setup, payload)
+ }
+ claimed, ok, err := m.store.ClaimSampleInstanceSetup(lifecycleCtx, setup.WorkspaceID, setup.UpdatedAt, m.replicaID, prepareDeadline, replicaHeartbeatStaleness)
+ if err != nil {
+ return nil, pkgerrors.Wrap(err, "failed to claim abandoned self-host sample setup")
+ }
+ if ok {
+ claimedPayload, err := decode(claimed)
+ if err != nil {
+ return nil, err
+ }
+ return m.prepareOwned(lifecycleCtx, claimed, claimedPayload, true)
+ }
+ if err := sample.SleepContext(lifecycleCtx, delay); err != nil {
+ return nil, sample.NewFailure(sample.FailureDeadlineExceeded, err)
+ }
+ if delay < pollMaxDelay {
+ delay *= 2
+ if delay > pollMaxDelay {
+ delay = pollMaxDelay
+ }
+ }
+ setup, err = m.store.GetSampleInstanceSetup(lifecycleCtx, request.WorkspaceID)
+ if err != nil {
+ return nil, err
+ }
+ created = false
+ if setup == nil {
+ setup, created, err = m.reserve(lifecycleCtx, request)
+ if err != nil {
+ return nil, err
+ }
+ }
+ }
+}
+
+func (m *Manager) reserve(ctx context.Context, request sample.SetupRequest) (*store.SampleInstanceSetupMessage, bool, error) {
+ environments, err := m.store.GetEnvironment(ctx, request.WorkspaceID)
+ if err != nil {
+ return nil, false, err
+ }
+ var testEnvironment, prodEnvironment *string
+ for _, environment := range environments.GetEnvironments() {
+ switch environment.Id {
+ case common.DefaultTestEnvironmentID:
+ value := environment.Id
+ testEnvironment = &value
+ case common.DefaultProdEnvironmentID:
+ value := environment.Id
+ prodEnvironment = &value
+ default:
+ }
+ }
+ payload, err := newPayload(m.random, request.ProjectID, testEnvironment, prodEnvironment)
+ if err != nil {
+ return nil, false, pkgerrors.Wrap(err, "failed to generate self-host sample payload")
+ }
+ encoded, err := protojson.Marshal(payload)
+ if err != nil {
+ return nil, false, pkgerrors.Wrap(err, "failed to encode self-host sample payload")
+ }
+ return m.store.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: request.WorkspaceID,
+ ReplicaID: m.replicaID,
+ Payload: encoded,
+ })
+}
+
+func (m *Manager) prepareOwned(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SelfHostSampleInstanceSetupPayload, takeover bool) (*sample.SetupResult, error) {
+ if takeover {
+ if err := m.reconcile(ctx, setup.WorkspaceID, payload); err != nil {
+ return nil, sample.NewFailure(sample.FailureUnavailable, err)
+ }
+ }
+ instances := make([]*store.InstanceMessage, 0, len(payload.Instances))
+ for _, entry := range payload.Instances {
+ if err := m.startEntry(ctx, entry); err != nil {
+ return nil, m.compensate(ctx, setup, payload, err)
+ }
+ registered, err := sample.CreateMetadata(ctx, m.store, sample.Registration{
+ WorkspaceID: setup.WorkspaceID,
+ EnvironmentID: entry.EnvironmentId,
+ InstanceID: entry.InstanceId,
+ Title: entry.Title,
+ AdminDataSource: dataSource(m.profile, entry),
+ SyncDatabaseNames: []string{entry.DatabaseName},
+ })
+ if err != nil {
+ return nil, m.compensate(ctx, setup, payload, err)
+ }
+ synced, _, databases, err := m.syncer.SyncInstance(ctx, registered)
+ if err != nil || len(databases) != 1 || databases[0].DatabaseName != entry.DatabaseName || databases[0].Deleted {
+ return nil, m.compensate(ctx, setup, payload, errors.Join(err, errors.New("self-host sample database discovery invariant failed")))
+ }
+ if err := sample.TransferDatabase(ctx, m.store, payload.DatabaseProjectId, entry.InstanceId, entry.DatabaseName); err != nil {
+ return nil, m.compensate(ctx, setup, payload, err)
+ }
+ if err := m.createBaseline(ctx, databases[0]); err != nil {
+ return nil, m.compensate(ctx, setup, payload, err)
+ }
+ m.syncer.SyncDatabasesAsync(databases)
+ instances = append(instances, synced)
+ }
+ activated, err := m.store.ActivateSampleInstanceSetup(ctx, setup.WorkspaceID, m.replicaID, []string{payload.DatabaseProjectId}, m.clock(), nil)
+ if err != nil || !activated {
+ return nil, m.compensate(ctx, setup, payload, errors.Join(errors.New("failed to activate self-host sample setup"), err))
+ }
+ return &sample.SetupResult{Instances: instances}, nil
+}
+
+func dataSource(profile *config.Profile, entry *storepb.SelfHostSampleInstanceSetupPayload_Instance) *storepb.DataSource {
+ return &storepb.DataSource{
+ Id: "admin",
+ Type: storepb.DataSourceType_ADMIN,
+ Username: entry.RoleName,
+ Host: common.GetPostgresSocketDir(),
+ Port: strconv.Itoa(profile.Port + 3 + int(entry.PortOffset)),
+ Database: entry.DatabaseName,
+ }
+}
+
+func (m *Manager) createBaseline(ctx context.Context, database *store.DatabaseMessage) error {
+ syncHistory, err := m.syncer.SyncDatabaseSchemaToHistory(ctx, database)
+ if err != nil {
+ return pkgerrors.Wrap(err, "failed to sync self-host sample baseline")
+ }
+ _, err = m.store.CreateChangelog(ctx, &store.ChangelogMessage{
+ InstanceID: database.InstanceID,
+ DatabaseName: database.DatabaseName,
+ Status: store.ChangelogStatusDone,
+ SyncHistory: &syncHistory,
+ Payload: &storepb.ChangelogPayload{GitCommit: m.profile.GitCommit},
+ })
+ return err
+}
+
+func (m *Manager) activeSetup(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SelfHostSampleInstanceSetupPayload) (*sample.SetupResult, error) {
+ instances := make([]*store.InstanceMessage, 0, len(payload.Instances))
+ for _, entry := range payload.Instances {
+ state, err := sample.LookupMetadata(ctx, m.store, sample.MetadataLookup{
+ WorkspaceID: setup.WorkspaceID,
+ DatabaseProjectID: payload.DatabaseProjectId,
+ InstanceID: entry.InstanceId,
+ DatabaseName: entry.DatabaseName,
+ })
+ if err != nil {
+ return nil, err
+ }
+ if !state.Active() {
+ return nil, sample.NewFailure(sample.FailureFailedPrecondition, errors.New("self-host sample metadata is not active"))
+ }
+ instances = append(instances, state.Instance)
+ }
+ return &sample.SetupResult{Instances: instances}, nil
+}
+
+func (m *Manager) compensate(ctx context.Context, setup *store.SampleInstanceSetupMessage, payload *storepb.SelfHostSampleInstanceSetupPayload, original error) error {
+ if err := m.reconcile(ctx, setup.WorkspaceID, payload); err != nil {
+ return sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ deleted, err := m.store.DeletePendingSampleInstanceSetup(ctx, setup.WorkspaceID, m.replicaID)
+ if err != nil || !deleted {
+ return sample.NewFailure(sample.FailureUnavailable, errors.Join(original, err))
+ }
+ return original
+}
+
+func (m *Manager) reconcile(ctx context.Context, workspaceID string, payload *storepb.SelfHostSampleInstanceSetupPayload) error {
+ var result error
+ for _, entry := range payload.Instances {
+ result = errors.Join(result, sample.PurgePartialMetadata(ctx, m.store, workspaceID, nil, entry.InstanceId))
+ m.stopEntry(entry.InstanceId)
+ result = errors.Join(result, postgres.RemoveEmbeddedInstance(sampleConfig(m.profile, entry).DataDir))
+ }
+ return result
+}
+
+func (m *Manager) startEntry(ctx context.Context, entry *storepb.SelfHostSampleInstanceSetupPayload_Instance) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if _, ok := m.stoppers[entry.InstanceId]; ok {
+ return nil
+ }
+ seedData, err := sample.LoadSeedData()
+ if err != nil {
+ return err
+ }
+ config := sampleConfig(m.profile, entry)
+ config.SeedData = seedData
+ stop, err := postgres.StartEmbeddedInstance(ctx, config)
+ if err != nil {
+ return err
+ }
+ m.stoppers[entry.InstanceId] = stop
+ return nil
+}
+
+func (m *Manager) stopEntry(instanceID string) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if stop := m.stoppers[instanceID]; stop != nil {
+ stop()
+ delete(m.stoppers, instanceID)
+ }
+}
+
+// Info reports managed payload instances or historical static instances.
+func (m *Manager) Info(ctx context.Context, workspaceID string) (*sample.Info, error) {
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil {
+ return nil, err
+ }
+ if setup != nil {
+ payload, err := decode(setup)
+ if err != nil {
+ return nil, err
+ }
+ info := &sample.Info{Available: setup.DeletedAt == nil}
+ for _, entry := range payload.Instances {
+ instance := sample.InstanceInfo{Instance: common.FormatInstance(entry.InstanceId)}
+ if setup.DeletedAt == nil {
+ instance.ExpireTime = setup.ExpiresAt
+ }
+ info.Instances = append(info.Instances, instance)
+ }
+ return info, nil
+ }
+ legacy, err := m.legacy.info(ctx, workspaceID)
+ if err != nil {
+ return nil, err
+ }
+ info := &sample.Info{Available: true}
+ for _, entry := range legacy {
+ info.Instances = append(info.Instances, sample.InstanceInfo{Instance: entry.instance})
+ }
+ return info, nil
+}
+
+// Start restores active embedded sample processes after server restart.
+func (m *Manager) Start(ctx context.Context, workspaceID string) error {
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil {
+ return err
+ }
+ if setup != nil && setup.ActivatedAt != nil && setup.DeletedAt == nil && (setup.ExpiresAt == nil || setup.ExpiresAt.After(m.clock())) {
+ payload, err := decode(setup)
+ if err != nil {
+ return err
+ }
+ active := false
+ for _, entry := range payload.Instances {
+ instance, err := m.store.GetInstance(ctx, &store.FindInstanceMessage{Workspace: workspaceID, ResourceID: &entry.InstanceId, ShowDeleted: true})
+ if err != nil {
+ return err
+ }
+ if instance != nil && !instance.Deleted {
+ active = true
+ }
+ }
+ if active {
+ for _, entry := range payload.Instances {
+ if err := m.startEntry(ctx, entry); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+ }
+ legacy, err := m.legacy.instances(ctx, workspaceID)
+ if err != nil {
+ return err
+ }
+ for _, instance := range legacy {
+ if !instance.Deleted {
+ m.legacy.start(ctx)
+ break
+ }
+ }
+ return nil
+}
+
+// Cleanup reconciles stale pending self-host setups. Permanent active setups
+// are not selected by the store cleanup query.
+func (m *Manager) Cleanup(ctx context.Context) error {
+ now := m.clock()
+ staleBefore := now.Add(-staleReservationAge)
+ for afterWorkspace := ""; ; {
+ result, err := m.store.WithLockedSampleInstanceSetupForCleanup(ctx, now, staleBefore, afterWorkspace, func(callbackCtx context.Context, tx *store.SampleInstanceSetupTx, setup *store.SampleInstanceSetupMessage) error {
+ payload, err := decode(setup)
+ if err != nil {
+ return err
+ }
+ if setup.ActivatedAt != nil {
+ for _, entry := range payload.Instances {
+ m.stopEntry(entry.InstanceId)
+ if err := postgres.RemoveEmbeddedInstance(sampleConfig(m.profile, entry).DataDir); err != nil {
+ return err
+ }
+ if _, err := sample.ArchiveMetadata(callbackCtx, m.store, setup.WorkspaceID, nil, entry.InstanceId); err != nil {
+ return err
+ }
+ }
+ return tx.MarkDeleted(callbackCtx, now)
+ }
+ if err := m.reconcile(callbackCtx, setup.WorkspaceID, payload); err != nil {
+ return err
+ }
+ return tx.DeleteReservation(callbackCtx)
+ })
+ if err != nil {
+ return err
+ }
+ if !result.Found {
+ return nil
+ }
+ afterWorkspace = result.WorkspaceID
+ if result.CallbackErr != nil {
+ return result.CallbackErr
+ }
+ }
+}
+
+// ValidateInstanceRestore rejects restoring a physically removed self-host
+// sample while allowing permanent and historical samples.
+func (m *Manager) ValidateInstanceRestore(ctx context.Context, workspaceID, instanceID string) error {
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil || setup == nil || setup.DeletedAt == nil {
+ return err
+ }
+ payload, err := decode(setup)
+ if err != nil {
+ return err
+ }
+ for _, entry := range payload.Instances {
+ if entry.InstanceId == instanceID {
+ return sample.NewFailure(sample.FailureFailedPrecondition, errors.New("expired sample instance cannot be restored"))
+ }
+ }
+ return nil
+}
+
+// HandleInstanceLifecycle starts or stops the exact managed sample process.
+func (m *Manager) HandleInstanceLifecycle(ctx context.Context, workspaceID, instanceID string, deleted bool) error {
+ if isLegacyInstanceID(instanceID) {
+ return m.legacy.handleLifecycle(ctx, workspaceID, instanceID, deleted)
+ }
+ setup, err := m.store.GetSampleInstanceSetup(ctx, workspaceID)
+ if err != nil || setup == nil || setup.DeletedAt != nil {
+ return err
+ }
+ payload, err := decode(setup)
+ if err != nil {
+ return err
+ }
+ managed := false
+ for _, entry := range payload.Instances {
+ managed = managed || entry.InstanceId == instanceID
+ }
+ if !managed {
+ return nil
+ }
+ if !deleted {
+ for _, entry := range payload.Instances {
+ if err := m.startEntry(ctx, entry); err != nil {
+ return err
+ }
+ }
+ return nil
+ }
+ for _, entry := range payload.Instances {
+ instance, err := m.store.GetInstance(ctx, &store.FindInstanceMessage{Workspace: workspaceID, ResourceID: &entry.InstanceId, ShowDeleted: true})
+ if err != nil {
+ return err
+ }
+ if instance != nil && !instance.Deleted {
+ return nil
+ }
+ }
+ for _, entry := range payload.Instances {
+ m.stopEntry(entry.InstanceId)
+ }
+ return nil
+}
+
+// Stop stops managed and legacy embedded sample processes.
+func (m *Manager) Stop() {
+ m.mu.Lock()
+ for id, stop := range m.stoppers {
+ stop()
+ delete(m.stoppers, id)
+ }
+ m.mu.Unlock()
+ m.legacy.stop()
+}
diff --git a/backend/component/sample/selfhost/manager_test.go b/backend/component/sample/selfhost/manager_test.go
new file mode 100644
index 0000000000..d23bca2360
--- /dev/null
+++ b/backend/component/sample/selfhost/manager_test.go
@@ -0,0 +1,33 @@
+package selfhost
+
+import (
+ "bytes"
+ "path/filepath"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/component/config"
+)
+
+func TestNewPayloadCreatesTwoShortRandomInstances(t *testing.T) {
+ payload, err := newPayload(bytes.NewReader([]byte("0123456789abcdef")), "project-a", nil, nil)
+ require.NoError(t, err)
+ require.Equal(t, "project-a", payload.DatabaseProjectId)
+ require.Len(t, payload.Instances, 2)
+ require.Equal(t, "sample-3031323334353637", payload.Instances[0].InstanceId)
+ require.Equal(t, "sample-3839616263646566", payload.Instances[1].InstanceId)
+ require.Equal(t, int32(0), payload.Instances[0].PortOffset)
+ require.Equal(t, int32(1), payload.Instances[1].PortOffset)
+ require.Equal(t, sampleDatabaseTest, payload.Instances[0].DatabaseName)
+ require.Equal(t, sampleDatabaseProd, payload.Instances[1].DatabaseName)
+}
+
+func TestSampleConfigUsesManagedDirectoryAndPortOffset(t *testing.T) {
+ profile := &config.Profile{DataDir: t.TempDir(), Port: 8080}
+ entry := managedEntry("sample-0123456789abcdef", "Test Sample Instance", 0, sampleDatabaseTest)
+ config := sampleConfig(profile, entry)
+ require.Equal(t, filepath.Join(profile.DataDir, "pgdata-sample-managed", entry.InstanceId), config.DataDir)
+ require.Equal(t, 8083, config.Port)
+ require.Equal(t, sampleDatabaseTest, config.DatabaseName)
+}
diff --git a/backend/component/sample/types.go b/backend/component/sample/types.go
new file mode 100644
index 0000000000..2cddfee0f5
--- /dev/null
+++ b/backend/component/sample/types.go
@@ -0,0 +1,97 @@
+// Package sample defines the application contract shared by the self-host and
+// SaaS sample implementations.
+package sample
+
+import (
+ "context"
+ "errors"
+ "io"
+ "log/slog"
+ "time"
+
+ "github.com/bytebase/bytebase/backend/store"
+)
+
+// SetupRequest identifies the workspace and database-owning project.
+type SetupRequest struct {
+ WorkspaceID string
+ ProjectID string
+}
+
+// SetupResult contains every instance created by the selected implementation.
+type SetupResult struct {
+ Instances []*store.InstanceMessage
+}
+
+// InstanceInfo describes one provisioned sample instance.
+type InstanceInfo struct {
+ Instance string
+ ExpireTime *time.Time
+}
+
+// Info describes availability and provisioned resources for one workspace.
+type Info struct {
+ Available bool
+ Instances []InstanceInfo
+}
+
+// Manager is the lifecycle interface implemented independently by self-host
+// and SaaS sample managers.
+type Manager interface {
+ SetupSample(context.Context, SetupRequest) (*SetupResult, error)
+ Info(context.Context, string) (*Info, error)
+ Start(context.Context, string) error
+ Cleanup(context.Context) error
+ ValidateInstanceRestore(context.Context, string, string) error
+ HandleInstanceLifecycle(context.Context, string, string, bool) error
+ Stop()
+}
+
+// ManagerOptions control manager identity and test seams.
+type ManagerOptions struct {
+ Clock func() time.Time
+ Random io.Reader
+ Logger *slog.Logger
+ ReplicaID string
+}
+
+// FailureKind classifies failures at the manager boundary.
+type FailureKind string
+
+const (
+ FailureUnknown FailureKind = "unknown"
+ FailureFailedPrecondition FailureKind = "failed_precondition"
+ FailureUnavailable FailureKind = "unavailable"
+ 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
+}
+
+// NewFailure classifies err for transport adapters.
+func NewFailure(kind FailureKind, err error) error {
+ if kind == FailureUnknown {
+ return err
+ }
+ return &failure{kind: kind, err: err}
+}
diff --git a/backend/component/sampleinstance/manager.go b/backend/component/sampleinstance/manager.go
deleted file mode 100644
index b22ef4c728..0000000000
--- a/backend/component/sampleinstance/manager.go
+++ /dev/null
@@ -1,314 +0,0 @@
-// Package sampleinstance manages sample database instances.
-package sampleinstance
-
-import (
- "context"
- "log/slog"
- "strconv"
- "sync"
-
- "github.com/pkg/errors"
-
- "github.com/bytebase/bytebase/backend/common"
- "github.com/bytebase/bytebase/backend/common/log"
- "github.com/bytebase/bytebase/backend/component/config"
- storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/resources/postgres"
- "github.com/bytebase/bytebase/backend/runner/schemasync"
- "github.com/bytebase/bytebase/backend/store"
-)
-
-// Manager manages sample database instances lifecycle.
-type Manager struct {
- mu sync.Mutex
- store *store.Store
- profile *config.Profile
- stoppers []func()
- port int // The base port for sample instances
-}
-
-func isSampleInstanceID(instanceID string) bool {
- return instanceID == "test-sample-instance" || instanceID == "prod-sample-instance"
-}
-
-// NewManager creates a new sample instance manager.
-func NewManager(store *store.Store, profile *config.Profile) *Manager {
- // Using profile.Port + 3 as our sample database port.
- // The actual startup of sample instances will be determined by checking the instance table.
- port := profile.Port + 3
-
- return &Manager{
- store: store,
- profile: profile,
- port: port,
- }
-}
-
-// StartIfExist starts sample instances if they exist in the database.
-func (m *Manager) StartIfExist(ctx context.Context, workspaceID string) error {
- // Check if sample instances exist in the database
- hasSampleInstances, err := m.store.HasSampleInstances(ctx, workspaceID)
- if err != nil {
- slog.Warn("failed to check for sample instances", log.BBError(err))
- return nil // Non-fatal error
- }
-
- if !hasSampleInstances {
- slog.Info("no sample instances found in database, skipping sample instance startup")
- return nil
- }
-
- // Start all sample instances
- slog.Info("starting sample instances")
- stoppers := postgres.StartAllSampleInstances(ctx, m.profile.DataDir, m.port)
-
- m.mu.Lock()
- defer m.mu.Unlock()
-
- m.stoppers = stoppers
-
- return nil
-}
-
-// HandleInstanceDeletion handles the deletion of a sample instance.
-// We stop all sample instances only when both have been deleted.
-func (m *Manager) HandleInstanceDeletion(ctx context.Context, workspaceID string, instanceID string) error {
- if !isSampleInstanceID(instanceID) {
- return nil
- }
-
- // Check if any sample instances still exist after this deletion
- hasSampleInstances, err := m.store.HasSampleInstances(ctx, workspaceID)
- if err != nil {
- slog.Warn("failed to check for remaining sample instances", log.BBError(err))
- return nil // Non-fatal error
- }
-
- if hasSampleInstances {
- // At least one sample instance still exists, don't stop
- slog.Info("sample instance deleted but others remain, keeping processes running", slog.String("instance", instanceID))
- return nil
- }
-
- m.mu.Lock()
- defer m.mu.Unlock()
-
- if len(m.stoppers) == 0 {
- // No sample instances running
- return nil
- }
-
- // Stop all sample instances when both have been deleted
- slog.Info("stopping all sample instances as none remain in database", slog.String("instance", instanceID))
- for _, stopper := range m.stoppers {
- if stopper != nil {
- stopper()
- }
- }
- m.stoppers = nil
-
- return nil
-}
-
-// HandleInstanceCreation handles the creation of a sample instance.
-// When any sample instance is created, we start all sample instances.
-func (m *Manager) HandleInstanceCreation(ctx context.Context, instanceID string) error {
- if !isSampleInstanceID(instanceID) {
- return nil
- }
-
- m.mu.Lock()
- defer m.mu.Unlock()
-
- // Check if already running
- if len(m.stoppers) > 0 {
- slog.Info("sample instances already running", slog.String("instance", instanceID))
- return nil
- }
-
- // Start all sample instances when any one is created
- slog.Info("starting all sample instances due to creation", slog.String("instance", instanceID))
- stoppers := postgres.StartAllSampleInstances(ctx, m.profile.DataDir, m.port)
- m.stoppers = stoppers
-
- return nil
-}
-
-// Stop stops all sample instances.
-func (m *Manager) Stop() {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- for _, stopper := range m.stoppers {
- if stopper != nil {
- stopper()
- }
- }
- m.stoppers = nil
-}
-
-// Port returns the base port for sample instances.
-func (m *Manager) Port() int {
- return m.port
-}
-
-// GenerateOnboardingData generates onboarding data including project and instance.
-func (m *Manager) GenerateOnboardingData(ctx context.Context, workspaceID string, user *store.UserMessage, schemaSyncer *schemasync.Syncer) error {
- // Sample instances are only for self-hosted (non-SaaS), so IDs are static.
- projectID := "project-sample"
- project, err := m.store.GetProject(ctx, &store.FindProjectMessage{
- Workspace: workspaceID,
- ResourceID: &projectID,
- })
- if err != nil {
- return errors.Wrapf(err, "failed to find onboarding project %v", projectID)
- }
- if project == nil {
- sampleProject, err := m.store.CreateProject(ctx, &store.ProjectMessage{
- Workspace: workspaceID,
- ResourceID: "project-sample",
- Title: "Sample Project",
- Setting: &storepb.Project{},
- }, user)
- if err != nil {
- return errors.Wrapf(err, "failed to create onboarding project")
- }
- project = sampleProject
- }
-
- instanceMessages := []*store.InstanceMessage{
- {
- ResourceID: "test-sample-instance",
- EnvironmentID: new(common.DefaultTestEnvironmentID),
- Workspace: workspaceID,
- Metadata: &storepb.Instance{
- Title: "Test Sample Instance",
- DataSources: []*storepb.DataSource{
- {
- Port: strconv.Itoa(m.port),
- Database: postgres.SampleDatabaseTest,
- },
- },
- },
- },
- {
- ResourceID: "prod-sample-instance",
- EnvironmentID: new(common.DefaultProdEnvironmentID),
- Workspace: workspaceID,
- Metadata: &storepb.Instance{
- Title: "Prod Sample Instance",
- DataSources: []*storepb.DataSource{
- {
- Port: strconv.Itoa(m.port + 1),
- Database: postgres.SampleDatabaseProd,
- },
- },
- },
- },
- }
- for _, instanceMessage := range instanceMessages {
- if err := m.generateInstance(ctx, project.ResourceID, instanceMessage, schemaSyncer); err != nil {
- slog.Error("failed to prepare onboarding instance", log.BBError(err), slog.String("instance", instanceMessage.ResourceID))
- }
- }
-
- return nil
-}
-
-func (m *Manager) generateInstance(
- ctx context.Context,
- projectID string,
- instanceMessage *store.InstanceMessage,
- schemaSyncer *schemasync.Syncer,
-) error {
- // Generate Sample Instance
- instance, err := m.store.GetInstance(ctx, &store.FindInstanceMessage{
- Workspace: instanceMessage.Workspace,
- ResourceID: &instanceMessage.ResourceID,
- })
- if err != nil {
- return errors.Wrapf(err, "failed to find onboarding instance %v", instanceMessage.ResourceID)
- }
- if instance == nil {
- sampleInstance, err := m.store.CreateInstance(ctx, &store.InstanceMessage{
- Workspace: instanceMessage.Workspace,
- ResourceID: instanceMessage.ResourceID,
- EnvironmentID: instanceMessage.EnvironmentID,
- Metadata: &storepb.Instance{
- Title: instanceMessage.Metadata.Title,
- Engine: storepb.Engine_POSTGRES,
- ExternalLink: "",
- Activation: false,
- DataSources: []*storepb.DataSource{
- {
- Id: "admin",
- Type: storepb.DataSourceType_ADMIN,
- Username: postgres.SampleUser,
- Password: "",
- Host: common.GetPostgresSocketDir(),
- Port: instanceMessage.Metadata.DataSources[0].Port,
- Database: instanceMessage.Metadata.DataSources[0].Database,
- },
- },
- },
- })
- if err != nil {
- return errors.Wrapf(err, "failed to create onboarding instance %v", instanceMessage.ResourceID)
- }
- instance = sampleInstance
-
- // Start the sample instance if needed
- if err := m.HandleInstanceCreation(ctx, instance.ResourceID); err != nil {
- slog.Warn("failed to start sample instance during onboarding", log.BBError(err), slog.String("instance", instance.ResourceID))
- }
- }
-
- // Sync the instance schema so we can transfer the sample database later.
- if _, _, _, err := schemaSyncer.SyncInstance(ctx, instance); err != nil {
- return errors.Wrapf(err, "failed to sync onboarding instance %v", instance.ResourceID)
- }
-
- dbName := instanceMessage.Metadata.DataSources[0].Database
- // Transfer sample database to the just created project.
- transferDatabaseMessage := &store.UpdateDatabaseMessage{
- InstanceID: instance.ResourceID,
- DatabaseName: dbName,
- ProjectID: &projectID,
- }
- _, err = m.store.UpdateDatabase(ctx, transferDatabaseMessage)
- if err != nil {
- return errors.Wrapf(err, "failed to transfer sample database %v", dbName)
- }
-
- testDatabase, err := m.store.GetDatabase(ctx, &store.FindDatabaseMessage{
- Workspace: instance.Workspace,
- InstanceID: &instance.ResourceID,
- DatabaseName: &dbName,
- })
- if err != nil {
- return errors.Wrapf(err, "failed to find onboarding database %v", dbName)
- }
- if testDatabase == nil {
- return errors.Errorf("database %q not found", dbName)
- }
-
- // Need to sync database schema so we can configure sensitive data policy and create the schema
- // update issue later. Also establish a baseline for schema rollback.
- syncHistory, err := schemaSyncer.SyncDatabaseSchemaToHistory(ctx, testDatabase)
- if err != nil {
- return errors.Wrapf(err, "failed to sync sample database schema %v", dbName)
- }
-
- if _, err := m.store.CreateChangelog(ctx, &store.ChangelogMessage{
- InstanceID: testDatabase.InstanceID,
- DatabaseName: dbName,
- Status: store.ChangelogStatusDone,
- SyncHistory: &syncHistory,
- Payload: &storepb.ChangelogPayload{
- GitCommit: m.profile.GitCommit,
- },
- }); err != nil {
- return errors.Wrapf(err, "failed to create baseline changelog for %v", dbName)
- }
- return nil
-}
diff --git a/backend/component/sampleprojectinstance/cloudsql_smoke_test.go b/backend/component/sampleprojectinstance/cloudsql_smoke_test.go
deleted file mode 100644
index 40aee4c131..0000000000
--- a/backend/component/sampleprojectinstance/cloudsql_smoke_test.go
+++ /dev/null
@@ -1,102 +0,0 @@
-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.go
deleted file mode 100644
index 7db3140918..0000000000
--- a/backend/component/sampleprojectinstance/manager.go
+++ /dev/null
@@ -1,667 +0,0 @@
-// 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"
- "sync"
- "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"
- sampleLifetime = 7 * 24 * time.Hour
- prepareDeadline = 3 * time.Minute
- provisionDeadline = 2 * time.Minute
- compensationDeadline = time.Minute
- cleanupValidationDeadline = 10 * time.Second
- targetAvailabilityDeadline = 3 * time.Second
- targetAvailabilityCacheTTL = time.Minute
- 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[:8])
- 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
- syncer *schemasync.Syncer
- clock func() time.Time
- random io.Reader
- logger *slog.Logger
-
- targetAvailabilityMu sync.Mutex
- targetAvailabilityCheckedAt time.Time
- targetAvailable bool
- replicaID string
-}
-
-// NewManagerFromURL creates a manager from raw target configuration.
-func NewManagerFromURL(
- s *store.Store,
- targetURL string,
- syncer *schemasync.Syncer,
- options ManagerOptions,
-) (*Manager, error) {
- target, err := NewTarget(targetURL)
- if err != nil {
- return nil, err
- }
- return newManager(s, target, syncer, options), nil
-}
-
-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,
- }
-}
-
-// ValidateTarget verifies the configured target before enabling Sample Project
-// Instance provisioning.
-func (m *Manager) ValidateTarget(ctx context.Context) error {
- if m == nil || m.target == nil {
- return errors.New("sample project instance target is not configured")
- }
- validationCtx, cancel := context.WithTimeout(ctx, cleanupValidationDeadline)
- defer cancel()
- err := m.target.Validate(validationCtx)
- m.recordTargetAvailability(err == nil)
- return err
-}
-
-// Available reports cached target readiness, refreshing stale state with a
-// short validation probe.
-func (m *Manager) Available(ctx context.Context) bool {
- if m == nil || m.target == nil {
- return false
- }
- m.targetAvailabilityMu.Lock()
- defer m.targetAvailabilityMu.Unlock()
-
- now := m.clock()
- if !m.targetAvailabilityCheckedAt.IsZero() && now.Before(m.targetAvailabilityCheckedAt.Add(targetAvailabilityCacheTTL)) {
- return m.targetAvailable
- }
- validationCtx, cancel := context.WithTimeout(ctx, targetAvailabilityDeadline)
- defer cancel()
- m.targetAvailable = m.target.Validate(validationCtx) == nil
- m.targetAvailabilityCheckedAt = m.clock()
- return m.targetAvailable
-}
-
-func (m *Manager) recordTargetAvailability(available bool) {
- m.targetAvailabilityMu.Lock()
- defer m.targetAvailabilityMu.Unlock()
- m.targetAvailable = available
- m.targetAvailabilityCheckedAt = m.clock()
-}
-
-// 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.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 {
- 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 err := m.ValidateTarget(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 := ""
- if environments := environments.GetEnvironments(); len(environments) > 0 {
- environmentID = environments[0].Id
- }
-
- 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 {
- return errors.New("sample project instance manager is not configured")
- }
- 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, 8)
- 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.go
deleted file mode 100644
index ff251b6a49..0000000000
--- a/backend/component/sampleprojectinstance/manager_test.go
+++ /dev/null
@@ -1,622 +0,0 @@
-package sampleprojectinstance
-
-import (
- "bytes"
- "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 TestRandomInstanceIDUses16CharacterToken(t *testing.T) {
- id, err := randomInstanceID(bytes.NewReader(make([]byte, 8)))
- require.NoError(t, err)
- require.Equal(t, "sample-0000000000000000", id)
-}
-
-func TestSampleNamesUse16CharacterTokens(t *testing.T) {
- names := sampleNames("sample-0000000000000000")
- require.Regexp(t, `^bb_sample_[0-9a-f]{16}$`, names.Database)
- require.Regexp(t, `^bb_sample_role_[0-9a-f]{16}$`, names.Role)
-}
-
-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 TestManagerValidateTargetRejectsInvalidConfiguration(t *testing.T) {
- manager, err := NewManagerFromURL(nil, "postgresql://control:[email protected]:5432/postgres?sslmode=prefer", nil, ManagerOptions{})
- require.Nil(t, manager)
- require.ErrorContains(t, err, "unsupported sslmode")
- require.NotContains(t, err.Error(), "secret")
-}
-
-func TestManagerAvailabilityRecoversAfterCachedValidationFailure(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()) })
-
- now := time.Now()
- target := newLocalTarget(t, container)
- manager := newManager(nil, target, nil, ManagerOptions{Clock: func() time.Time { return now }})
- require.True(t, manager.Available(ctx))
-
- port := target.config.Port
- target.config.Port = 1
- require.True(t, manager.Available(ctx))
- now = now.Add(targetAvailabilityCacheTTL)
- require.False(t, manager.Available(ctx))
-
- target.config.Port = port
- require.False(t, manager.Available(ctx))
- now = now.Add(targetAvailabilityCacheTTL)
- require.True(t, manager.Available(ctx))
-}
-
-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 TestManagerUsesFirstEnvironment(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"},
- {Title: "Test", Id: "test"},
- }},
- })
- 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 TestManagerAllowsNoEnvironment(t *testing.T) {
- ctx, _, s, _, manager := newConcreteManager(t)
- _, err := s.UpsertSetting(ctx, &store.SettingMessage{
- Name: storepb.SettingName_ENVIRONMENT,
- Workspace: "workspace-a",
- Value: &storepb.EnvironmentSetting{},
- })
- require.NoError(t, err)
-
- result, err := manager.Prepare(ctx, PrepareRequest{WorkspaceID: "workspace-a", ProjectID: "project-a"})
- require.NoError(t, err)
- require.Nil(t, result.Instance.EnvironmentID)
-}
-
-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: "test",
- 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: "test"},
- }},
- })
- 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.go
deleted file mode 100644
index 218b018597..0000000000
--- a/backend/component/sampleprojectinstance/metadata.go
+++ /dev/null
@@ -1,107 +0,0 @@
-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 inactive, 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: &registration.ProjectID,
- EnvironmentID: &registration.EnvironmentID,
- ResourceID: registration.InstanceID,
- Metadata: &storepb.Instance{
- Title: registration.Title,
- Engine: registration.Engine,
- Activation: false,
- 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.go
deleted file mode 100644
index 311ee35cd0..0000000000
--- a/backend/component/sampleprojectinstance/metadata_test.go
+++ /dev/null
@@ -1,107 +0,0 @@
-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.False(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_test.go b/backend/component/sampleprojectinstance/target_test.go
deleted file mode 100644
index 9c7432c87a..0000000000
--- a/backend/component/sampleprojectinstance/target_test.go
+++ /dev/null
@@ -1,519 +0,0 @@
-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: "unsupported TLS mode", targetURL: "postgres://postgres:[email protected]:5432/postgres?sslmode=prefer"},
- {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 TestNewTargetBuildsRegistrationConfigWithoutTLS(t *testing.T) {
- for _, targetURL := range []string{
- "postgres://control:[email protected]:5432/postgres",
- "postgres://control:[email protected]:5432/postgres?sslmode=disable",
- } {
- target, err := NewTarget(targetURL)
- require.NoError(t, err)
- require.Nil(t, target.config.TLSConfig)
-
- config, err := target.InstanceConfig(Allocation{
- Database: "sample_database",
- Role: "sample_role",
- Password: "sample-password",
- })
- require.NoError(t, err)
- require.False(t, config.AdminDataSource.UseSsl)
- require.False(t, config.AdminDataSource.VerifyTlsCertificate)
- require.Empty(t, config.AdminDataSource.SslCa)
- }
-}
-
-func TestNewTargetBuildsRegistrationConfigWithTLSWithoutVerification(t *testing.T) {
- target, err := NewTarget("postgres://control:[email protected]:5432/postgres?sslmode=require")
- require.NoError(t, err)
- require.NotNil(t, target.config.TLSConfig)
-
- config, err := target.InstanceConfig(Allocation{
- Database: "sample_database",
- Role: "sample_role",
- Password: "sample-password",
- })
- require.NoError(t, err)
- require.True(t, config.AdminDataSource.UseSsl)
- require.False(t, config.AdminDataSource.VerifyTlsCertificate)
- require.Empty(t, config.AdminDataSource.SslCa)
-}
-
-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 TestTargetValidateAllowsPublicAccess(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.NoError(t, newLocalTarget(t, container).Validate(ctx))
-}
-
-func TestTargetValidateAllowsExistingPublicDatabase(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)
- _, err := admin.Exec(ctx, "CREATE DATABASE existing_public_database")
- require.NoError(t, err)
- t.Cleanup(func() {
- _, _ = admin.Exec(context.Background(), "DROP DATABASE existing_public_database")
- })
-
- target := newLocalTarget(t, container)
- require.NoError(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/store/sample_instance.pb.go b/backend/generated-go/store/sample_instance.pb.go
new file mode 100644
index 0000000000..2b9650823f
--- /dev/null
+++ b/backend/generated-go/store/sample_instance.pb.go
@@ -0,0 +1,325 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// protoc-gen-go v1.36.12
+// protoc (unknown)
+// source: store/sample_instance.proto
+
+package store
+
+import (
+ protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+ reflect "reflect"
+ sync "sync"
+ unsafe "unsafe"
+)
+
+const (
+ // Verify that this generated code is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+ // Verify that runtime/protoimpl is sufficiently up-to-date.
+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type SaaSSampleInstanceSetupPayload struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
+ InstanceId string `protobuf:"bytes,2,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
+ Title string `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
+ EnvironmentId *string `protobuf:"bytes,4,opt,name=environment_id,json=environmentId,proto3,oneof" json:"environment_id,omitempty"`
+ DatabaseName string `protobuf:"bytes,5,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
+ RoleName string `protobuf:"bytes,6,opt,name=role_name,json=roleName,proto3" json:"role_name,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *SaaSSampleInstanceSetupPayload) Reset() {
+ *x = SaaSSampleInstanceSetupPayload{}
+ mi := &file_store_sample_instance_proto_msgTypes[0]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *SaaSSampleInstanceSetupPayload) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SaaSSampleInstanceSetupPayload) ProtoMessage() {}
+
+func (x *SaaSSampleInstanceSetupPayload) ProtoReflect() protoreflect.Message {
+ mi := &file_store_sample_instance_proto_msgTypes[0]
+ 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 SaaSSampleInstanceSetupPayload.ProtoReflect.Descriptor instead.
+func (*SaaSSampleInstanceSetupPayload) Descriptor() ([]byte, []int) {
+ return file_store_sample_instance_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetProjectId() string {
+ if x != nil {
+ return x.ProjectId
+ }
+ return ""
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetInstanceId() string {
+ if x != nil {
+ return x.InstanceId
+ }
+ return ""
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetTitle() string {
+ if x != nil {
+ return x.Title
+ }
+ return ""
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetEnvironmentId() string {
+ if x != nil && x.EnvironmentId != nil {
+ return *x.EnvironmentId
+ }
+ return ""
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetDatabaseName() string {
+ if x != nil {
+ return x.DatabaseName
+ }
+ return ""
+}
+
+func (x *SaaSSampleInstanceSetupPayload) GetRoleName() string {
+ if x != nil {
+ return x.RoleName
+ }
+ return ""
+}
+
+type SelfHostSampleInstanceSetupPayload struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ DatabaseProjectId string `protobuf:"bytes,1,opt,name=database_project_id,json=databaseProjectId,proto3" json:"database_project_id,omitempty"`
+ Instances []*SelfHostSampleInstanceSetupPayload_Instance `protobuf:"bytes,2,rep,name=instances,proto3" json:"instances,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *SelfHostSampleInstanceSetupPayload) Reset() {
+ *x = SelfHostSampleInstanceSetupPayload{}
+ mi := &file_store_sample_instance_proto_msgTypes[1]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *SelfHostSampleInstanceSetupPayload) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SelfHostSampleInstanceSetupPayload) ProtoMessage() {}
+
+func (x *SelfHostSampleInstanceSetupPayload) ProtoReflect() protoreflect.Message {
+ mi := &file_store_sample_instance_proto_msgTypes[1]
+ 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 SelfHostSampleInstanceSetupPayload.ProtoReflect.Descriptor instead.
+func (*SelfHostSampleInstanceSetupPayload) Descriptor() ([]byte, []int) {
+ return file_store_sample_instance_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *SelfHostSampleInstanceSetupPayload) GetDatabaseProjectId() string {
+ if x != nil {
+ return x.DatabaseProjectId
+ }
+ return ""
+}
+
+func (x *SelfHostSampleInstanceSetupPayload) GetInstances() []*SelfHostSampleInstanceSetupPayload_Instance {
+ if x != nil {
+ return x.Instances
+ }
+ return nil
+}
+
+type SelfHostSampleInstanceSetupPayload_Instance struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceId,proto3" json:"instance_id,omitempty"`
+ Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
+ EnvironmentId *string `protobuf:"bytes,3,opt,name=environment_id,json=environmentId,proto3,oneof" json:"environment_id,omitempty"`
+ PortOffset int32 `protobuf:"varint,4,opt,name=port_offset,json=portOffset,proto3" json:"port_offset,omitempty"`
+ DatabaseName string `protobuf:"bytes,5,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
+ RoleName string `protobuf:"bytes,6,opt,name=role_name,json=roleName,proto3" json:"role_name,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) Reset() {
+ *x = SelfHostSampleInstanceSetupPayload_Instance{}
+ mi := &file_store_sample_instance_proto_msgTypes[2]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SelfHostSampleInstanceSetupPayload_Instance) ProtoMessage() {}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) ProtoReflect() protoreflect.Message {
+ mi := &file_store_sample_instance_proto_msgTypes[2]
+ 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 SelfHostSampleInstanceSetupPayload_Instance.ProtoReflect.Descriptor instead.
+func (*SelfHostSampleInstanceSetupPayload_Instance) Descriptor() ([]byte, []int) {
+ return file_store_sample_instance_proto_rawDescGZIP(), []int{1, 0}
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetInstanceId() string {
+ if x != nil {
+ return x.InstanceId
+ }
+ return ""
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetTitle() string {
+ if x != nil {
+ return x.Title
+ }
+ return ""
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetEnvironmentId() string {
+ if x != nil && x.EnvironmentId != nil {
+ return *x.EnvironmentId
+ }
+ return ""
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetPortOffset() int32 {
+ if x != nil {
+ return x.PortOffset
+ }
+ return 0
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetDatabaseName() string {
+ if x != nil {
+ return x.DatabaseName
+ }
+ return ""
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) GetRoleName() string {
+ if x != nil {
+ return x.RoleName
+ }
+ return ""
+}
+
+var File_store_sample_instance_proto protoreflect.FileDescriptor
+
+const file_store_sample_instance_proto_rawDesc = "" +
+ "\n" +
+ "\x1bstore/sample_instance.proto\x12\x0ebytebase.store\"\xf7\x01\n" +
+ "\x1eSaaSSampleInstanceSetupPayload\x12\x1d\n" +
+ "\n" +
+ "project_id\x18\x01 \x01(\tR\tprojectId\x12\x1f\n" +
+ "\vinstance_id\x18\x02 \x01(\tR\n" +
+ "instanceId\x12\x14\n" +
+ "\x05title\x18\x03 \x01(\tR\x05title\x12*\n" +
+ "\x0eenvironment_id\x18\x04 \x01(\tH\x00R\renvironmentId\x88\x01\x01\x12#\n" +
+ "\rdatabase_name\x18\x05 \x01(\tR\fdatabaseName\x12\x1b\n" +
+ "\trole_name\x18\x06 \x01(\tR\broleNameB\x11\n" +
+ "\x0f_environment_id\"\x95\x03\n" +
+ "\"SelfHostSampleInstanceSetupPayload\x12.\n" +
+ "\x13database_project_id\x18\x01 \x01(\tR\x11databaseProjectId\x12Y\n" +
+ "\tinstances\x18\x02 \x03(\v2;.bytebase.store.SelfHostSampleInstanceSetupPayload.InstanceR\tinstances\x1a\xe3\x01\n" +
+ "\bInstance\x12\x1f\n" +
+ "\vinstance_id\x18\x01 \x01(\tR\n" +
+ "instanceId\x12\x14\n" +
+ "\x05title\x18\x02 \x01(\tR\x05title\x12*\n" +
+ "\x0eenvironment_id\x18\x03 \x01(\tH\x00R\renvironmentId\x88\x01\x01\x12\x1f\n" +
+ "\vport_offset\x18\x04 \x01(\x05R\n" +
+ "portOffset\x12#\n" +
+ "\rdatabase_name\x18\x05 \x01(\tR\fdatabaseName\x12\x1b\n" +
+ "\trole_name\x18\x06 \x01(\tR\broleNameB\x11\n" +
+ "\x0f_environment_idB\x96\x01\n" +
+ "\x12com.bytebase.storeB\x13SampleInstanceProtoP\x01Z\x12generated-go/store\xa2\x02\x03BSX\xaa\x02\x0eBytebase.Store\xca\x02\x0eBytebase\\Store\xe2\x02\x1aBytebase\\Store\\GPBMetadata\xea\x02\x0fBytebase::Storeb\x06proto3"
+
+var (
+ file_store_sample_instance_proto_rawDescOnce sync.Once
+ file_store_sample_instance_proto_rawDescData []byte
+)
+
+func file_store_sample_instance_proto_rawDescGZIP() []byte {
+ file_store_sample_instance_proto_rawDescOnce.Do(func() {
+ file_store_sample_instance_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_store_sample_instance_proto_rawDesc), len(file_store_sample_instance_proto_rawDesc)))
+ })
+ return file_store_sample_instance_proto_rawDescData
+}
+
+var file_store_sample_instance_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
+var file_store_sample_instance_proto_goTypes = []any{
+ (*SaaSSampleInstanceSetupPayload)(nil), // 0: bytebase.store.SaaSSampleInstanceSetupPayload
+ (*SelfHostSampleInstanceSetupPayload)(nil), // 1: bytebase.store.SelfHostSampleInstanceSetupPayload
+ (*SelfHostSampleInstanceSetupPayload_Instance)(nil), // 2: bytebase.store.SelfHostSampleInstanceSetupPayload.Instance
+}
+var file_store_sample_instance_proto_depIdxs = []int32{
+ 2, // 0: bytebase.store.SelfHostSampleInstanceSetupPayload.instances:type_name -> bytebase.store.SelfHostSampleInstanceSetupPayload.Instance
+ 1, // [1:1] is the sub-list for method output_type
+ 1, // [1:1] is the sub-list for method input_type
+ 1, // [1:1] is the sub-list for extension type_name
+ 1, // [1:1] is the sub-list for extension extendee
+ 0, // [0:1] is the sub-list for field type_name
+}
+
+func init() { file_store_sample_instance_proto_init() }
+func file_store_sample_instance_proto_init() {
+ if File_store_sample_instance_proto != nil {
+ return
+ }
+ file_store_sample_instance_proto_msgTypes[0].OneofWrappers = []any{}
+ file_store_sample_instance_proto_msgTypes[2].OneofWrappers = []any{}
+ type x struct{}
+ out := protoimpl.TypeBuilder{
+ File: protoimpl.DescBuilder{
+ GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+ RawDescriptor: unsafe.Slice(unsafe.StringData(file_store_sample_instance_proto_rawDesc), len(file_store_sample_instance_proto_rawDesc)),
+ NumEnums: 0,
+ NumMessages: 3,
+ NumExtensions: 0,
+ NumServices: 0,
+ },
+ GoTypes: file_store_sample_instance_proto_goTypes,
+ DependencyIndexes: file_store_sample_instance_proto_depIdxs,
+ MessageInfos: file_store_sample_instance_proto_msgTypes,
+ }.Build()
+ File_store_sample_instance_proto = out.File
+ file_store_sample_instance_proto_goTypes = nil
+ file_store_sample_instance_proto_depIdxs = nil
+}
diff --git a/backend/generated-go/store/sample_instance_equal.pb.go b/backend/generated-go/store/sample_instance_equal.pb.go
new file mode 100644
index 0000000000..41292b3e3a
--- /dev/null
+++ b/backend/generated-go/store/sample_instance_equal.pb.go
@@ -0,0 +1,81 @@
+// Code generated by protoc-gen-equal-go. DO NOT EDIT.
+// source: store/sample_instance.proto
+
+package store
+
+func (x *SaaSSampleInstanceSetupPayload) Equal(y *SaaSSampleInstanceSetupPayload) bool {
+ if x == y {
+ return true
+ }
+ if x == nil || y == nil {
+ return x == nil && y == nil
+ }
+ if x.ProjectId != y.ProjectId {
+ return false
+ }
+ if x.InstanceId != y.InstanceId {
+ return false
+ }
+ if x.Title != y.Title {
+ return false
+ }
+ if p, q := x.EnvironmentId, y.EnvironmentId; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+ return false
+ }
+ if x.DatabaseName != y.DatabaseName {
+ return false
+ }
+ if x.RoleName != y.RoleName {
+ return false
+ }
+ return true
+}
+
+func (x *SelfHostSampleInstanceSetupPayload_Instance) Equal(y *SelfHostSampleInstanceSetupPayload_Instance) bool {
+ if x == y {
+ return true
+ }
+ if x == nil || y == nil {
+ return x == nil && y == nil
+ }
+ if x.InstanceId != y.InstanceId {
+ return false
+ }
+ if x.Title != y.Title {
+ return false
+ }
+ if p, q := x.EnvironmentId, y.EnvironmentId; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
+ return false
+ }
+ if x.PortOffset != y.PortOffset {
+ return false
+ }
+ if x.DatabaseName != y.DatabaseName {
+ return false
+ }
+ if x.RoleName != y.RoleName {
+ return false
+ }
+ return true
+}
+
+func (x *SelfHostSampleInstanceSetupPayload) Equal(y *SelfHostSampleInstanceSetupPayload) bool {
+ if x == y {
+ return true
+ }
+ if x == nil || y == nil {
+ return x == nil && y == nil
+ }
+ if x.DatabaseProjectId != y.DatabaseProjectId {
+ return false
+ }
+ if len(x.Instances) != len(y.Instances) {
+ return false
+ }
+ for i := 0; i < len(x.Instances); i++ {
+ if !x.Instances[i].Equal(y.Instances[i]) {
+ return false
+ }
+ }
+ return true
+}
diff --git a/backend/generated-go/v1/actuator_service.pb.go b/backend/generated-go/v1/actuator_service.pb.go
index fd5a29c518..ccd242b9c4 100644
--- a/backend/generated-go/v1/actuator_service.pb.go
+++ b/backend/generated-go/v1/actuator_service.pb.go
@@ -103,11 +103,8 @@ type SampleInfo struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Whether sample setup is currently available.
Available bool `protobuf:"varint,1,opt,name=available,proto3" json:"available,omitempty"`
- // The provisioned sample instance.
- // Format: instances/{instance}
- Instance string `protobuf:"bytes,2,opt,name=instance,proto3" json:"instance,omitempty"`
- // The time when the provisioned sample resources expire.
- ExpireTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
+ // The provisioned sample instances.
+ Instances []*SampleInfo_Instance `protobuf:"bytes,2,rep,name=instances,proto3" json:"instances,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -149,16 +146,9 @@ func (x *SampleInfo) GetAvailable() bool {
return false
}
-func (x *SampleInfo) GetInstance() string {
- if x != nil {
- return x.Instance
- }
- return ""
-}
-
-func (x *SampleInfo) GetExpireTime() *timestamppb.Timestamp {
+func (x *SampleInfo) GetInstances() []*SampleInfo_Instance {
if x != nil {
- return x.ExpireTime
+ return x.Instances
}
return nil
}
@@ -338,19 +328,77 @@ func (x *ActuatorInfo) GetSample() *SampleInfo {
return nil
}
+// Instance describes one provisioned sample instance.
+type SampleInfo_Instance struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ // The provisioned sample instance.
+ // Format: instances/{instance}
+ Instance string `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
+ // The time when the provisioned sample instance expires.
+ ExpireTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *SampleInfo_Instance) Reset() {
+ *x = SampleInfo_Instance{}
+ mi := &file_v1_actuator_service_proto_msgTypes[4]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *SampleInfo_Instance) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SampleInfo_Instance) ProtoMessage() {}
+
+func (x *SampleInfo_Instance) ProtoReflect() protoreflect.Message {
+ mi := &file_v1_actuator_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 SampleInfo_Instance.ProtoReflect.Descriptor instead.
+func (*SampleInfo_Instance) Descriptor() ([]byte, []int) {
+ return file_v1_actuator_service_proto_rawDescGZIP(), []int{2, 0}
+}
+
+func (x *SampleInfo_Instance) GetInstance() string {
+ if x != nil {
+ return x.Instance
+ }
+ return ""
+}
+
+func (x *SampleInfo_Instance) GetExpireTime() *timestamppb.Timestamp {
+ if x != nil {
+ return x.ExpireTime
+ }
+ return nil
+}
+
var File_v1_actuator_service_proto protoreflect.FileDescriptor
const file_v1_actuator_service_proto_rawDesc = "" +
"\n" +
"\x19v1/actuator_service.proto\x12\vbytebase.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x13v1/annotation.proto\"\x14\n" +
"\x12SetupSampleRequest\"\x18\n" +
- "\x16GetActuatorInfoRequest\"\xac\x01\n" +
+ "\x16GetActuatorInfoRequest\"\xfe\x01\n" +
"\n" +
"SampleInfo\x12!\n" +
- "\tavailable\x18\x01 \x01(\bB\x03\xe0A\x03R\tavailable\x129\n" +
- "\binstance\x18\x02 \x01(\tB\x1d\xe0A\x03\xfaA\x17\n" +
+ "\tavailable\x18\x01 \x01(\bB\x03\xe0A\x03R\tavailable\x12C\n" +
+ "\tinstances\x18\x02 \x03(\v2 .bytebase.v1.SampleInfo.InstanceB\x03\xe0A\x03R\tinstances\x1a\x87\x01\n" +
+ "\bInstance\x129\n" +
+ "\binstance\x18\x01 \x01(\tB\x1d\xe0A\x03\xfaA\x17\n" +
"\x15bytebase.com/InstanceR\binstance\x12@\n" +
- "\vexpire_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
+ "\vexpire_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" +
"expireTime\"\x92\x06\n" +
"\fActuatorInfo\x12\x1d\n" +
"\aversion\x18\x01 \x01(\tB\x03\xe0A\x03R\aversion\x12\"\n" +
@@ -388,28 +436,30 @@ func file_v1_actuator_service_proto_rawDescGZIP() []byte {
return file_v1_actuator_service_proto_rawDescData
}
-var file_v1_actuator_service_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_v1_actuator_service_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
var file_v1_actuator_service_proto_goTypes = []any{
(*SetupSampleRequest)(nil), // 0: bytebase.v1.SetupSampleRequest
(*GetActuatorInfoRequest)(nil), // 1: bytebase.v1.GetActuatorInfoRequest
(*SampleInfo)(nil), // 2: bytebase.v1.SampleInfo
(*ActuatorInfo)(nil), // 3: bytebase.v1.ActuatorInfo
- (*timestamppb.Timestamp)(nil), // 4: google.protobuf.Timestamp
- (*emptypb.Empty)(nil), // 5: google.protobuf.Empty
+ (*SampleInfo_Instance)(nil), // 4: bytebase.v1.SampleInfo.Instance
+ (*timestamppb.Timestamp)(nil), // 5: google.protobuf.Timestamp
+ (*emptypb.Empty)(nil), // 6: google.protobuf.Empty
}
var file_v1_actuator_service_proto_depIdxs = []int32{
- 4, // 0: bytebase.v1.SampleInfo.expire_time:type_name -> google.protobuf.Timestamp
- 4, // 1: bytebase.v1.ActuatorInfo.last_active_time:type_name -> google.protobuf.Timestamp
+ 4, // 0: bytebase.v1.SampleInfo.instances:type_name -> bytebase.v1.SampleInfo.Instance
+ 5, // 1: bytebase.v1.ActuatorInfo.last_active_time:type_name -> google.protobuf.Timestamp
2, // 2: bytebase.v1.ActuatorInfo.sample:type_name -> bytebase.v1.SampleInfo
- 1, // 3: bytebase.v1.ActuatorService.GetActuatorInfo:input_type -> bytebase.v1.GetActuatorInfoRequest
- 0, // 4: bytebase.v1.ActuatorService.SetupSample:input_type -> bytebase.v1.SetupSampleRequest
- 3, // 5: bytebase.v1.ActuatorService.GetActuatorInfo:output_type -> bytebase.v1.ActuatorInfo
- 5, // 6: bytebase.v1.ActuatorService.SetupSample:output_type -> google.protobuf.Empty
- 5, // [5:7] is the sub-list for method output_type
- 3, // [3:5] is the sub-list for method input_type
- 3, // [3:3] is the sub-list for extension type_name
- 3, // [3:3] is the sub-list for extension extendee
- 0, // [0:3] is the sub-list for field type_name
+ 5, // 3: bytebase.v1.SampleInfo.Instance.expire_time:type_name -> google.protobuf.Timestamp
+ 1, // 4: bytebase.v1.ActuatorService.GetActuatorInfo:input_type -> bytebase.v1.GetActuatorInfoRequest
+ 0, // 5: bytebase.v1.ActuatorService.SetupSample:input_type -> bytebase.v1.SetupSampleRequest
+ 3, // 6: bytebase.v1.ActuatorService.GetActuatorInfo:output_type -> bytebase.v1.ActuatorInfo
+ 6, // 7: bytebase.v1.ActuatorService.SetupSample:output_type -> google.protobuf.Empty
+ 6, // [6:8] is the sub-list for method output_type
+ 4, // [4:6] is the sub-list for method input_type
+ 4, // [4:4] is the sub-list for extension type_name
+ 4, // [4:4] is the sub-list for extension extendee
+ 0, // [0:4] is the sub-list for field type_name
}
func init() { file_v1_actuator_service_proto_init() }
@@ -424,7 +474,7 @@ func file_v1_actuator_service_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_actuator_service_proto_rawDesc), len(file_v1_actuator_service_proto_rawDesc)),
NumEnums: 0,
- NumMessages: 4,
+ NumMessages: 5,
NumExtensions: 0,
NumServices: 1,
},
diff --git a/backend/generated-go/v1/actuator_service_equal.pb.go b/backend/generated-go/v1/actuator_service_equal.pb.go
index aaabf9dc49..8aa2c572ca 100644
--- a/backend/generated-go/v1/actuator_service_equal.pb.go
+++ b/backend/generated-go/v1/actuator_service_equal.pb.go
@@ -23,6 +23,22 @@ func (x *GetActuatorInfoRequest) Equal(y *GetActuatorInfoRequest) bool {
return true
}
+func (x *SampleInfo_Instance) Equal(y *SampleInfo_Instance) bool {
+ if x == y {
+ return true
+ }
+ if x == nil || y == nil {
+ return x == nil && y == nil
+ }
+ if x.Instance != y.Instance {
+ return false
+ }
+ if p, q := x.ExpireTime, y.ExpireTime; (p == nil && q != nil) || (p != nil && (q == nil || p.Seconds != q.Seconds || p.Nanos != q.Nanos)) {
+ return false
+ }
+ return true
+}
+
func (x *SampleInfo) Equal(y *SampleInfo) bool {
if x == y {
return true
@@ -33,11 +49,13 @@ func (x *SampleInfo) Equal(y *SampleInfo) bool {
if x.Available != y.Available {
return false
}
- if x.Instance != y.Instance {
+ if len(x.Instances) != len(y.Instances) {
return false
}
- if p, q := x.ExpireTime, y.ExpireTime; (p == nil && q != nil) || (p != nil && (q == nil || p.Seconds != q.Seconds || p.Nanos != q.Nanos)) {
- return false
+ for i := 0; i < len(x.Instances); i++ {
+ if !x.Instances[i].Equal(y.Instances[i]) {
+ return false
+ }
}
return true
}
diff --git a/backend/migrator/migration/3.22/0013##sample_instance_setup.sql b/backend/migrator/migration/3.22/0013##sample_instance_setup.sql
new file mode 100644
index 0000000000..d0d07f254b
--- /dev/null
+++ b/backend/migrator/migration/3.22/0013##sample_instance_setup.sql
@@ -0,0 +1,55 @@
+-- Tracks one sample setup lifecycle per workspace. The payload is owned by the
+-- selected sample manager implementation.
+CREATE TABLE sample_instance_setup (
+ workspace text PRIMARY KEY REFERENCES workspace(resource_id),
+ replica_id text NOT NULL,
+ payload jsonb NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ activated_at timestamptz,
+ expires_at timestamptz,
+ deleted_at timestamptz,
+ CHECK (expires_at IS NULL OR activated_at IS NOT NULL),
+ CHECK (deleted_at IS NULL OR activated_at IS NOT NULL)
+);
+
+INSERT INTO sample_instance_setup (
+ workspace,
+ replica_id,
+ payload,
+ created_at,
+ updated_at,
+ activated_at,
+ expires_at,
+ deleted_at
+)
+SELECT
+ workspace,
+ replica_id,
+ jsonb_build_object(
+ 'projectId', project,
+ 'instanceId', instance,
+ 'title', 'Sample Project Instance',
+ 'databaseName', db_name,
+ 'roleName', role_name
+ ),
+ created_at,
+ created_at,
+ CASE WHEN expires_at IS NULL THEN NULL ELSE expires_at - interval '7 days' END,
+ expires_at,
+ deleted_at
+FROM sample_project_instance;
+
+DO $$
+DECLARE
+ old_count bigint;
+ setup_count bigint;
+BEGIN
+ SELECT COUNT(*) INTO old_count FROM sample_project_instance;
+ SELECT COUNT(*) INTO setup_count FROM sample_instance_setup;
+ IF old_count <> setup_count THEN
+ RAISE EXCEPTION 'sample Project Instance migration count mismatch: old %, setup %', old_count, setup_count;
+ END IF;
+END $$;
+
+DROP TABLE sample_project_instance;
diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sql
index fb178c980d..f114d4a7a7 100644
--- a/backend/migrator/migration/LATEST.sql
+++ b/backend/migrator/migration/LATEST.sql
@@ -17,19 +17,19 @@ 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,
+-- Tracks one sample setup lifecycle per workspace. The payload is owned by the
+-- selected sample manager implementation.
+CREATE TABLE sample_instance_setup (
+ workspace text PRIMARY KEY REFERENCES workspace(resource_id),
replica_id text NOT NULL,
+ payload jsonb NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ activated_at timestamptz,
expires_at timestamptz,
deleted_at timestamptz,
- CHECK (deleted_at IS NULL OR expires_at IS NOT NULL)
+ CHECK (expires_at IS NULL OR activated_at IS NOT NULL),
+ CHECK (deleted_at IS NULL OR activated_at IS NOT NULL)
);
CREATE TABLE subscription (
diff --git a/backend/migrator/migrator_test.go b/backend/migrator/migrator_test.go
index e5f5b588c7..c56c29031f 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.12"), *files[len(files)-1].version)
- require.Equal(t, "migration/3.22/0012##login_attempt.sql", files[len(files)-1].path)
+ require.Equal(t, semver.MustParse("3.22.13"), *files[len(files)-1].version)
+ require.Equal(t, "migration/3.22/0013##sample_instance_setup.sql", files[len(files)-1].path)
}
func TestVersionUnique(t *testing.T) {
@@ -40,6 +40,50 @@ func TestVersionUnique(t *testing.T) {
}
}
+func TestMigration3_22_12MigratesSampleProjectInstance(t *testing.T) {
+ ctx := context.Background()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
+ db := container.GetDB()
+ _, err := db.ExecContext(ctx, `
+ CREATE TABLE workspace (resource_id text PRIMARY KEY);
+ INSERT INTO workspace (resource_id) VALUES ('workspace-a');
+ `)
+ require.NoError(t, err)
+ statement, err := migrationFS.ReadFile("migration/3.22/0011##sample_project_instance.sql")
+ require.NoError(t, err)
+ _, err = db.ExecContext(ctx, string(statement))
+ require.NoError(t, err)
+ createdAt := time.Date(2026, time.August, 1, 12, 0, 0, 0, time.UTC)
+ expiresAt := createdAt.Add(7 * 24 * time.Hour)
+ _, err = db.ExecContext(ctx, `
+ INSERT INTO sample_project_instance (
+ workspace, project, instance, db_name, role_name, replica_id,
+ created_at, expires_at
+ ) VALUES ('workspace-a', 'project-a', 'sample-a', 'db-a', 'role-a', 'replica-a', $1, $2)
+ `, createdAt, expiresAt)
+ require.NoError(t, err)
+ statement, err = migrationFS.ReadFile("migration/3.22/0013##sample_instance_setup.sql")
+ require.NoError(t, err)
+ _, err = db.ExecContext(ctx, string(statement))
+ require.NoError(t, err)
+
+ var instance string
+ var activatedAt time.Time
+ err = db.QueryRowContext(ctx, `
+ SELECT activated_at, payload->>'instanceId'
+ FROM sample_instance_setup
+ WHERE workspace = 'workspace-a'
+ `).Scan(&activatedAt, &instance)
+ require.NoError(t, err)
+ require.Equal(t, createdAt, activatedAt)
+ require.Equal(t, "sample-a", instance)
+
+ var oldTable *string
+ require.NoError(t, db.QueryRowContext(ctx, "SELECT to_regclass('sample_project_instance')").Scan(&oldTable))
+ require.Nil(t, oldTable)
+}
+
// TestMigration3_16_2_TaskRunLogDuplicateTimestamps verifies that the 3.16.2
// id-column cleanup succeeds on legacy task_run_log data holding duplicate
// (task_run_id, created_at) pairs, which were legal under the old id primary
diff --git a/backend/resources/postgres/embedded_instance.go b/backend/resources/postgres/embedded_instance.go
new file mode 100644
index 0000000000..2db043fd73
--- /dev/null
+++ b/backend/resources/postgres/embedded_instance.go
@@ -0,0 +1,96 @@
+package postgres
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "log/slog"
+ "os"
+ "path/filepath"
+
+ "github.com/jackc/pgx/v5"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/log"
+)
+
+// EmbeddedInstanceConfig configures one embedded PostgreSQL process and its
+// initial database.
+type EmbeddedInstanceConfig struct {
+ DataDir string
+ Port int
+ User string
+ DatabaseName string
+ SeedData string
+}
+
+// StartEmbeddedInstance initializes and starts one embedded PostgreSQL process.
+// The returned stopper preserves its data directory.
+func StartEmbeddedInstance(ctx context.Context, config EmbeddedInstanceConfig) (func(), error) {
+ if config.DataDir == "" || config.Port <= 0 || config.User == "" || config.DatabaseName == "" {
+ return nil, errors.New("embedded PostgreSQL instance requires data directory, port, user, and database")
+ }
+ if err := initDB(config.DataDir, config.User); err != nil {
+ return nil, errors.Wrap(err, "failed to initialize embedded PostgreSQL instance")
+ }
+ if err := start(config.Port, config.DataDir, true); err != nil {
+ return nil, errors.Wrap(err, "failed to start embedded PostgreSQL instance")
+ }
+ stopper := func() {
+ if err := stop(config.DataDir); err != nil {
+ slog.Error("failed to stop embedded PostgreSQL instance", log.BBError(err))
+ }
+ }
+ if err := setupEmbeddedInstance(ctx, config); err != nil {
+ stopper()
+ return nil, errors.Wrap(err, "failed to set up embedded PostgreSQL instance")
+ }
+ return stopper, nil
+}
+
+// RemoveEmbeddedInstance stops an embedded PostgreSQL process and removes its
+// exact data directory. A missing directory is successful.
+func RemoveEmbeddedInstance(dataDir string) error {
+ if dataDir == "" {
+ return errors.New("embedded PostgreSQL instance requires data directory")
+ }
+ if _, err := os.Stat(filepath.Join(dataDir, "PG_VERSION")); err == nil {
+ if err := stop(dataDir); err != nil {
+ slog.Debug("embedded PostgreSQL instance was not running during removal", log.BBError(err))
+ }
+ } else if !os.IsNotExist(err) {
+ return errors.Wrap(err, "failed to inspect embedded PostgreSQL instance data")
+ }
+ return errors.Wrap(os.RemoveAll(dataDir), "failed to remove embedded PostgreSQL instance data")
+}
+
+func setupEmbeddedInstance(ctx context.Context, config EmbeddedInstanceConfig) error {
+ defaultDB, err := sql.Open("pgx", fmt.Sprintf("user=%s host=%s port=%d database=postgres", config.User, common.GetPostgresSocketDir(), config.Port))
+ if err != nil {
+ return err
+ }
+ defer defaultDB.Close()
+
+ var exists bool
+ if err := defaultDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1);", config.DatabaseName).Scan(&exists); err != nil {
+ return err
+ }
+ if exists {
+ return nil
+ }
+ if _, err := defaultDB.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{config.DatabaseName}.Sanitize())); err != nil {
+ return errors.Wrap(err, "failed to create embedded PostgreSQL database")
+ }
+
+ database, err := sql.Open("pgx", fmt.Sprintf("user=%s host=%s port=%d database=%s", config.User, common.GetPostgresSocketDir(), config.Port, config.DatabaseName))
+ if err != nil {
+ return err
+ }
+ defer database.Close()
+ if config.SeedData == "" {
+ return nil
+ }
+ _, err = database.ExecContext(ctx, config.SeedData)
+ return err
+}
diff --git a/backend/resources/postgres/sample_instance.go b/backend/resources/postgres/sample_instance.go
deleted file mode 100644
index bf95eaedbb..0000000000
--- a/backend/resources/postgres/sample_instance.go
+++ /dev/null
@@ -1,131 +0,0 @@
-package postgres
-
-import (
- "context"
- "database/sql"
- "embed"
- "fmt"
- "io/fs"
- "log/slog"
- "path"
- "slices"
- "strings"
-
- "github.com/pkg/errors"
-
- "github.com/bytebase/bytebase/backend/common"
- "github.com/bytebase/bytebase/backend/common/log"
-)
-
-// Sample data is from https://github.com/bytebase/employee-sample-database/tree/main/postgres/dataset_small
-//
-//go:embed sample
-var sampleFS embed.FS
-
-var (
- SampleUser = "bbsample"
- SampleDatabaseTest = "hr_test"
- SampleDatabaseProd = "hr_prod"
-
- envs = []string{"test", "prod"}
- envDB = map[string]string{
- "test": SampleDatabaseTest,
- "prod": SampleDatabaseProd,
- }
-)
-
-// StartAllSampleInstances starts all postgres sample instances.
-func StartAllSampleInstances(ctx context.Context, dataDir string, basePort int) []func() {
- sampleData, err := LoadSampleData()
- if err != nil {
- slog.Error("failed to load sample data", log.BBError(err))
- return nil
- }
-
- slog.Info("-----Sample Postgres Instance BEGIN-----")
- stoppers := []func(){}
- for i, env := range envs {
- port := basePort + i
- dataDir := path.Join(dataDir, "pgdata-sample", env)
-
- if err := initDB(dataDir, SampleUser); err != nil {
- slog.Error("failed to init sample instance", log.BBError(err))
- continue
- }
-
- slog.Info(fmt.Sprintf("Start sample instance %v at port %d", env, port))
- if err := start(port, dataDir, true /* serverLog */); err != nil {
- slog.Error("failed to start sample instance", log.BBError(err))
- continue
- }
- stoppers = append(stoppers, func() {
- if err := stop(dataDir); err != nil {
- panic(err)
- }
- })
-
- if err := setupSampleInstance(ctx, envDB[env], port, sampleData); err != nil {
- slog.Error("failed to init sample instance", log.BBError(err))
- continue
- }
- }
-
- slog.Info("-----Sample Postgres Instance END-----")
- return stoppers
-}
-
-// LoadSampleData returns the ordered employee sample SQL embedded in this
-// package. Callers execute it in their own transaction.
-func LoadSampleData() (string, error) {
- // Load sample data
- names, err := fs.Glob(sampleFS, "sample/*.sql")
- if err != nil {
- return "", err
- }
- slices.Sort(names)
-
- var builder strings.Builder
- for _, name := range names {
- buf, err := fs.ReadFile(sampleFS, name)
- if err != nil {
- return "", errors.Wrapf(err, "failed to read sample database data: %s", name)
- }
- if _, err := builder.Write(buf); err != nil {
- return "", err
- }
- }
- return builder.String(), nil
-}
-
-// setupSampleInstance starts a single postgres sample instance.
-func setupSampleInstance(ctx context.Context, databaseName string, port int, sampleData string) error {
- defaultDB, err := sql.Open("pgx", fmt.Sprintf("user=%s host=%s port=%d database=postgres", SampleUser, common.GetPostgresSocketDir(), port))
- if err != nil {
- return err
- }
- defer defaultDB.Close()
-
- var ok bool
- if err := defaultDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1);", databaseName).Scan(&ok); err != nil {
- return err
- }
- if ok {
- slog.Info(fmt.Sprintf("Sample database %s already exists, skip setup", databaseName))
- return nil
- }
-
- if _, err := defaultDB.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", databaseName)); err != nil { // NOSONAR(go:S2077) databaseName is a hardcoded constant from envDB map, not user input
- return errors.Wrapf(err, "failed to create sample database")
- }
-
- db, err := sql.Open("pgx", fmt.Sprintf("user=%s host=%s port=%d database=%s", SampleUser, common.GetPostgresSocketDir(), port, databaseName))
- if err != nil {
- return err
- }
- defer db.Close()
-
- if _, err := db.ExecContext(ctx, sampleData); err != nil {
- return err
- }
- return nil
-}
diff --git a/backend/runner/sampleprojectinstance/cleanup.go b/backend/runner/sample/cleanup.go
similarity index 63%
rename from backend/runner/sampleprojectinstance/cleanup.go
rename to backend/runner/sample/cleanup.go
index 371a4b4de9..4719db8e67 100644
--- a/backend/runner/sampleprojectinstance/cleanup.go
+++ b/backend/runner/sample/cleanup.go
@@ -1,6 +1,6 @@
-// Package sampleprojectinstance periodically expires Cloud sample Project
-// Instances. Every replica runs this worker; row locking makes passes safe.
-package sampleprojectinstance
+// Package sample periodically reconciles stale or expired sample instance
+// setups. Every replica runs this worker; row locking makes passes safe.
+package sample
import (
"context"
@@ -11,20 +11,18 @@ import (
const interval = time.Hour
-// Runner performs startup and hourly sample Project Instance cleanup.
+// Runner performs startup and hourly sample instance cleanup.
type Runner struct {
manager cleanupManager
- clock func() time.Time
logger *slog.Logger
}
type cleanupManager interface {
- Cleanup(context.Context, time.Time) error
+ Cleanup(context.Context) error
}
// Options configures a cleanup runner.
type Options struct {
- Clock func() time.Time
Logger *slog.Logger
}
@@ -34,15 +32,11 @@ func NewRunner(manager cleanupManager, options ...Options) *Runner {
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,
}
}
@@ -64,13 +58,13 @@ func (r *Runner) Run(ctx context.Context, wg *sync.WaitGroup) {
}
}
-// RunOnce performs one Sample Project Instance cleanup pass.
+// RunOnce performs one Sample instance cleanup pass.
func (r *Runner) RunOnce(ctx context.Context) error {
- return r.manager.Cleanup(ctx, r.clock())
+ return r.manager.Cleanup(ctx)
}
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)
+ r.logger.ErrorContext(ctx, "Sample instance cleanup failed", "error", err)
}
}
diff --git a/backend/runner/sample/runner_test.go b/backend/runner/sample/runner_test.go
new file mode 100644
index 0000000000..09555501b1
--- /dev/null
+++ b/backend/runner/sample/runner_test.go
@@ -0,0 +1,54 @@
+package sample
+
+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 struct{}, 1)}
+ runner := NewRunner(manager)
+
+ var wg sync.WaitGroup
+ wg.Add(1)
+ go runner.Run(ctx, &wg)
+
+ <-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 TestRunnerRunOnceCallsCleanup(t *testing.T) {
+ manager := &cleanupManagerStub{calls: make(chan struct{}, 1)}
+ runner := NewRunner(manager)
+
+ require.NoError(t, runner.RunOnce(context.Background()))
+ <-manager.calls
+}
+
+type cleanupManagerStub struct {
+ calls chan struct{}
+}
+
+func (m *cleanupManagerStub) Cleanup(context.Context) error {
+ m.calls <- struct{}{}
+ return nil
+}
diff --git a/backend/runner/sampleprojectinstance/runner_test.go b/backend/runner/sampleprojectinstance/runner_test.go
deleted file mode 100644
index f1f5326a2b..0000000000
--- a/backend/runner/sampleprojectinstance/runner_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-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.go
index ce1d247062..dc12606b8b 100644
--- a/backend/server/grpc_routes.go
+++ b/backend/server/grpc_routes.go
@@ -27,8 +27,7 @@ import (
"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/sampleinstance"
- "github.com/bytebase/bytebase/backend/component/sampleprojectinstance"
+ "github.com/bytebase/bytebase/backend/component/sample"
"github.com/bytebase/bytebase/backend/component/sheet"
"github.com/bytebase/bytebase/backend/component/webhook"
"github.com/bytebase/bytebase/backend/enterprise"
@@ -51,8 +50,7 @@ func configureGrpcRouters(
webhookManager *webhook.Manager,
iamManager *iam.Manager,
secret string,
- sampleInstanceManager *sampleinstance.Manager,
- sampleProjectManager *sampleprojectinstance.Manager,
+ sampleManager sample.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.
@@ -94,7 +92,7 @@ func configureGrpcRouters(
)
aiService := apiv1.NewAIService(stores)
accessGrantService := apiv1.NewAccessGrantService(stores, licenseService, webhookManager, bus)
- actuatorService := apiv1.NewActuatorService(stores, profile, schemaSyncer, licenseService, sampleInstanceManager, sampleProjectManager)
+ actuatorService := apiv1.NewActuatorService(stores, profile, schemaSyncer, licenseService, sampleManager)
auditLogService := apiv1.NewAuditLogService(stores, licenseService)
authService := apiv1.NewAuthService(stores, secret, licenseService, profile, iamManager)
celService := apiv1.NewCelService()
@@ -105,7 +103,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, sampleProjectManager)
+ instanceService := apiv1.NewInstanceService(stores, profile, licenseService, dbFactory, schemaSyncer, sampleManager)
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/sample_project_instance_test.go b/backend/server/sample_project_instance_test.go
index 0ba6ca43fa..535628ed4b 100644
--- a/backend/server/sample_project_instance_test.go
+++ b/backend/server/sample_project_instance_test.go
@@ -9,13 +9,13 @@ import (
"github.com/stretchr/testify/require"
)
-func TestConfigureSampleProjectManagerDisablesInvalidTarget(t *testing.T) {
+func TestConfigureSampleManagerDisablesInvalidTarget(t *testing.T) {
var output bytes.Buffer
originalLogger := slog.Default()
slog.SetDefault(slog.New(slog.NewTextHandler(&output, nil)))
t.Cleanup(func() { slog.SetDefault(originalLogger) })
- manager := configureSampleProjectManager(
+ manager := configureSampleManager(
context.Background(),
"postgresql://control:[email protected]:5432/postgres?sslmode=prefer",
nil,
@@ -28,25 +28,25 @@ func TestConfigureSampleProjectManagerDisablesInvalidTarget(t *testing.T) {
require.NotContains(t, output.String(), "secret")
}
-func TestConfigureSampleProjectManagerIgnoresEmptyTarget(t *testing.T) {
+func TestConfigureSampleManagerIgnoresEmptyTarget(t *testing.T) {
var output bytes.Buffer
originalLogger := slog.Default()
slog.SetDefault(slog.New(slog.NewTextHandler(&output, nil)))
t.Cleanup(func() { slog.SetDefault(originalLogger) })
- manager := configureSampleProjectManager(context.Background(), "", nil, nil, "replica")
+ manager := configureSampleManager(context.Background(), "", nil, nil, "replica")
require.Nil(t, manager)
require.Empty(t, output.String())
}
-func TestConfigureSampleProjectManagerRetainsTemporarilyUnavailableTarget(t *testing.T) {
+func TestConfigureSampleManagerRetainsTemporarilyUnavailableTarget(t *testing.T) {
var output bytes.Buffer
originalLogger := slog.Default()
slog.SetDefault(slog.New(slog.NewTextHandler(&output, nil)))
t.Cleanup(func() { slog.SetDefault(originalLogger) })
- manager := configureSampleProjectManager(
+ manager := configureSampleManager(
context.Background(),
"postgresql://control:[email protected]:1/postgres",
nil,
diff --git a/backend/server/server.go b/backend/server/server.go
index 723af4c03f..767d609e64 100644
--- a/backend/server/server.go
+++ b/backend/server/server.go
@@ -27,8 +27,9 @@ import (
"github.com/bytebase/bytebase/backend/component/iam"
"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/sample"
+ "github.com/bytebase/bytebase/backend/component/sample/saas"
+ "github.com/bytebase/bytebase/backend/component/sample/selfhost"
"github.com/bytebase/bytebase/backend/component/sheet"
"github.com/bytebase/bytebase/backend/component/telemetry"
"github.com/bytebase/bytebase/backend/component/webhook"
@@ -42,7 +43,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"
+ samplerunner "github.com/bytebase/bytebase/backend/runner/sample"
"github.com/bytebase/bytebase/backend/runner/schemasync"
"github.com/bytebase/bytebase/backend/runner/taskrun"
"github.com/bytebase/bytebase/backend/store"
@@ -60,20 +61,19 @@ 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
- sampleProjectRunner *sampleprojectinstancerunner.Runner
- runnerWG sync.WaitGroup
-
- webhookManager *webhook.Manager
- iamManager *iam.Manager
- sampleInstanceManager *sampleinstance.Manager
- sampleProjectManager *sampleprojectinstance.Manager
+ taskScheduler *taskrun.Scheduler
+ planCheckScheduler *plancheck.Scheduler
+ schemaSyncer *schemasync.Syncer
+ approvalRunner *review.Runner
+ notifyListener *notifylistener.Listener
+ dataCleaner *cleaner.DataCleaner
+ heartbeatRunner *heartbeat.Runner
+ sampleRunner *samplerunner.Runner
+ runnerWG sync.WaitGroup
+
+ webhookManager *webhook.Manager
+ iamManager *iam.Manager
+ sampleManager sample.Manager
licenseService *enterprise.LicenseService
@@ -159,16 +159,10 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {
}
var workspaceID string
if !s.profile.SaaS {
- s.sampleInstanceManager = sampleinstance.NewManager(stores, profile)
-
// Load workspace-dependent settings if workspace exists.
// On first boot (no workspace yet), these remain at defaults and get
// initialized when the workspace is created and settings are updated via API.
if workspaceID, _ = stores.GetWorkspaceID(ctx); workspaceID != "" {
- if err := s.sampleInstanceManager.StartIfExist(ctx, workspaceID); err != nil {
- slog.Warn("failed to start sample instances", log.BBError(err))
- }
-
if workspaceProfileSetting, err := s.store.GetWorkspaceProfileSetting(ctx, workspaceID); err == nil {
logSetup = workspaceProfileSetting
if logSetup.GetEnableAuditLogStdout() && s.licenseService.IsFeatureEnabled(ctx, workspaceID, v1pb.PlanFeature_FEATURE_AUDIT_LOG) == nil {
@@ -221,15 +215,22 @@ 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 = configureSampleProjectManager(
+ s.sampleManager = configureSampleManager(
ctx,
profile.SampleProjectInstancePgURL,
stores,
s.schemaSyncer,
profile.ReplicaID,
)
- if s.sampleProjectManager != nil {
- s.sampleProjectRunner = sampleprojectinstancerunner.NewRunner(s.sampleProjectManager)
+ } else {
+ s.sampleManager = selfhost.NewManager(stores, profile, s.schemaSyncer, sample.ManagerOptions{ReplicaID: profile.ReplicaID})
+ }
+ if s.sampleManager != nil {
+ s.sampleRunner = samplerunner.NewRunner(s.sampleManager)
+ if workspaceID != "" {
+ if err := s.sampleManager.Start(ctx, workspaceID); err != nil {
+ slog.Warn("failed to start sample instances", log.BBError(err))
+ }
}
}
s.approvalRunner = review.NewRunner(stores, s.bus, s.webhookManager, s.licenseService)
@@ -256,7 +257,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, s.sampleProjectManager)
+ 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.sampleManager)
if err != nil {
return nil, errors.Wrapf(err, "failed to configure gRPC routers")
}
@@ -270,28 +271,28 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {
return s, nil
}
-func configureSampleProjectManager(
+func configureSampleManager(
ctx context.Context,
targetURL string,
stores *store.Store,
syncer *schemasync.Syncer,
replicaID string,
-) *sampleprojectinstance.Manager {
+) sample.Manager {
if targetURL == "" {
return nil
}
- manager, err := sampleprojectinstance.NewManagerFromURL(
+ manager, err := saas.NewManager(
stores,
targetURL,
syncer,
- sampleprojectinstance.ManagerOptions{ReplicaID: replicaID},
+ sample.ManagerOptions{ReplicaID: replicaID},
)
if err != nil {
slog.Warn("invalid SAMPLE_PROJECT_INSTANCE_PG_URL; Sample Project Instance is disabled", log.BBError(err))
return nil
}
- if err := manager.ValidateTarget(ctx); err != nil {
- slog.Warn("Sample Project Instance target is temporarily unavailable", log.BBError(err))
+ if !manager.Available(ctx) {
+ slog.Warn("Sample Project Instance target is temporarily unavailable")
}
return manager
}
@@ -317,9 +318,9 @@ 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 {
+ if s.sampleRunner != nil {
s.runnerWG.Add(1)
- go s.sampleProjectRunner.Run(ctx, &s.runnerWG)
+ go s.sampleRunner.Run(ctx, &s.runnerWG)
}
s.runnerWG.Add(1)
@@ -387,8 +388,8 @@ func (s *Server) Shutdown(ctx context.Context) error {
}
// Shutdown sample instances
- if s.sampleInstanceManager != nil {
- s.sampleInstanceManager.Stop()
+ if s.sampleManager != nil {
+ s.sampleManager.Stop()
}
// Shutdown postgres instances.
diff --git a/backend/store/instance.go b/backend/store/instance.go
index 926e75fa2d..3219905fc8 100644
--- a/backend/store/instance.go
+++ b/backend/store/instance.go
@@ -846,20 +846,6 @@ func (s *Store) deobfuscateInstances(ctx context.Context, instances []*InstanceM
return nil
}
-// HasSampleInstances checks if there are sample instances in the database.
-func (s *Store) HasSampleInstances(ctx context.Context, workspaceID string) (bool, error) {
- instances, err := s.ListInstances(ctx, &FindInstanceMessage{
- Workspace: workspaceID,
- WorkspaceOnly: true,
- ResourceIDs: &[]string{"test-sample-instance", "prod-sample-instance"},
- ShowDeleted: false,
- })
- if err != nil {
- return false, err
- }
- return len(instances) > 0, nil
-}
-
// DeleteInstance permanently purges a soft-deleted instance and all related resources.
// This operation is irreversible and should only be used for:
// - Administrative cleanup of old soft-deleted instances
diff --git a/backend/store/sample_instance.go b/backend/store/sample_instance.go
new file mode 100644
index 0000000000..b456fb7b8e
--- /dev/null
+++ b/backend/store/sample_instance.go
@@ -0,0 +1,353 @@
+package store
+
+import (
+ "context"
+ "database/sql"
+ "slices"
+ "time"
+
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common"
+)
+
+// SampleInstanceSetupMessage is the persisted lifecycle envelope for one
+// implementation-owned sample setup.
+type SampleInstanceSetupMessage struct {
+ WorkspaceID string
+ ReplicaID string
+ Payload []byte
+ CreatedAt time.Time
+ UpdatedAt time.Time
+ ActivatedAt *time.Time
+ ExpiresAt *time.Time
+ DeletedAt *time.Time
+}
+
+// SampleInstanceSetupTx owns a locked setup transaction during cleanup.
+type SampleInstanceSetupTx struct {
+ tx *sql.Tx
+ workspace string
+ replica string
+}
+
+// SampleInstanceCleanupResult describes one locked cleanup attempt.
+type SampleInstanceCleanupResult struct {
+ WorkspaceID string
+ Found bool
+ CallbackErr error
+}
+
+// GetSampleInstanceSetup returns the setup for a workspace.
+func (s *Store) GetSampleInstanceSetup(ctx context.Context, workspaceID string) (*SampleInstanceSetupMessage, error) {
+ return getSampleInstanceSetup(ctx, s.GetDB(), workspaceID)
+}
+
+// ReserveSampleInstanceSetup atomically consumes a workspace's setup
+// entitlement and persists the complete implementation payload.
+func (s *Store) ReserveSampleInstanceSetup(ctx context.Context, create *SampleInstanceSetupMessage) (*SampleInstanceSetupMessage, bool, error) {
+ tx, err := s.GetDB().BeginTx(ctx, nil)
+ if err != nil {
+ return nil, false, errors.Wrap(err, "failed to begin sample instance setup reservation")
+ }
+ 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 := getSampleInstanceSetup(ctx, tx, create.WorkspaceID)
+ if err != nil {
+ return nil, false, err
+ }
+ if existing != nil {
+ if err := tx.Commit(); err != nil {
+ return nil, false, errors.Wrap(err, "failed to commit sample instance setup lookup")
+ }
+ return existing, false, nil
+ }
+ if _, err := tx.ExecContext(ctx, `
+ INSERT INTO sample_instance_setup (workspace, replica_id, payload)
+ VALUES ($1, $2, $3::jsonb)
+ `, create.WorkspaceID, create.ReplicaID, create.Payload); err != nil {
+ return nil, false, errors.Wrap(err, "failed to reserve sample instance setup")
+ }
+ reserved, err := getSampleInstanceSetup(ctx, tx, create.WorkspaceID)
+ if err != nil {
+ return nil, false, err
+ }
+ if err := tx.Commit(); err != nil {
+ return nil, false, errors.Wrap(err, "failed to commit sample instance setup reservation")
+ }
+ return reserved, true, nil
+}
+
+// ClaimSampleInstanceSetup transfers an abandoned pending setup to replicaID.
+func (s *Store) ClaimSampleInstanceSetup(ctx context.Context, workspaceID string, observedUpdatedAt time.Time, replicaID string, attemptAge, heartbeatStaleness time.Duration) (*SampleInstanceSetupMessage, bool, error) {
+ var workspace string
+ err := s.GetDB().QueryRowContext(ctx, `
+ UPDATE sample_instance_setup
+ SET replica_id = $1, updated_at = now()
+ WHERE workspace = $2
+ AND updated_at = $3
+ AND activated_at IS NULL
+ AND deleted_at IS NULL
+ AND updated_at <= now() - $4::INTERVAL
+ AND (
+ replica_id = $1
+ OR NOT EXISTS (
+ SELECT 1 FROM replica_heartbeat
+ WHERE replica_id = sample_instance_setup.replica_id
+ AND last_heartbeat >= now() - $5::INTERVAL
+ )
+ )
+ RETURNING workspace
+ `, replicaID, workspaceID, observedUpdatedAt, attemptAge.String(), heartbeatStaleness.String()).Scan(&workspace)
+ if errors.Is(err, sql.ErrNoRows) {
+ return nil, false, nil
+ }
+ if err != nil {
+ return nil, false, errors.Wrap(err, "failed to claim sample instance setup")
+ }
+ setup, err := s.GetSampleInstanceSetup(ctx, workspace)
+ return setup, err == nil, err
+}
+
+// ActivateSampleInstanceSetup marks a setup active after validating its owning
+// workspace and projects are still active.
+func (s *Store) ActivateSampleInstanceSetup(ctx context.Context, workspaceID, replicaID string, projectIDs []string, activatedAt time.Time, expiresAt *time.Time) (bool, error) {
+ tx, err := s.GetDB().BeginTx(ctx, nil)
+ if err != nil {
+ return false, errors.Wrap(err, "failed to begin sample instance setup activation")
+ }
+ defer tx.Rollback()
+
+ setup, err := scanSampleInstanceSetup(tx.QueryRowContext(ctx, `
+ SELECT workspace, replica_id, payload, created_at, updated_at,
+ activated_at, expires_at, deleted_at
+ FROM sample_instance_setup
+ WHERE workspace = $1 AND replica_id = $2
+ AND activated_at IS NULL AND deleted_at IS NULL
+ FOR UPDATE
+ `, workspaceID, replicaID))
+ if errors.Is(err, sql.ErrNoRows) {
+ if err := tx.Commit(); err != nil {
+ return false, errors.Wrap(err, "failed to commit unchanged sample instance setup activation")
+ }
+ return false, nil
+ }
+ if err != nil {
+ return false, errors.Wrap(err, "failed to lock sample instance setup activation")
+ }
+
+ projects := slices.Clone(projectIDs)
+ slices.Sort(projects)
+ projects = slices.Compact(projects)
+ for _, projectID := range projects {
+ var deleted bool
+ if err := tx.QueryRowContext(ctx, `
+ SELECT deleted FROM project
+ WHERE workspace = $1 AND resource_id = $2
+ FOR UPDATE
+ `, workspaceID, projectID).Scan(&deleted); err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ return false, common.Errorf(common.NotFound, "project %s not found", projectID)
+ }
+ return false, errors.Wrapf(err, "failed to lock project %s for sample instance setup activation", projectID)
+ }
+ if deleted {
+ return false, common.Errorf(common.NotFound, "project %s is deleted", projectID)
+ }
+ }
+
+ var workspaceDeleted bool
+ if err := tx.QueryRowContext(ctx, `
+ SELECT deleted FROM workspace WHERE resource_id = $1 FOR UPDATE
+ `, workspaceID).Scan(&workspaceDeleted); err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ return false, common.Errorf(common.NotFound, "workspace %s not found", workspaceID)
+ }
+ return false, errors.Wrapf(err, "failed to lock workspace %s", workspaceID)
+ }
+ if workspaceDeleted {
+ return false, common.Errorf(common.NotFound, "workspace %s is deleted", workspaceID)
+ }
+
+ result, err := tx.ExecContext(ctx, `
+ UPDATE sample_instance_setup
+ SET activated_at = $1, expires_at = $2, updated_at = $1
+ WHERE workspace = $3 AND replica_id = $4
+ AND activated_at IS NULL AND deleted_at IS NULL
+ `, activatedAt, expiresAt, setup.WorkspaceID, setup.ReplicaID)
+ if err != nil {
+ return false, errors.Wrap(err, "failed to activate sample instance setup")
+ }
+ rows, err := result.RowsAffected()
+ if err != nil {
+ return false, errors.Wrap(err, "failed to inspect sample instance setup activation")
+ }
+ if err := tx.Commit(); err != nil {
+ return false, errors.Wrap(err, "failed to commit sample instance setup activation")
+ }
+ return rows == 1, nil
+}
+
+// DeletePendingSampleInstanceSetup removes an unactivated setup still owned by
+// replicaID.
+func (s *Store) DeletePendingSampleInstanceSetup(ctx context.Context, workspaceID, replicaID string) (bool, error) {
+ result, err := s.GetDB().ExecContext(ctx, `
+ DELETE FROM sample_instance_setup
+ WHERE workspace = $1 AND replica_id = $2
+ AND activated_at IS NULL AND deleted_at IS NULL
+ `, workspaceID, replicaID)
+ if err != nil {
+ return false, errors.Wrap(err, "failed to delete pending sample instance setup")
+ }
+ rows, err := result.RowsAffected()
+ return rows == 1, errors.Wrap(err, "failed to inspect pending sample instance setup deletion")
+}
+
+// CountSampleInstanceSetupsForCleanup counts stale pending or expired active
+// setups.
+func (s *Store) CountSampleInstanceSetupsForCleanup(ctx context.Context, now, staleBefore time.Time) (int, error) {
+ var count int
+ err := s.GetDB().QueryRowContext(ctx, `
+ SELECT COUNT(*) FROM sample_instance_setup
+ WHERE deleted_at IS NULL AND (
+ (activated_at IS NULL AND updated_at <= $2)
+ OR (activated_at IS NOT NULL AND expires_at IS NOT NULL AND expires_at <= $1)
+ )
+ `, now, staleBefore).Scan(&count)
+ return count, errors.Wrap(err, "failed to count sample instance setups for cleanup")
+}
+
+// WithLockedSampleInstanceSetupForCleanup locks one eligible setup of the
+// requested lifecycle state and invokes callback in the same transaction.
+func (s *Store) WithLockedSampleInstanceSetupForCleanup(ctx context.Context, now, staleBefore time.Time, afterWorkspace string, callback func(context.Context, *SampleInstanceSetupTx, *SampleInstanceSetupMessage) error) (*SampleInstanceCleanupResult, error) {
+ tx, err := s.GetDB().BeginTx(ctx, nil)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to begin sample instance cleanup")
+ }
+ defer tx.Rollback()
+
+ var workspace string
+ err = tx.QueryRowContext(ctx, `
+ SELECT workspace FROM sample_instance_setup
+ WHERE deleted_at IS NULL AND (
+ (activated_at IS NULL AND updated_at <= $2)
+ OR (activated_at IS NOT NULL AND expires_at IS NOT NULL AND expires_at <= $1)
+ )
+ AND workspace > $3
+ ORDER BY workspace
+ FOR UPDATE SKIP LOCKED
+ LIMIT 1
+ `, now, staleBefore, afterWorkspace).Scan(&workspace)
+ if errors.Is(err, sql.ErrNoRows) {
+ if err := tx.Commit(); err != nil {
+ return nil, errors.Wrap(err, "failed to commit empty sample instance cleanup")
+ }
+ return &SampleInstanceCleanupResult{}, nil
+ }
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to lock sample instance setup for cleanup")
+ }
+ setup, err := getSampleInstanceSetup(ctx, tx, workspace)
+ if err != nil {
+ return nil, err
+ }
+ result := &SampleInstanceCleanupResult{WorkspaceID: workspace, Found: true}
+ if err := callback(ctx, &SampleInstanceSetupTx{tx: tx, workspace: workspace, replica: setup.ReplicaID}, setup); err != nil {
+ result.CallbackErr = err
+ }
+ if err := tx.Commit(); err != nil {
+ return nil, errors.Wrap(err, "failed to commit sample instance cleanup")
+ }
+ return result, nil
+}
+
+// MarkDeleted marks an activated setup physically removed.
+func (tx *SampleInstanceSetupTx) MarkDeleted(ctx context.Context, deletedAt time.Time) error {
+ result, err := tx.tx.ExecContext(ctx, `
+ UPDATE sample_instance_setup SET deleted_at = $1, updated_at = $1
+ WHERE workspace = $2 AND replica_id = $3
+ AND activated_at IS NOT NULL AND deleted_at IS NULL
+ `, deletedAt, tx.workspace, tx.replica)
+ if err != nil {
+ return errors.Wrap(err, "failed to mark sample instance setup deleted")
+ }
+ rows, err := result.RowsAffected()
+ if err != nil {
+ return errors.Wrap(err, "failed to inspect sample instance setup deletion")
+ }
+ if rows != 1 {
+ return errors.Errorf("sample instance setup %q cannot be marked deleted", tx.workspace)
+ }
+ return nil
+}
+
+// DeleteReservation removes the locked pending setup.
+func (tx *SampleInstanceSetupTx) DeleteReservation(ctx context.Context) error {
+ result, err := tx.tx.ExecContext(ctx, `
+ DELETE FROM sample_instance_setup
+ WHERE workspace = $1 AND replica_id = $2
+ AND activated_at IS NULL AND deleted_at IS NULL
+ `, tx.workspace, tx.replica)
+ if err != nil {
+ return errors.Wrap(err, "failed to delete sample instance setup reservation")
+ }
+ rows, err := result.RowsAffected()
+ if err != nil {
+ return errors.Wrap(err, "failed to inspect sample instance setup reservation deletion")
+ }
+ if rows != 1 {
+ return errors.Errorf("sample instance setup %q cannot be deleted", tx.workspace)
+ }
+ return nil
+}
+
+type sampleInstanceDBTX interface {
+ QueryRowContext(context.Context, string, ...any) *sql.Row
+}
+
+func getSampleInstanceSetup(ctx context.Context, db sampleInstanceDBTX, workspaceID string) (*SampleInstanceSetupMessage, error) {
+ setup, err := scanSampleInstanceSetup(db.QueryRowContext(ctx, `
+ SELECT workspace, replica_id, payload, created_at, updated_at,
+ activated_at, expires_at, deleted_at
+ FROM sample_instance_setup 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 instance setup")
+ }
+ return setup, nil
+}
+
+type sampleInstanceScanner interface {
+ Scan(...any) error
+}
+
+func scanSampleInstanceSetup(scanner sampleInstanceScanner) (*SampleInstanceSetupMessage, error) {
+ setup := &SampleInstanceSetupMessage{}
+ err := scanner.Scan(
+ &setup.WorkspaceID,
+ &setup.ReplicaID,
+ &setup.Payload,
+ &setup.CreatedAt,
+ &setup.UpdatedAt,
+ &setup.ActivatedAt,
+ &setup.ExpiresAt,
+ &setup.DeletedAt,
+ )
+ return setup, err
+}
diff --git a/backend/store/sample_instance_test.go b/backend/store/sample_instance_test.go
new file mode 100644
index 0000000000..ee1158e2f6
--- /dev/null
+++ b/backend/store/sample_instance_test.go
@@ -0,0 +1,350 @@
+package store_test
+
+import (
+ "context"
+ "database/sql"
+ "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 newSampleInstanceFixture(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(),
+ )
+ stores, err := store.New(ctx, pgURL, false)
+ require.NoError(t, err)
+ t.Cleanup(func() { require.NoError(t, stores.Close()) })
+ return ctx, db, stores
+}
+
+func TestSampleInstanceSetupPersistsOpaquePayload(t *testing.T) {
+ ctx, _, stores := newSampleInstanceFixture(t)
+ create := &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"instances":[{"instanceId":"sample-a"}]}`),
+ }
+
+ got, created, err := stores.ReserveSampleInstanceSetup(ctx, create)
+ require.NoError(t, err)
+ require.True(t, created)
+ require.JSONEq(t, string(create.Payload), string(got.Payload))
+
+ again, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-b",
+ Payload: []byte(`{"instanceId":"different"}`),
+ })
+ require.NoError(t, err)
+ require.False(t, created)
+ require.JSONEq(t, string(create.Payload), string(again.Payload))
+
+ count, err := stores.CountSampleInstanceSetupsForCleanup(
+ ctx,
+ time.Now().Add(time.Hour),
+ time.Now().Add(time.Hour),
+ )
+ require.NoError(t, err)
+ require.Equal(t, 1, count)
+}
+
+func TestSampleInstanceSetupPermanentLifecycle(t *testing.T) {
+ ctx, _, stores := newSampleInstanceFixture(t)
+ setup := &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"databaseProjectId":"project-workspace-a","instances":[]}`),
+ }
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, setup)
+ require.NoError(t, err)
+ require.True(t, created)
+
+ activatedAt := time.Now().UTC().Truncate(time.Microsecond)
+ activated, err := stores.ActivateSampleInstanceSetup(
+ ctx,
+ "workspace-a",
+ "replica-a",
+ []string{"project-workspace-a"},
+ activatedAt,
+ nil,
+ )
+ require.NoError(t, err)
+ require.True(t, activated)
+ active, err := stores.GetSampleInstanceSetup(ctx, "workspace-a")
+ require.NoError(t, err)
+ require.Equal(t, activatedAt, *active.ActivatedAt)
+ require.Nil(t, active.ExpiresAt)
+
+ count, err := stores.CountSampleInstanceSetupsForCleanup(
+ ctx,
+ activatedAt.Add(365*24*time.Hour),
+ activatedAt.Add(365*24*time.Hour),
+ )
+ require.NoError(t, err)
+ require.Zero(t, count)
+}
+
+func TestSampleInstanceSetupCleanupIsWorkspaceScoped(t *testing.T) {
+ ctx, _, stores := newSampleInstanceFixture(t)
+ now := time.Now().UTC().Truncate(time.Microsecond)
+ for _, workspace := range []string{"workspace-a", "workspace-b"} {
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: workspace,
+ ReplicaID: "replica-a",
+ Payload: []byte(fmt.Sprintf(`{"instanceId":"sample-%s"}`, workspace)),
+ })
+ require.NoError(t, err)
+ require.True(t, created)
+ }
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-c",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"instances":[]}`),
+ })
+ require.NoError(t, err)
+ require.True(t, created)
+
+ beforeB, err := stores.GetSampleInstanceSetup(ctx, "workspace-b")
+ require.NoError(t, err)
+ result, err := stores.WithLockedSampleInstanceSetupForCleanup(
+ ctx,
+ now,
+ now.Add(time.Hour),
+ "",
+ func(ctx context.Context, tx *store.SampleInstanceSetupTx, setup *store.SampleInstanceSetupMessage) error {
+ require.Equal(t, "workspace-a", setup.WorkspaceID)
+ return tx.DeleteReservation(ctx)
+ },
+ )
+ require.NoError(t, err)
+ require.True(t, result.Found)
+ require.Equal(t, "workspace-a", result.WorkspaceID)
+
+ afterB, err := stores.GetSampleInstanceSetup(ctx, "workspace-b")
+ require.NoError(t, err)
+ require.Equal(t, beforeB, afterB)
+ selfHost, err := stores.GetSampleInstanceSetup(ctx, "workspace-c")
+ require.NoError(t, err)
+ require.NotNil(t, selfHost)
+}
+
+func TestSampleInstanceSetupDeletedRowRemainsTombstone(t *testing.T) {
+ ctx, _, stores := newSampleInstanceFixture(t)
+ now := time.Now().UTC().Truncate(time.Microsecond)
+ expiresAt := now.Add(time.Hour)
+ setup := &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"projectId":"project-workspace-a","instanceId":"sample-a"}`),
+ }
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, setup)
+ require.NoError(t, err)
+ require.True(t, created)
+ activated, err := stores.ActivateSampleInstanceSetup(
+ ctx,
+ "workspace-a",
+ "replica-a",
+ []string{"project-workspace-a"},
+ now,
+ &expiresAt,
+ )
+ require.NoError(t, err)
+ require.True(t, activated)
+
+ cleanupAt := expiresAt.Add(time.Second)
+ result, err := stores.WithLockedSampleInstanceSetupForCleanup(
+ ctx,
+ cleanupAt,
+ cleanupAt.Add(-time.Hour),
+ "",
+ func(ctx context.Context, tx *store.SampleInstanceSetupTx, _ *store.SampleInstanceSetupMessage) error {
+ return tx.MarkDeleted(ctx, cleanupAt)
+ },
+ )
+ require.NoError(t, err)
+ require.True(t, result.Found)
+
+ deleted, err := stores.GetSampleInstanceSetup(ctx, "workspace-a")
+ require.NoError(t, err)
+ require.Equal(t, cleanupAt, *deleted.DeletedAt)
+ again, created, err := stores.ReserveSampleInstanceSetup(ctx, setup)
+ require.NoError(t, err)
+ require.False(t, created)
+ require.Equal(t, deleted, again)
+}
+
+func TestActivateSampleInstanceSetupSerializesWithProjectArchive(t *testing.T) {
+ ctx, db, stores := newSampleInstanceFixture(t)
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"projectId":"project-workspace-a","instanceId":"sample-a"}`),
+ })
+ require.NoError(t, err)
+ require.True(t, created)
+
+ archiveTx, err := db.BeginTx(ctx, nil)
+ require.NoError(t, err)
+ committed := false
+ defer func() {
+ if !committed {
+ _ = archiveTx.Rollback()
+ }
+ }()
+ _, err = archiveTx.ExecContext(ctx, `
+ UPDATE project SET deleted = TRUE
+ WHERE workspace = 'workspace-a' AND resource_id = 'project-workspace-a'
+ `)
+ require.NoError(t, err)
+
+ result := make(chan error, 1)
+ go func() {
+ _, err := stores.ActivateSampleInstanceSetup(
+ ctx,
+ "workspace-a",
+ "replica-a",
+ []string{"project-workspace-a"},
+ time.Now(),
+ nil,
+ )
+ 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())
+ committed = true
+ require.Equal(t, common.NotFound, common.ErrorCode(<-result))
+
+ current, err := stores.GetSampleInstanceSetup(ctx, "workspace-a")
+ require.NoError(t, err)
+ require.Nil(t, current.ActivatedAt)
+}
+
+func TestProjectArchiveWaitsForSampleInstanceSetupActivation(t *testing.T) {
+ ctx, db, stores := newSampleInstanceFixture(t)
+ _, created, err := stores.ReserveSampleInstanceSetup(ctx, &store.SampleInstanceSetupMessage{
+ WorkspaceID: "workspace-a",
+ ReplicaID: "replica-a",
+ Payload: []byte(`{"projectId":"project-workspace-a","instanceId":"sample-a"}`),
+ })
+ require.NoError(t, err)
+ require.True(t, created)
+
+ workspaceTx, err := db.BeginTx(ctx, nil)
+ require.NoError(t, err)
+ committed := false
+ defer func() {
+ if !committed {
+ _ = workspaceTx.Rollback()
+ }
+ }()
+ var lockedWorkspace string
+ err = workspaceTx.QueryRowContext(ctx, `
+ SELECT resource_id FROM workspace
+ WHERE resource_id = 'workspace-a'
+ FOR UPDATE
+ `).Scan(&lockedWorkspace)
+ require.NoError(t, err)
+
+ activationResult := make(chan struct {
+ activated bool
+ err error
+ }, 1)
+ go func() {
+ activated, err := stores.ActivateSampleInstanceSetup(
+ ctx,
+ "workspace-a",
+ "replica-a",
+ []string{"project-workspace-a"},
+ time.Now(),
+ nil,
+ )
+ activationResult <- struct {
+ activated bool
+ err error
+ }{activated: activated, err: 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)
+
+ archiveResult := make(chan error, 1)
+ go func() {
+ _, err := db.ExecContext(ctx, `
+ UPDATE project SET deleted = TRUE
+ WHERE workspace = 'workspace-a' AND resource_id = 'project-workspace-a'
+ `)
+ archiveResult <- 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 '%UPDATE project SET deleted = TRUE%'
+ )
+ `).Scan(&waiting)
+ return err == nil && waiting
+ }, 5*time.Second, 10*time.Millisecond)
+
+ require.NoError(t, workspaceTx.Commit())
+ committed = true
+ activation := <-activationResult
+ require.NoError(t, activation.err)
+ require.True(t, activation.activated)
+ require.NoError(t, <-archiveResult)
+
+ current, err := stores.GetSampleInstanceSetup(ctx, "workspace-a")
+ require.NoError(t, err)
+ require.NotNil(t, current.ActivatedAt)
+ var projectDeleted bool
+ require.NoError(t, db.QueryRowContext(ctx, `
+ SELECT deleted FROM project
+ WHERE workspace = 'workspace-a' AND resource_id = 'project-workspace-a'
+ `).Scan(&projectDeleted))
+ require.True(t, projectDeleted)
+}
diff --git a/backend/store/sample_project_instance.go b/backend/store/sample_project_instance.go
deleted file mode 100644
index f4b6a868ef..0000000000
--- a/backend/store/sample_project_instance.go
+++ /dev/null
@@ -1,444 +0,0 @@
-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.go
deleted file mode 100644
index 0acb72366f..0000000000
--- a/backend/store/sample_project_instance_test.go
+++ /dev/null
@@ -1,504 +0,0 @@
-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/operations/sample-project-instance.md b/docs/operations/sample-project-instance.md
index 3bb162df0d..ab05469112 100644
--- a/docs/operations/sample-project-instance.md
+++ b/docs/operations/sample-project-instance.md
@@ -1,6 +1,11 @@
-# Operate Bytebase Cloud Sample Project Instances
+# Operate Sample 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 configured PostgreSQL target. A Workspace receives one lifetime entitlement. Do not provide reset tooling or expose a separate user-visible expired state.
+Self-host and SaaS sample instances use separate implementations behind one
+application lifecycle interface. Self-host creates an atomic pair of permanent
+workspace-level Test and Prod instances. SaaS creates one project-level
+instance with a seven-day lifetime and one lifetime entitlement per Workspace.
+The shared persistence envelope can also represent future self-host expiration
+without coupling the two implementations' provisioning details.
## Configure the target
@@ -19,9 +24,25 @@ An absent or syntactically invalid target configuration must not block server st
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.
+The independent control-plane setup is the Workspace's entitlement and atomic
+activation fence. `sample_instance_setup` stores the replica owner, an opaque
+implementation-specific JSONB payload, activation,
+expiration, and deletion. The SaaS and self-host payloads are separate store
+protocol messages, and each concrete manager decodes only its own payload.
+`activated_at` distinguishes a permanent active setup from a pending setup; an
+active setup with no `expires_at` is never selected merely because it is old.
+
+Each concrete manager owns compensation. It commits the pending reservation
+before contacting its 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. The original owner cannot
+activate or delete after takeover because those transitions are fenced by
+Workspace and replica ID. If preparation fails, the
+manager removes partial Bytebase metadata and the exact physical resources
+recorded in its payload before deleting the pending reservation. Failed
+compensation leaves the reservation for a later request or cleanup pass.
## Cleanup
@@ -29,7 +50,20 @@ Every replica runs cleanup once at startup and then hourly. Each pass scans elig
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.
+For an expired SaaS setup, cleanup removes the physical database and role and
+soft-deletes the Bytebase Instance. Database metadata remains retained under
+the archived Instance, and the setup row is marked deleted so the Workspace
+entitlement is not reset. A later restore is rejected because the physical
+resources no longer exist. Stale pending setup compensation instead hard-purges
+only partial Instance metadata, removes physical resources, and deletes the
+pending setup so the user can retry.
+
+For self-host, permanent active setups are not eligible for cleanup. Archiving
+one instance leaves the managed pair running while the other remains active;
+archiving both stops the pair without deleting its data directories. Restoring
+either starts the pair again. Existing `test-sample-instance` and
+`prod-sample-instance` resources keep the same pair-level behavior and are not
+migrated into managed setup rows.
## Logging and credential hygiene
diff --git a/frontend/src/components/SampleExpirationAlert.tsx b/frontend/src/components/SampleExpirationAlert.tsx
index 349855d8eb..35570d1374 100644
--- a/frontend/src/components/SampleExpirationAlert.tsx
+++ b/frontend/src/components/SampleExpirationAlert.tsx
@@ -15,10 +15,12 @@ export function SampleExpirationAlert({
}: SampleExpirationAlertProps) {
const { t } = useTranslation();
const sample = useAppStore((state) => state.serverInfo?.sample);
- const expireTime = sample?.expireTime;
const canonicalInstanceName = `instances/${extractInstanceResourceName(instanceName)}`;
+ const expireTime = sample?.instances.find(
+ ({ instance }) => instance === canonicalInstanceName
+ )?.expireTime;
- if (!expireTime || sample.instance !== canonicalInstanceName) {
+ if (!expireTime) {
return null;
}
diff --git a/frontend/src/components/instance/CreateInstanceView.test.tsx b/frontend/src/components/instance/CreateInstanceView.test.tsx
index de879b53e7..ec6996b0ef 100644
--- a/frontend/src/components/instance/CreateInstanceView.test.tsx
+++ b/frontend/src/components/instance/CreateInstanceView.test.tsx
@@ -15,7 +15,7 @@ const mocks = vi.hoisted(() => ({
pushNotification: vi.fn(),
isSaaSMode: false,
sampleAvailable: true,
- sampleInstance: "",
+ sampleInstances: [] as { instance: string }[],
totalInstanceCount: 0,
instanceCountLimit: 10,
activatedInstanceCount: 0,
@@ -67,7 +67,7 @@ vi.mock("@/stores/app", () => ({
serverInfo: {
sample: {
available: mocks.sampleAvailable,
- instance: mocks.sampleInstance,
+ instances: mocks.sampleInstances,
},
},
totalInstanceCount: () => mocks.totalInstanceCount,
@@ -130,7 +130,7 @@ beforeEach(async () => {
vi.clearAllMocks();
mocks.isSaaSMode = false;
mocks.sampleAvailable = true;
- mocks.sampleInstance = "";
+ mocks.sampleInstances = [];
mocks.totalInstanceCount = 0;
mocks.instanceCountLimit = 10;
mocks.activatedInstanceCount = 0;
@@ -380,7 +380,7 @@ describe("CreateInstanceView", () => {
test("hides sample instance creation when a sample was already provisioned", () => {
mocks.isSaaSMode = true;
- mocks.sampleInstance = "instances/sample";
+ mocks.sampleInstances = [{ instance: "instances/sample" }];
const container = document.createElement("div");
const root = createRoot(container);
diff --git a/frontend/src/components/instance/CreateInstanceView.tsx b/frontend/src/components/instance/CreateInstanceView.tsx
index f246541ca4..c7cb50683b 100644
--- a/frontend/src/components/instance/CreateInstanceView.tsx
+++ b/frontend/src/components/instance/CreateInstanceView.tsx
@@ -44,7 +44,7 @@ export function CreateInstanceView({
(state) => state.serverInfo?.sample?.available ?? false
);
const sampleProvisioned = useAppStore(
- (state) => !!state.serverInfo?.sample?.instance
+ (state) => (state.serverInfo?.sample?.instances.length ?? 0) > 0
);
const totalInstanceCount = useAppStore((state) => state.totalInstanceCount());
const canPrepareSampleProjectInstance =
diff --git a/frontend/src/components/instance/InstanceDetailView.test.tsx b/frontend/src/components/instance/InstanceDetailView.test.tsx
index c217b4afa4..acd549cb6f 100644
--- a/frontend/src/components/instance/InstanceDetailView.test.tsx
+++ b/frontend/src/components/instance/InstanceDetailView.test.tsx
@@ -51,8 +51,10 @@ const mocks = vi.hoisted(() => ({
serverInfo: { defaultProject: "projects/default" } as {
defaultProject: string;
sample?: {
- instance: string;
- expireTime?: { seconds: bigint; nanos: number };
+ instances: {
+ instance: string;
+ expireTime?: { seconds: bigint; nanos: number };
+ }[];
};
},
}));
@@ -297,11 +299,17 @@ describe("InstanceDetailView", () => {
mocks.serverInfo = {
defaultProject: "projects/default",
sample: {
- instance: "instances/prod",
- expireTime: {
- seconds: BigInt(Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60),
- nanos: 0,
- },
+ instances: [
+ {
+ instance: "instances/prod",
+ expireTime: {
+ seconds: BigInt(
+ Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60
+ ),
+ nanos: 0,
+ },
+ },
+ ],
},
};
mocks.instance = {
@@ -322,11 +330,15 @@ describe("InstanceDetailView", () => {
mocks.serverInfo = {
defaultProject: "projects/default",
sample: {
- instance: "instances/prod",
- expireTime: {
- seconds: BigInt(Math.floor(Date.now() / 1000) - 60),
- nanos: 0,
- },
+ instances: [
+ {
+ instance: "instances/prod",
+ expireTime: {
+ seconds: BigInt(Math.floor(Date.now() / 1000) - 60),
+ nanos: 0,
+ },
+ },
+ ],
},
};
diff --git a/frontend/src/routes/project/ProjectDatabaseDetailPage.test.tsx b/frontend/src/routes/project/ProjectDatabaseDetailPage.test.tsx
index 3e0bd145e7..0307e0b5a2 100644
--- a/frontend/src/routes/project/ProjectDatabaseDetailPage.test.tsx
+++ b/frontend/src/routes/project/ProjectDatabaseDetailPage.test.tsx
@@ -180,8 +180,10 @@ const mocks = vi.hoisted(() => {
},
serverInfo: {} as {
sample?: {
- instance: string;
- expireTime?: { seconds: bigint; nanos: number };
+ instances: {
+ instance: string;
+ expireTime?: { seconds: bigint; nanos: number };
+ }[];
};
},
};
@@ -553,11 +555,17 @@ describe("ProjectDatabaseDetailPage", () => {
test("shows the sample expiration warning for a sample database", async () => {
mocks.serverInfo = {
sample: {
- instance: "instances/inst1",
- expireTime: {
- seconds: BigInt(Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60),
- nanos: 0,
- },
+ instances: [
+ {
+ instance: "instances/inst1",
+ expireTime: {
+ seconds: BigInt(
+ Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60
+ ),
+ nanos: 0,
+ },
+ },
+ ],
},
};
mocks.useProjectDatabaseDetail.mockReturnValue({
diff --git a/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts b/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts
index 4c616f9158..0987793e42 100644
--- a/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts
+++ b/frontend/src/types/proto-es/v1/actuator_service_pb.d.ts
@@ -52,27 +52,47 @@ export declare type SampleInfo = Message<"bytebase.v1.SampleInfo"> & {
*/
available: boolean;
+ /**
+ * The provisioned sample instances.
+ *
+ * @generated from field: repeated bytebase.v1.SampleInfo.Instance instances = 2;
+ */
+ instances: SampleInfo_Instance[];
+};
+
+/**
+ * Describes the message bytebase.v1.SampleInfo.
+ * Use `create(SampleInfoSchema)` to create a new message.
+ */
+export declare const SampleInfoSchema: GenMessage<SampleInfo>;
+
+/**
+ * Instance describes one provisioned sample instance.
+ *
+ * @generated from message bytebase.v1.SampleInfo.Instance
+ */
+export declare type SampleInfo_Instance = Message<"bytebase.v1.SampleInfo.Instance"> & {
/**
* The provisioned sample instance.
* Format: instances/{instance}
*
- * @generated from field: string instance = 2;
+ * @generated from field: string instance = 1;
*/
instance: string;
/**
- * The time when the provisioned sample resources expire.
+ * The time when the provisioned sample instance expires.
*
- * @generated from field: google.protobuf.Timestamp expire_time = 3;
+ * @generated from field: google.protobuf.Timestamp expire_time = 2;
*/
expireTime?: Timestamp | undefined;
};
/**
- * Describes the message bytebase.v1.SampleInfo.
- * Use `create(SampleInfoSchema)` to create a new message.
+ * Describes the message bytebase.v1.SampleInfo.Instance.
+ * Use `create(SampleInfo_InstanceSchema)` to create a new message.
*/
-export declare const SampleInfoSchema: GenMessage<SampleInfo>;
+export declare const SampleInfo_InstanceSchema: GenMessage<SampleInfo_Instance>;
/**
* System information and configuration for the Bytebase instance.
diff --git a/frontend/src/types/proto-es/v1/actuator_service_pb.js b/frontend/src/types/proto-es/v1/actuator_service_pb.js
index 5dced538eb..26a2f789f5 100644
--- a/frontend/src/types/proto-es/v1/actuator_service_pb.js
+++ b/frontend/src/types/proto-es/v1/actuator_service_pb.js
@@ -14,7 +14,7 @@ import { file_v1_annotation } from "./annotation_pb";
* Describes the file v1/actuator_service.proto.
*/
export const file_v1_actuator_service = /*@__PURE__*/
- fileDesc("Chl2MS9hY3R1YXRvcl9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSIUChJTZXR1cFNhbXBsZVJlcXVlc3QiGAoWR2V0QWN0dWF0b3JJbmZvUmVxdWVzdCKLAQoKU2FtcGxlSW5mbxIWCglhdmFpbGFibGUYASABKAhCA+BBAxIvCghpbnN0YW5jZRgCIAEoCUId4EED+kEXChVieXRlYmFzZS5jb20vSW5zdGFuY2USNAoLZXhwaXJlX3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMisQQKDEFjdHVhdG9ySW5mbxIUCgd2ZXJzaW9uGAEgASgJQgPgQQMSFwoKZ2l0X2NvbW1pdBgCIAEoCUID4EEDEhEKBHNhYXMYBCABKAhCA+BBAxIZCgxleHRlcm5hbF91cmwYCCABKAlCA+BBAxI5ChBsYXN0X2FjdGl2ZV90aW1lGAsgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDEhYKCXdvcmtzcGFjZRgNIAEoCUID4EEDEiAKE3VubGljZW5zZWRfZmVhdHVyZXMYDyADKAlCA+BBAxIlChhhY3RpdmF0ZWRfaW5zdGFuY2VfY291bnQYFCABKAVCA+BBAxIhChR0b3RhbF9pbnN0YW5jZV9jb3VudBgVIAEoBUID4EEDEiMKFmV4dGVybmFsX3VybF9mcm9tX2ZsYWcYFyABKAhCA+BBAxIaCg1yZXBsaWNhX2NvdW50GBggASgFQgPgQQMSHAoPZGVmYXVsdF9wcm9qZWN0GBogASgJQgPgQQMSHgoRdXNlcl9jb3VudF9pbl9pYW0YGyABKAVCA+BBAxIiChVhY3RpdmVfdmNzX3VzZXJfY291bnQYHCABKAVCA+BBAxIsCgZzYW1wbGUYHSABKAsyFy5ieXRlYmFzZS52MS5TYW1wbGVJbmZvQgPgQQNKBAgDEARKBAgFEAhKBAgJEApKBAgKEAtKBAgMEA1KBAgOEA9KBAgQEBRKBAgWEBdKBAgZEBoylwIKD0FjdHVhdG9yU2VydmljZRJzCg9HZXRBY3R1YXRvckluZm8SIy5ieXRlYmFzZS52MS5HZXRBY3R1YXRvckluZm9SZXF1ZXN0GhkuYnl0ZWJhc2UudjEuQWN0dWF0b3JJbmZvIiDaQQCg6jABgtPkkwITEhEvdjEvYWN0dWF0b3IvaW5mbxKOAQoLU2V0dXBTYW1wbGUSHy5ieXRlYmFzZS52MS5TZXR1cFNhbXBsZVJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiRorqMBJiYi5wcm9qZWN0cy5jcmVhdGWQ6jABmOowAaDqMASo6jAJgtPkkwIaIhgvdjEvYWN0dWF0b3I6c2V0dXBTYW1wbGVCqgEKD2NvbS5ieXRlYmFzZS52MUIUQWN0dWF0b3JTZXJ2aWNlUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_timestamp, file_v1_annotation]);
+ fileDesc("Chl2MS9hY3R1YXRvcl9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSIUChJTZXR1cFNhbXBsZVJlcXVlc3QiGAoWR2V0QWN0dWF0b3JJbmZvUmVxdWVzdCLRAQoKU2FtcGxlSW5mbxIWCglhdmFpbGFibGUYASABKAhCA+BBAxI4CglpbnN0YW5jZXMYAiADKAsyIC5ieXRlYmFzZS52MS5TYW1wbGVJbmZvLkluc3RhbmNlQgPgQQMacQoISW5zdGFuY2USLwoIaW5zdGFuY2UYASABKAlCHeBBA/pBFwoVYnl0ZWJhc2UuY29tL0luc3RhbmNlEjQKC2V4cGlyZV90aW1lGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLlRpbWVzdGFtcEID4EEDIrEECgxBY3R1YXRvckluZm8SFAoHdmVyc2lvbhgBIAEoCUID4EEDEhcKCmdpdF9jb21taXQYAiABKAlCA+BBAxIRCgRzYWFzGAQgASgIQgPgQQMSGQoMZXh0ZXJuYWxfdXJsGAggASgJQgPgQQMSOQoQbGFzdF9hY3RpdmVfdGltZRgLIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAxIWCgl3b3Jrc3BhY2UYDSABKAlCA+BBAxIgChN1bmxpY2Vuc2VkX2ZlYXR1cmVzGA8gAygJQgPgQQMSJQoYYWN0aXZhdGVkX2luc3RhbmNlX2NvdW50GBQgASgFQgPgQQMSIQoUdG90YWxfaW5zdGFuY2VfY291bnQYFSABKAVCA+BBAxIjChZleHRlcm5hbF91cmxfZnJvbV9mbGFnGBcgASgIQgPgQQMSGgoNcmVwbGljYV9jb3VudBgYIAEoBUID4EEDEhwKD2RlZmF1bHRfcHJvamVjdBgaIAEoCUID4EEDEh4KEXVzZXJfY291bnRfaW5faWFtGBsgASgFQgPgQQMSIgoVYWN0aXZlX3Zjc191c2VyX2NvdW50GBwgASgFQgPgQQMSLAoGc2FtcGxlGB0gASgLMhcuYnl0ZWJhc2UudjEuU2FtcGxlSW5mb0ID4EEDSgQIAxAESgQIBRAISgQICRAKSgQIChALSgQIDBANSgQIDhAPSgQIEBAUSgQIFhAXSgQIGRAaMpcCCg9BY3R1YXRvclNlcnZpY2UScwoPR2V0QWN0dWF0b3JJbmZvEiMuYnl0ZWJhc2UudjEuR2V0QWN0dWF0b3JJbmZvUmVxdWVzdBoZLmJ5dGViYXNlLnYxLkFjdHVhdG9ySW5mbyIg2kEAoOowAYLT5JMCExIRL3YxL2FjdHVhdG9yL2luZm8SjgEKC1NldHVwU2FtcGxlEh8uYnl0ZWJhc2UudjEuU2V0dXBTYW1wbGVSZXF1ZXN0GhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5IkaK6jASYmIucHJvamVjdHMuY3JlYXRlkOowAZjqMAGg6jAEqOowCYLT5JMCGiIYL3YxL2FjdHVhdG9yOnNldHVwU2FtcGxlQqoBCg9jb20uYnl0ZWJhc2UudjFCFEFjdHVhdG9yU2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_timestamp, file_v1_annotation]);
/**
* Describes the message bytebase.v1.SetupSampleRequest.
@@ -37,6 +37,13 @@ export const GetActuatorInfoRequestSchema = /*@__PURE__*/
export const SampleInfoSchema = /*@__PURE__*/
messageDesc(file_v1_actuator_service, 2);
+/**
+ * Describes the message bytebase.v1.SampleInfo.Instance.
+ * Use `create(SampleInfo_InstanceSchema)` to create a new message.
+ */
+export const SampleInfo_InstanceSchema = /*@__PURE__*/
+ messageDesc(file_v1_actuator_service, 2, 0);
+
/**
* Describes the message bytebase.v1.ActuatorInfo.
* Use `create(ActuatorInfoSchema)` to create a new message.
diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yaml
index 7628c9818e..eb41c0d2d8 100644
--- a/proto/gen/grpc-doc/openapi.yaml
+++ b/proto/gen/grpc-doc/openapi.yaml
@@ -29209,6 +29209,19 @@ components:
title: available
description: Whether sample setup is currently available.
readOnly: true
+ instances:
+ type: array
+ items:
+ $ref: '#/components/schemas/bytebase.v1.SampleInfo.Instance'
+ title: instances
+ description: The provisioned sample instances.
+ readOnly: true
+ title: SampleInfo
+ additionalProperties: false
+ description: SampleInfo describes sample setup availability and provisioned resources.
+ bytebase.v1.SampleInfo.Instance:
+ type: object
+ properties:
instance:
type: string
title: instance
@@ -29218,12 +29231,12 @@ components:
readOnly: true
expireTime:
title: expire_time
- description: The time when the provisioned sample resources expire.
+ description: The time when the provisioned sample instance expires.
readOnly: true
$ref: '#/components/schemas/google.protobuf.Timestamp'
- title: SampleInfo
+ title: Instance
additionalProperties: false
- description: SampleInfo describes sample setup availability and provisioned resources.
+ description: Instance describes one provisioned sample instance.
bytebase.v1.SavedQuery:
type: object
properties:
diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.md
index 04f5373630..2a1fbd452d 100644
--- a/proto/gen/grpc-doc/store/README.md
+++ b/proto/gen/grpc-doc/store/README.md
@@ -244,6 +244,11 @@
- [store/role.proto](#store_role-proto)
- [RolePermissions](#bytebase-store-RolePermissions)
+- [store/sample_instance.proto](#store_sample_instance-proto)
+ - [SaaSSampleInstanceSetupPayload](#bytebase-store-SaaSSampleInstanceSetupPayload)
+ - [SelfHostSampleInstanceSetupPayload](#bytebase-store-SelfHostSampleInstanceSetupPayload)
+ - [SelfHostSampleInstanceSetupPayload.Instance](#bytebase-store-SelfHostSampleInstanceSetupPayload-Instance)
+
- [store/saved_query.proto](#store_saved_query-proto)
- [SavedQueryBinding](#bytebase-store-SavedQueryBinding)
- [SavedQueryPayload](#bytebase-store-SavedQueryPayload)
@@ -4157,6 +4162,78 @@ The severity level for SQL review rules.
+<a name="store_sample_instance-proto"></a>
+<p align="right"><a href="#top">Top</a></p>
+
+## store/sample_instance.proto
+
+
+
+<a name="bytebase-store-SaaSSampleInstanceSetupPayload"></a>
+
+### SaaSSampleInstanceSetupPayload
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| project_id | [string](#string) | | |
+| instance_id | [string](#string) | | |
+| title | [string](#string) | | |
+| environment_id | [string](#string) | optional | |
+| database_name | [string](#string) | | |
+| role_name | [string](#string) | | |
+
+
+
+
+
+
+<a name="bytebase-store-SelfHostSampleInstanceSetupPayload"></a>
+
+### SelfHostSampleInstanceSetupPayload
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| database_project_id | [string](#string) | | |
+| instances | [SelfHostSampleInstanceSetupPayload.Instance](#bytebase-store-SelfHostSampleInstanceSetupPayload-Instance) | repeated | |
+
+
+
+
+
+
+<a name="bytebase-store-SelfHostSampleInstanceSetupPayload-Instance"></a>
+
+### SelfHostSampleInstanceSetupPayload.Instance
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| instance_id | [string](#string) | | |
+| title | [string](#string) | | |
+| environment_id | [string](#string) | optional | |
+| port_offset | [int32](#int32) | | |
+| database_name | [string](#string) | | |
+| role_name | [string](#string) | | |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
<a name="store_saved_query-proto"></a>
<p align="right"><a href="#top">Top</a></p>
diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.html
index 78288ff7a4..606c776694 100644
--- a/proto/gen/grpc-doc/store/index.html
+++ b/proto/gen/grpc-doc/store/index.html
@@ -1150,6 +1150,29 @@
+ </ul>
+ </li>
+
+
+ <li>
+ <a href="#store%2fsample_instance.proto">store/sample_instance.proto</a>
+ <ul>
+
+ <li>
+ <a href="#bytebase.store.SaaSSampleInstanceSetupPayload"><span class="badge">M</span>SaaSSampleInstanceSetupPayload</a>
+ </li>
+
+ <li>
+ <a href="#bytebase.store.SelfHostSampleInstanceSetupPayload"><span class="badge">M</span>SelfHostSampleInstanceSetupPayload</a>
+ </li>
+
+ <li>
+ <a href="#bytebase.store.SelfHostSampleInstanceSetupPayload.Instance"><span class="badge">M</span>SelfHostSampleInstanceSetupPayload.Instance</a>
+ </li>
+
+
+
+
</ul>
</li>
@@ -11758,6 +11781,169 @@ unreadable and the revision carries no sheet name. </p></td>
+ <div class="file-heading">
+ <h2 id="store/sample_instance.proto">store/sample_instance.proto</h2><a href="#title">Top</a>
+ </div>
+ <p></p>
+
+
+ <h3 id="bytebase.store.SaaSSampleInstanceSetupPayload">SaaSSampleInstanceSetupPayload</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>project_id</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>instance_id</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>title</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>environment_id</td>
+ <td><a href="#string">string</a></td>
+ <td>optional</td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>database_name</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>role_name</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ </tbody>
+ </table>
+
+
+
+
+
+ <h3 id="bytebase.store.SelfHostSampleInstanceSetupPayload">SelfHostSampleInstanceSetupPayload</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>database_project_id</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>instances</td>
+ <td><a href="#bytebase.store.SelfHostSampleInstanceSetupPayload.Instance">SelfHostSampleInstanceSetupPayload.Instance</a></td>
+ <td>repeated</td>
+ <td><p> </p></td>
+ </tr>
+
+ </tbody>
+ </table>
+
+
+
+
+
+ <h3 id="bytebase.store.SelfHostSampleInstanceSetupPayload.Instance">SelfHostSampleInstanceSetupPayload.Instance</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>instance_id</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>title</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>environment_id</td>
+ <td><a href="#string">string</a></td>
+ <td>optional</td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>port_offset</td>
+ <td><a href="#int32">int32</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>database_name</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ <tr>
+ <td>role_name</td>
+ <td><a href="#string">string</a></td>
+ <td></td>
+ <td><p> </p></td>
+ </tr>
+
+ </tbody>
+ </table>
+
+
+
+
+
+
+
+
+
+
+
+
+
<div class="file-heading">
<h2 id="store/saved_query.proto">store/saved_query.proto</h2><a href="#title">Top</a>
</div>
diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.md
index a90508415e..9fe3c3b87e 100644
--- a/proto/gen/grpc-doc/v1/README.md
+++ b/proto/gen/grpc-doc/v1/README.md
@@ -36,6 +36,7 @@
- [ActuatorInfo](#bytebase-v1-ActuatorInfo)
- [GetActuatorInfoRequest](#bytebase-v1-GetActuatorInfoRequest)
- [SampleInfo](#bytebase-v1-SampleInfo)
+ - [SampleInfo.Instance](#bytebase-v1-SampleInfo-Instance)
- [SetupSampleRequest](#bytebase-v1-SetupSampleRequest)
- [ActuatorService](#bytebase-v1-ActuatorService)
@@ -1190,8 +1191,23 @@ SampleInfo describes sample setup availability and provisioned resources.
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| available | [bool](#bool) | | Whether sample setup is currently available. |
+| instances | [SampleInfo.Instance](#bytebase-v1-SampleInfo-Instance) | repeated | The provisioned sample instances. |
+
+
+
+
+
+
+<a name="bytebase-v1-SampleInfo-Instance"></a>
+
+### SampleInfo.Instance
+Instance describes one provisioned sample instance.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
| instance | [string](#string) | | The provisioned sample instance. Format: instances/{instance} |
-| expire_time | [google.protobuf.Timestamp](#google-protobuf-Timestamp) | | The time when the provisioned sample resources expire. |
+| expire_time | [google.protobuf.Timestamp](#google-protobuf-Timestamp) | | The time when the provisioned sample instance expires. |
diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.html
index ec0c545d05..147046fbd8 100644
--- a/proto/gen/grpc-doc/v1/index.html
+++ b/proto/gen/grpc-doc/v1/index.html
@@ -300,6 +300,10 @@
<a href="#bytebase.v1.SampleInfo"><span class="badge">M</span>SampleInfo</a>
</li>
+ <li>
+ <a href="#bytebase.v1.SampleInfo.Instance"><span class="badge">M</span>SampleInfo.Instance</a>
+ </li>
+
<li>
<a href="#bytebase.v1.SetupSampleRequest"><span class="badge">M</span>SetupSampleRequest</a>
</li>
@@ -4333,6 +4337,30 @@ Format: projects/{id} </p></td>
<td><p>Whether sample setup is currently available. </p></td>
</tr>
+ <tr>
+ <td>instances</td>
+ <td><a href="#bytebase.v1.SampleInfo.Instance">SampleInfo.Instance</a></td>
+ <td>repeated</td>
+ <td><p>The provisioned sample instances. </p></td>
+ </tr>
+
+ </tbody>
+ </table>
+
+
+
+
+
+ <h3 id="bytebase.v1.SampleInfo.Instance">SampleInfo.Instance</h3>
+ <p>Instance describes one provisioned sample instance.</p>
+
+
+ <table class="field-table">
+ <thead>
+ <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>
+ </thead>
+ <tbody>
+
<tr>
<td>instance</td>
<td><a href="#string">string</a></td>
@@ -4345,7 +4373,7 @@ Format: instances/{instance} </p></td>
<td>expire_time</td>
<td><a href="#google.protobuf.Timestamp">google.protobuf.Timestamp</a></td>
<td></td>
- <td><p>The time when the provisioned sample resources expire. </p></td>
+ <td><p>The time when the provisioned sample instance expires. </p></td>
</tr>
</tbody>
diff --git a/proto/store/store/sample_instance.proto b/proto/store/store/sample_instance.proto
new file mode 100644
index 0000000000..7ed6b3449a
--- /dev/null
+++ b/proto/store/store/sample_instance.proto
@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+package bytebase.store;
+
+option go_package = "generated-go/store";
+
+message SaaSSampleInstanceSetupPayload {
+ string project_id = 1;
+ string instance_id = 2;
+ string title = 3;
+ optional string environment_id = 4;
+ string database_name = 5;
+ string role_name = 6;
+}
+
+message SelfHostSampleInstanceSetupPayload {
+ message Instance {
+ string instance_id = 1;
+ string title = 2;
+ optional string environment_id = 3;
+ int32 port_offset = 4;
+ string database_name = 5;
+ string role_name = 6;
+ }
+
+ string database_project_id = 1;
+ repeated Instance instances = 2;
+}
diff --git a/proto/v1/v1/actuator_service.proto b/proto/v1/v1/actuator_service.proto
index a3a4c8dead..35d804b306 100644
--- a/proto/v1/v1/actuator_service.proto
+++ b/proto/v1/v1/actuator_service.proto
@@ -46,18 +46,24 @@ message GetActuatorInfoRequest {}
// SampleInfo describes sample setup availability and provisioned resources.
message SampleInfo {
+ // Instance describes one provisioned sample instance.
+ message Instance {
+ // The provisioned sample instance.
+ // Format: instances/{instance}
+ string instance = 1 [
+ (google.api.field_behavior) = OUTPUT_ONLY,
+ (google.api.resource_reference) = {type: "bytebase.com/Instance"}
+ ];
+
+ // The time when the provisioned sample instance expires.
+ google.protobuf.Timestamp expire_time = 2 [(google.api.field_behavior) = OUTPUT_ONLY];
+ }
+
// Whether sample setup is currently available.
bool available = 1 [(google.api.field_behavior) = OUTPUT_ONLY];
- // The provisioned sample instance.
- // Format: instances/{instance}
- string instance = 2 [
- (google.api.field_behavior) = OUTPUT_ONLY,
- (google.api.resource_reference) = {type: "bytebase.com/Instance"}
- ];
-
- // The time when the provisioned sample resources expire.
- google.protobuf.Timestamp expire_time = 3 [(google.api.field_behavior) = OUTPUT_ONLY];
+ // The provisioned sample instances.
+ repeated Instance instances = 2 [(google.api.field_behavior) = OUTPUT_ONLY];
}
// System information and configuration for the Bytebase instance.