direct: Engine dedup+logging; dashboard saves draft state as Published=false

Engine.SaveState:
- Accepts resourceKey for logging: "SaveState: resources.X id=Y N bytes: {...}"
- Skips WAL write if state is unchanged (structdiff.IsEqual), logging a skip message.
- Records the last saved value in e.lastSaved for subsequent comparisons.

Dashboard DoCreate:
- Saves intermediate state with Published=false (the actual draft state) instead of
  the user's Published=true. This ensures the planner sees a real diff (false→true)
  on the next deploy if publish is interrupted, rather than treating the resource as
  up-to-date and silently skipping the publish.

publish-failure-retry acceptance test:
- Adds `bundle plan -o json` and extracts the published change to verify
  old=false, new=true in the plan after a failed publish.

README.md: update stale SetID+SaveState reference to current SaveState(ctx, id, state) API.

Co-authored-by: Denis Bilenko

Author: denik

acceptance/bundle/resources/dashboards/publish-failure-retry/out.plan_published_change.json

@@ -0,0 +1,6 @@
+{
+  "action": "update",
+  "old": false,
+  "new": true,
+  "remote": false
+}

acceptance/bundle/resources/dashboards/publish-failure-retry/output.txt

@@ -25,10 +25,15 @@ Resources:
       Name: my dashboard
       URL:  [DATABRICKS_URL]/dashboardsv3/[DASHBOARD_ID]/published?[WSPARAM]=[NUMID]
 
->>> [CLI] bundle plan
-update dashboards.dashboard1
+>>> [CLI] bundle plan -o json
 
-Plan: 0 to add, 1 to change, 0 to delete, 0 unchanged
+>>> cat out.plan_published_change.json
+{
+  "action": "update",
+  "old": false,
+  "new": true,
+  "remote": false
+}
 
 >>> [CLI] bundle deploy
 Uploading bundle files to /Workspace/Users/[USERNAME]/.bundle/publish-failure-retry/default/files...

acceptance/bundle/resources/dashboards/publish-failure-retry/script

@@ -20,8 +20,10 @@ errcode trace $CLI bundle deploy
 # Dashboard should be in state (tracked) despite the publish failure.
 trace $CLI bundle summary
 
-# Plan should show that publishing is still needed.
-trace $CLI bundle plan
+# Plan should show published: false (saved state) -> true (desired).
+# Capture the Changes entry for 'published' to verify the diff direction.
+trace $CLI bundle plan -o json | jq '.plan["resources.dashboards.dashboard1"].changes.published' > out.plan_published_change.json
+trace cat out.plan_published_change.json
 
 # Discard first-deploy requests so the output only contains second-deploy
 # calls, making it easy to confirm no CREATE was issued.

bundle/direct/apply.go

