bundle/deploy/lock: replace DeploymentManager interface with concrete DeploymentLock

Remove the DeploymentManager interface and CreateVersion/CompleteVersion methods.
Replace with a concrete DeploymentLock type backed by the workspace-filesystem
lock, with Acquire/Release methods. DMS version tracking will be added
additively alongside the file lock in a follow-up — no interface needed since
both operations happen inside Acquire/Release on the same type.

Co-authored-by: Shreyas Goenka <shreyas.goenka@databricks.com>

Author: shreyas-goenka

bundle/deploy/lock/lock.go

@@ -26,43 +26,43 @@ const (
 	DeploymentFailure
 )
 
-// DeploymentManager controls the versioned lifecycle of deployment operations.
-//
-// DMS semantics: CreateVersion atomically succeeds only if no other deployment
-// is in progress and the returned version is exactly +1 to the latest closed
-// version, providing serialized optimistic concurrency control. CompleteVersion
-// records the outcome.
-//
-// Workspace-filesystem semantics: CreateVersion acquires the workspace lock
-// file; CompleteVersion releases it. The returned version number is a placeholder
-// (the lock file does not track a monotonic counter today).
-type DeploymentManager interface {
-	// CreateVersion begins a new deployment for the given goal.
-	// Returns the version number assigned by the backend.
-	CreateVersion(ctx context.Context, goal Goal) (int64, error)
-
-	// CompleteVersion finalizes the deployment version created by CreateVersion.
-	CompleteVersion(ctx context.Context, version int64, status DeploymentStatus) error
+// DeploymentLock manages the lifecycle of a bundle deployment.
+// The workspace-filesystem lock serializes concurrent deployments.
+// DMS version tracking will be added additively — see deployment_metadata_service.go.
+type DeploymentLock struct {
+	wfs workspaceFilesystemLock
 }
 
-// NewDeploymentManager returns a DeploymentManager backed by the workspace
-// filesystem. Captures everything it needs from the bundle at construction time
-// so the implementation does not retain a *bundle.Bundle reference. The
-// workspace client is only initialized when locking is enabled to match the
-// original lazy-init behavior.
-func NewDeploymentManager(ctx context.Context, b *bundle.Bundle) DeploymentManager {
+// NewDeploymentLock returns a DeploymentLock for the bundle.
+// Captures everything it needs from the bundle at construction time
+// so the lock does not retain a *bundle.Bundle reference. The
+// workspace client is only initialized when locking is enabled.
+func NewDeploymentLock(ctx context.Context, b *bundle.Bundle, goal Goal) *DeploymentLock {
 	enabled := b.Config.Bundle.Deployment.Lock.IsEnabled()
-	l := &workspaceFilesystemLock{
-		user:      b.Config.Workspace.CurrentUser.UserName,
-		statePath: b.Config.Workspace.StatePath,
-		enabled:   enabled,
-		force:     b.Config.Bundle.Deployment.Lock.Force,
-		reportPermissionError: func(ctx context.Context, path string) diag.Diagnostics {
-			return permissions.ReportPossiblePermissionDenied(ctx, b, path)
+	l := &DeploymentLock{
+		wfs: workspaceFilesystemLock{
+			user:      b.Config.Workspace.CurrentUser.UserName,
+			statePath: b.Config.Workspace.StatePath,
+			enabled:   enabled,
+			force:     b.Config.Bundle.Deployment.Lock.Force,
+			goal:      goal,
+			reportPermissionError: func(ctx context.Context, path string) diag.Diagnostics {
+				return permissions.ReportPossiblePermissionDenied(ctx, b, path)
+			},
 		},
 	}
 	if enabled {
-		l.client = b.WorkspaceClient(ctx)
+		l.wfs.client = b.WorkspaceClient(ctx)
 	}
 	return l
 }
+
+// Acquire acquires the deployment lock.
+func (l *DeploymentLock) Acquire(ctx context.Context) error {
+	return l.wfs.acquire(ctx)
+}
+
+// Release releases the deployment lock.
+func (l *DeploymentLock) Release(ctx context.Context, status DeploymentStatus) error {
+	return l.wfs.release(ctx, status)
+}

bundle/deploy/lock/workspace_filesystem.go

@@ -11,9 +11,8 @@ import (
 	"github.com/databricks/databricks-sdk-go"
 )
 
-// workspaceFilesystemLock implements DeploymentManager using a lock file in the
-// bundle's workspace state path. Holds only the primitives it needs from the
-// bundle.
+// workspaceFilesystemLock holds the state for the workspace-filesystem lock.
+// Methods are unexported; callers use DeploymentLock.Acquire / DeploymentLock.Release.
 type workspaceFilesystemLock struct {
 	client    *databricks.WorkspaceClient
 	user      string
@@ -30,18 +29,16 @@ type workspaceFilesystemLock struct {
 	goal   Goal
 }
 
-func (l *workspaceFilesystemLock) CreateVersion(ctx context.Context, goal Goal) (int64, error) {
-	l.goal = goal
-
+func (l *workspaceFilesystemLock) acquire(ctx context.Context) error {
 	// Return early if locking is disabled.
 	if !l.enabled {
 		log.Infof(ctx, "Skipping; locking is disabled")
-		return 0, nil
+		return nil
 	}
 
 	lk, err := locker.CreateLocker(l.user, l.statePath, l.client)
 	if err != nil {
-		return 0, err
+		return err
 	}
 
 	l.locker = lk
@@ -54,16 +51,16 @@ func (l *workspaceFilesystemLock) CreateVersion(ctx context.Context, goal Goal)
 		// If we get a permission or "doesn't exist" error from the API this
 		// indicates we either don't have permissions or the path is invalid.
 		if errors.Is(err, fs.ErrPermission) || errors.Is(err, fs.ErrNotExist) {
-			return 0, l.reportPermissionError(ctx, l.statePath).Error()
+			return l.reportPermissionError(ctx, l.statePath).Error()
 		}
 
-		return 0, err
+		return err
 	}
 
-	return 0, nil
+	return nil
 }
 
-func (l *workspaceFilesystemLock) CompleteVersion(ctx context.Context, _ int64, _ DeploymentStatus) error {
+func (l *workspaceFilesystemLock) release(ctx context.Context, _ DeploymentStatus) error {
 	// Return early if locking is disabled.
 	if !l.enabled {
 		log.Infof(ctx, "Skipping; locking is disabled")

bundle/phases/bind.go

@@ -23,9 +23,8 @@ import (
 func Bind(ctx context.Context, b *bundle.Bundle, opts *terraform.BindOptions, engine engine.EngineType) {
 	log.Info(ctx, "Phase: bind")
 
-	dm := lock.NewDeploymentManager(ctx, b)
-	version, err := dm.CreateVersion(ctx, lock.GoalBind)
-	if err != nil {
+	dl := lock.NewDeploymentLock(ctx, b, lock.GoalBind)
+	if err := dl.Acquire(ctx); err != nil {
 		logdiag.LogError(ctx, err)
 		return
 	}
@@ -35,7 +34,7 @@ func Bind(ctx context.Context, b *bundle.Bundle, opts *terraform.BindOptions, en
 		if logdiag.HasError(ctx) {
 			status = lock.DeploymentFailure
 		}
-		if err := dm.CompleteVersion(ctx, version, status); err != nil {
+		if err := dl.Release(ctx, status); err != nil {
 			logdiag.LogError(ctx, err)
 		}
 	}()
@@ -127,9 +126,8 @@ func jsonDump(ctx context.Context, v any, field string) string {
 func Unbind(ctx context.Context, b *bundle.Bundle, bundleType, tfResourceType, resourceKey string, engine engine.EngineType) {
 	log.Info(ctx, "Phase: unbind")
 
-	dm := lock.NewDeploymentManager(ctx, b)
-	version, err := dm.CreateVersion(ctx, lock.GoalUnbind)
-	if err != nil {
+	dl := lock.NewDeploymentLock(ctx, b, lock.GoalUnbind)
+	if err := dl.Acquire(ctx); err != nil {
 		logdiag.LogError(ctx, err)
 		return
 	}
@@ -139,7 +137,7 @@ func Unbind(ctx context.Context, b *bundle.Bundle, bundleType, tfResourceType, r
 		if logdiag.HasError(ctx) {
 			status = lock.DeploymentFailure
 		}
-		if err := dm.CompleteVersion(ctx, version, status); err != nil {
+		if err := dl.Release(ctx, status); err != nil {
 			logdiag.LogError(ctx, err)
 		}
 	}()

bundle/phases/deploy.go

@@ -128,13 +128,12 @@ func Deploy(ctx context.Context, b *bundle.Bundle, outputHandler sync.OutputHand
 	// mutators need informed consent if they are potentially destructive.
 	bundle.ApplyContext(ctx, b, scripts.Execute(config.ScriptPreDeploy))
 	if logdiag.HasError(ctx) {
-		// deployment version not yet created
+		// lock not yet acquired
 		return
 	}
 
-	dm := lock.NewDeploymentManager(ctx, b)
-	version, err := dm.CreateVersion(ctx, lock.GoalDeploy)
-	if err != nil {
+	dl := lock.NewDeploymentLock(ctx, b, lock.GoalDeploy)
+	if err := dl.Acquire(ctx); err != nil {
 		logdiag.LogError(ctx, err)
 		return
 	}
@@ -144,7 +143,7 @@ func Deploy(ctx context.Context, b *bundle.Bundle, outputHandler sync.OutputHand
 		if logdiag.HasError(ctx) {
 			status = lock.DeploymentFailure
 		}
-		if err := dm.CompleteVersion(ctx, version, status); err != nil {
+		if err := dl.Release(ctx, status); err != nil {
 			logdiag.LogError(ctx, err)
 		}
 	}()

bundle/phases/destroy.go

@@ -120,9 +120,8 @@ func Destroy(ctx context.Context, b *bundle.Bundle, engine engine.EngineType) {
 		return
 	}
 
-	dm := lock.NewDeploymentManager(ctx, b)
-	version, err := dm.CreateVersion(ctx, lock.GoalDestroy)
-	if err != nil {
+	dl := lock.NewDeploymentLock(ctx, b, lock.GoalDestroy)
+	if err := dl.Acquire(ctx); err != nil {
 		logdiag.LogError(ctx, err)
 		return
 	}
@@ -132,7 +131,7 @@ func Destroy(ctx context.Context, b *bundle.Bundle, engine engine.EngineType) {
 		if logdiag.HasError(ctx) {
 			status = lock.DeploymentFailure
 		}
-		if err := dm.CompleteVersion(ctx, version, status); err != nil {
+		if err := dl.Release(ctx, status); err != nil {
 			logdiag.LogError(ctx, err)
 		}
 	}()