Unlocked edit mode for workspace deployed job (#4193)

## Changes
1. Add a new env flag that controls the behavior of deployments from the
Workspace. Currently, this flag controls only the edit mode of the job.
In the next PRs, it will also enable saving the resource snapshots that
are required for the UI->YAML sync
2. Add logic that sets job edit mode to Editable when the flag is
enabled and deploy is running from the Workspace

## Why
We need to unlock jobs to allow users to manually edit
Workspace-deployed jobs and run the UI->YAML sync. This feature is not
yet released; therefore, we need to use a flag to maintain both old and
new behaviors.

## Tests
Currently, only unit tests. It seems that running acceptance tests is
not yet possible for DBR-specific functionality. One potential option is
to skip the DBR check for the sake of testability, but the flag is more
likely to be removed at some point and we will need to introduce DBR
check again.

Also I will manually check that the Workspace integration works as
expected

Author: ilyakuz-db

bundle/deploy/metadata/annotate_jobs.go

@@ -2,8 +2,11 @@ package metadata
 
 import (
 	"context"
+	"strings"
 
 	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/env"
+	"github.com/databricks/cli/libs/dbr"
 	"github.com/databricks/cli/libs/diag"
 	"github.com/databricks/databricks-sdk-go/service/jobs"
 )
@@ -18,13 +21,21 @@ func (m *annotateJobs) Name() string {
 	return "metadata.AnnotateJobs"
 }
 
-func (m *annotateJobs) Apply(_ context.Context, b *bundle.Bundle) diag.Diagnostics {
+func (m *annotateJobs) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
 	for _, job := range b.Config.Resources.Jobs {
 		job.Deployment = &jobs.JobDeployment{
 			Kind:             jobs.JobDeploymentKindBundle,
 			MetadataFilePath: metadataFilePath(b),
 		}
-		job.EditMode = jobs.JobEditModeUiLocked
+
+		isDatabricksWorkspace := dbr.RunsOnRuntime(ctx) && strings.HasPrefix(b.SyncRootPath, "/Workspace/")
+		_, experimentalYamlSyncEnabled := env.ExperimentalYamlSync(ctx)
+		if isDatabricksWorkspace && experimentalYamlSyncEnabled {
+			job.EditMode = jobs.JobEditModeEditable
+		} else {
+			job.EditMode = jobs.JobEditModeUiLocked
+		}
+
 		job.Format = jobs.FormatMultiTask
 	}
 

bundle/deploy/metadata/annotate_jobs_test.go

@@ -7,6 +7,8 @@ import (
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/bundle/config"
 	"github.com/databricks/cli/bundle/config/resources"
+	"github.com/databricks/cli/libs/dbr"
+	"github.com/databricks/cli/libs/env"
 	"github.com/databricks/databricks-sdk-go/service/jobs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -35,7 +37,10 @@ func TestAnnotateJobsMutator(t *testing.T) {
 		},
 	}
 
-	diags := AnnotateJobs().Apply(context.Background(), b)
+	ctx := context.Background()
+	ctx = dbr.MockRuntime(ctx, dbr.Environment{IsDbr: false, Version: ""})
+
+	diags := AnnotateJobs().Apply(ctx, b)
 	require.NoError(t, diags.Error())
 
 	assert.Equal(t,
@@ -68,6 +73,98 @@ func TestAnnotateJobsMutatorJobWithoutSettings(t *testing.T) {
 		},
 	}
 
-	diags := AnnotateJobs().Apply(context.Background(), b)
+	ctx := context.Background()
+	ctx = dbr.MockRuntime(ctx, dbr.Environment{IsDbr: false, Version: ""})
+
+	diags := AnnotateJobs().Apply(ctx, b)
+	require.NoError(t, diags.Error())
+}
+
+func TestAnnotateJobsWorkspaceWithFlag(t *testing.T) {
+	b := &bundle.Bundle{
+		SyncRootPath: "/Workspace/Users/user@example.com/project",
+		Config: config.Root{
+			Workspace: config.Workspace{
+				StatePath: "/a/b/c",
+			},
+			Resources: config.Resources{
+				Jobs: map[string]*resources.Job{
+					"my-job": {
+						JobSettings: jobs.JobSettings{
+							Name: "My Job",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctx := context.Background()
+	ctx = dbr.MockRuntime(ctx, dbr.Environment{IsDbr: true, Version: "14.0"})
+	ctx = env.Set(ctx, "DATABRICKS_BUNDLE_ENABLE_EXPERIMENTAL_YAML_SYNC", "1")
+
+	diags := AnnotateJobs().Apply(ctx, b)
+	require.NoError(t, diags.Error())
+
+	assert.Equal(t, jobs.JobEditModeEditable, b.Config.Resources.Jobs["my-job"].EditMode)
+	assert.Equal(t, jobs.FormatMultiTask, b.Config.Resources.Jobs["my-job"].Format)
+}
+
+func TestAnnotateJobsWorkspaceWithoutFlag(t *testing.T) {
+	b := &bundle.Bundle{
+		SyncRootPath: "/Workspace/Users/user@example.com/project",
+		Config: config.Root{
+			Workspace: config.Workspace{
+				StatePath: "/a/b/c",
+			},
+			Resources: config.Resources{
+				Jobs: map[string]*resources.Job{
+					"my-job": {
+						JobSettings: jobs.JobSettings{
+							Name: "My Job",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctx := context.Background()
+	ctx = dbr.MockRuntime(ctx, dbr.Environment{IsDbr: true, Version: "14.0"})
+
+	diags := AnnotateJobs().Apply(ctx, b)
 	require.NoError(t, diags.Error())
+
+	assert.Equal(t, jobs.JobEditModeUiLocked, b.Config.Resources.Jobs["my-job"].EditMode)
+	assert.Equal(t, jobs.FormatMultiTask, b.Config.Resources.Jobs["my-job"].Format)
+}
+
+func TestAnnotateJobsNonWorkspaceWithFlag(t *testing.T) {
+	b := &bundle.Bundle{
+		SyncRootPath: "/some/local/path",
+		Config: config.Root{
+			Workspace: config.Workspace{
+				StatePath: "/a/b/c",
+			},
+			Resources: config.Resources{
+				Jobs: map[string]*resources.Job{
+					"my-job": {
+						JobSettings: jobs.JobSettings{
+							Name: "My Job",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctx := context.Background()
+	ctx = dbr.MockRuntime(ctx, dbr.Environment{IsDbr: false, Version: ""})
+	ctx = env.Set(ctx, "DATABRICKS_BUNDLE_ENABLE_EXPERIMENTAL_YAML_SYNC", "1")
+
+	diags := AnnotateJobs().Apply(ctx, b)
+	require.NoError(t, diags.Error())
+
+	assert.Equal(t, jobs.JobEditModeUiLocked, b.Config.Resources.Jobs["my-job"].EditMode)
+	assert.Equal(t, jobs.FormatMultiTask, b.Config.Resources.Jobs["my-job"].Format)
 }

bundle/env/experimental_yaml_sync.go

@@ -0,0 +1,15 @@
+package env
+
+import "context"
+
+// experimentalYamlSyncVariable names the environment variable that holds the flag whether
+// experimental YAML sync is enabled.
+const experimentalYamlSyncVariable = "DATABRICKS_BUNDLE_ENABLE_EXPERIMENTAL_YAML_SYNC"
+
+// ExperimentalYamlSync returns the environment variable that holds the flag whether
+// experimental YAML sync is enabled.
+func ExperimentalYamlSync(ctx context.Context) (string, bool) {
+	return get(ctx, []string{
+		experimentalYamlSyncVariable,
+	})
+}