@@ -51,7 +51,7 @@ func (d *DeploymentUnit) Deploy(ctx context.Context, db *dstate.DeploymentState,
 }
 
 func (d *DeploymentUnit) Create(ctx context.Context, db *dstate.DeploymentState, newState any) error {
-	engine := dresources.NewEngine(d.Adapter.StateType(), func(id string, x any) error {
+	engine := dresources.NewEngine(d.ResourceKey, d.Adapter.StateType(), func(id string, x any) error {
 		return db.SaveState(d.ResourceKey, id, x, d.DependsOn)
 	})
 
@@ -126,7 +126,7 @@ func (d *DeploymentUnit) Update(ctx context.Context, db *dstate.DeploymentState,
 		return fmt.Errorf("internal error: DoUpdate not implemented for resource %s", d.ResourceKey)
 	}
 
-	engine := dresources.NewEngine(d.Adapter.StateType(), func(_ string, x any) error {
+	engine := dresources.NewEngine(d.ResourceKey, d.Adapter.StateType(), func(_ string, x any) error {
 		return db.SaveState(d.ResourceKey, id, x, d.DependsOn)
 	})
 	remoteState, err := retryOnTransient(ctx, func() (any, error) {

bundle/direct/dresources/README.md

@@ -36,7 +36,7 @@ If a resource has fields that must not be sent in updates (deploy-only, lifecycl
 
 ## Async APIs
 
-For resources whose create or update is asynchronous, poll inline inside `DoCreate`/`DoUpdate` after the initial API call. To prevent orphaning if deployment is interrupted during a long wait, call `engine.SetID(id)` then `engine.SaveState(config)` immediately after the resource is created and before any waiting. The framework provides a `*Engine` as the second argument to both methods.
+For resources whose create or update is asynchronous, poll inline inside `DoCreate`/`DoUpdate` after the initial API call. To prevent orphaning if deployment is interrupted during a long wait, call `engine.SaveState(ctx, id, config)` immediately after the resource is created and before any waiting. The framework provides a `*Engine` as the second argument to both methods.
 
 ## Slice ordering: KeyedSlices
 

bundle/direct/dresources/dashboard.go

@@ -298,10 +298,14 @@ func (r *ResourceDashboard) DoCreate(ctx context.Context, engine *Engine, config
 
 	// Persist the etag in state.
 	config.Etag = createResp.Etag
-	// Save state before publishing so an interrupted publish leaves a tracked
-	// draft rather than an orphan. The next deploy finds the draft in state and
-	// re-publishes via DoUpdate without recreating the dashboard.
+	// Save state with Published=false: the dashboard exists as a draft; publish
+	// has not succeeded yet. Using Published=false ensures the planner sees a
+	// real diff (false→true) if publish is interrupted, triggering a DoUpdate
+	// on the next deploy instead of silently treating the resource as up-to-date.
+	savedPublished := config.Published
+	config.Published = false
 	engine.SaveState(ctx, createResp.DashboardId, config)
+	config.Published = savedPublished
 
 	var publishResp *dashboards.PublishedDashboard
 	// Note, today config.Published is always true (we do not have this field in input config).

bundle/direct/dresources/engine.go

@@ -2,35 +2,41 @@ package dresources
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"reflect"
 
+	"github.com/databricks/cli/libs/log"
 	"github.com/databricks/cli/libs/logdiag"
+	"github.com/databricks/cli/libs/structs/structdiff"
 )
 
 // Engine provides state persistence to resource implementations.
 // Pass it to DoCreate or DoUpdate to save intermediate state before long-running
 // wait operations, so the resource is not orphaned if deployment is interrupted.
 type Engine struct {
-	id        string
-	stateType reflect.Type
-	saveFunc  func(id string, x any) error
+	resourceKey string
+	id          string
+	stateType   reflect.Type
+	saveFunc    func(id string, x any) error
+	lastSaved   any
 }
 
 // NewEngine creates an Engine with the given state type and save function.
 // The framework calls this before invoking DoCreate or DoUpdate.
-func NewEngine(stateType reflect.Type, saveFunc func(id string, x any) error) *Engine {
-	return &Engine{id: "", stateType: stateType, saveFunc: saveFunc}
+func NewEngine(resourceKey string, stateType reflect.Type, saveFunc func(id string, x any) error) *Engine {
+	return &Engine{resourceKey: resourceKey, id: "", stateType: stateType, saveFunc: saveFunc, lastSaved: nil}
 }
 
 // NewNopEngine creates an Engine that discards all saves. Use in tests.
 func NewNopEngine(stateType reflect.Type) *Engine {
-	return NewEngine(stateType, func(_ string, _ any) error { return nil })
+	return NewEngine("", stateType, func(_ string, _ any) error { return nil })
 }
 
 // SaveState saves the resource state. id must be the resource's identifier; on
 // the first call it is recorded, and subsequent calls panic if a different id is
 // passed. x must be a pointer to the same struct type as the resource's state.
+// If the state is identical to what was last saved, the write is skipped.
 // Failures to persist state are logged but do not abort the deployment — the
 // resource already exists and aborting would not undo its creation.
 func (e *Engine) SaveState(ctx context.Context, id string, x any) {
@@ -43,7 +49,19 @@ func (e *Engine) SaveState(ctx context.Context, id string, x any) {
 	if xt != e.stateType {
 		panic(fmt.Sprintf("SaveState: type mismatch: expected %v, got %v", e.stateType, xt))
 	}
+	if e.lastSaved != nil && structdiff.IsEqual(e.lastSaved, x) {
+		log.Debugf(ctx, "SaveState: %s id=%s: skipping, state unchanged", e.resourceKey, id)
+		return
+	}
+	b, _ := json.Marshal(x)
+	preview := string(b)
+	if len(preview) > 100 {
+		preview = preview[:100]
+	}
+	log.Debugf(ctx, "SaveState: %s id=%s %d bytes: %s", e.resourceKey, id, len(b), preview)
 	if err := e.saveFunc(e.id, x); err != nil {
 		logdiag.LogError(ctx, err)
+		return
 	}
+	e.lastSaved = x
 }