[Feature] Add TF support for setting DisableLegacyFeatures (#4676)

## Changes
<!-- Summary of your changes that are easy to understand -->
This PR adds TF support for the DisableLegacyFeatures account level
setting.

## Tests
<!-- 
How is this tested? Please see the checklist below and also describe any
other relevant tests
-->

- [x] `make test` run locally
- [x] relevant change in `docs/` folder
- [x] covered with integration tests in `internal/acceptance`
- [ ] using Go SDK
- [x] using TF Plugin Framework

---------

Co-authored-by: Alex Ott <[email protected]>
Co-authored-by: Alex Ott <[email protected]>

Author: EmanueleFWM

NEXT_CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### New Features and Improvements
 
+ * Add `databricks_disable_legacy_features_setting` account-level resource ([#4676](https://github.com/databricks/terraform-provider-databricks/pull/4676))
+
 ### Bug Fixes
 
 ### Documentation

docs/resources/disable_legacy_features_setting.md

@@ -0,0 +1,42 @@
+---
+subcategory: "Settings"
+---
+
+# databricks_disable_legacy_features_setting Resource
+
+-> This resource can only be used with an account-level provider!
+
+-> This setting is currently in private preview, and only available for enrolled customers.
+
+The `databricks_disable_legacy_features_setting` resource allows you to disable legacy features on newly created workspaces.
+
+When this setting is on, the following applies to new workspaces:
+- Disables the use of DBFS root and mounts.
+- Hive Metastore will not be provisioned.
+- Disables the use of ‘No-isolation clusters’.
+- Disables Databricks Runtime versions prior to 13.3LTS
+
+## Example Usage
+
+```hcl
+resource "databricks_disable_legacy_features_setting" "this" {
+  disable_legacy_features {
+    value = true
+  }
+}
+```
+
+## Argument Reference
+
+The resource supports the following arguments:
+
+- `disable_legacy_features` block with following attributes:
+  - `value` - (Required) The boolean value for the setting.
+
+## Import
+
+This resource can be imported by predefined name `global`:
+
+```bash
+terraform import databricks_disable_legacy_features_setting.this global
+```

settings/all_settings.go

@@ -24,5 +24,6 @@ func AllSettingsResources() map[string]common.Resource {
 		"aibi_dashboard_embedding_approved_domains": makeSettingResource[settings.AibiDashboardEmbeddingApprovedDomainsSetting, *databricks.WorkspaceClient](aibiDashboardEmbeddingApprovedDomainsSetting),
 		"disable_legacy_access":                     makeSettingResource[settings.DisableLegacyAccess, *databricks.WorkspaceClient](disableLegacyAccess),
 		"disable_legacy_dbfs":                       makeSettingResource[settings.DisableLegacyDbfs, *databricks.WorkspaceClient](disableLegacyDbfs),
+		"disable_legacy_features":                   makeSettingResource[settings.DisableLegacyFeatures, *databricks.AccountClient](disableLegacyFeatures),
 	}
 }

settings/disable_legacy_features_test.go

@@ -0,0 +1,78 @@
+package settings_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/databricks/databricks-sdk-go/apierr"
+	"github.com/databricks/databricks-sdk-go/service/settings"
+	"github.com/databricks/terraform-provider-databricks/common"
+	"github.com/databricks/terraform-provider-databricks/internal/acceptance"
+	"github.com/hashicorp/terraform-plugin-testing/terraform"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMwsAccDisableLegacyFeaturesSetting(t *testing.T) {
+	template := `
+ 	resource "databricks_disable_legacy_features_setting" "this" {
+ 		disable_legacy_features {
+ 			value = "true"
+ 		}
+ 	}
+ 	`
+	acceptance.AccountLevel(t, acceptance.Step{
+		Template: template,
+		Check: acceptance.ResourceCheckWithState("databricks_disable_legacy_features_setting.this",
+			func(ctx context.Context, client *common.DatabricksClient, state *terraform.InstanceState) error {
+				ctx = context.WithValue(ctx, common.Api, common.API_2_1)
+				w, err := client.AccountClient()
+				require.NoError(t, err)
+				etag := state.Attributes["etag"]
+				require.NotEmpty(t, etag)
+				res, err := w.Settings.DisableLegacyFeatures().Get(ctx, settings.GetDisableLegacyFeaturesRequest{
+					Etag: etag,
+				})
+				require.NoError(t, err)
+				// Check that the resource has been created and that it has the correct value.
+				assert.Equal(t, res.DisableLegacyFeatures.Value, true)
+				return nil
+			}),
+	},
+		acceptance.Step{
+			Template: template,
+			Destroy:  true,
+			Check: acceptance.ResourceCheck("databricks_disable_legacy_features_setting.this", func(ctx context.Context, client *common.DatabricksClient, id string) error {
+				ctx = context.WithValue(ctx, common.Api, common.API_2_1)
+				w, err := client.AccountClient()
+				require.NoError(t, err)
+				// Terraform Check returns the latest resource status before it is destroyed, which has an outdated eTag.
+				// We are making an update call to get the correct eTag in the response error.
+				_, err = w.Settings.DisableLegacyFeatures().Update(ctx, settings.UpdateDisableLegacyFeaturesRequest{
+					AllowMissing: true,
+					Setting: settings.DisableLegacyFeatures{
+						DisableLegacyFeatures: settings.BooleanMessage{
+							Value: false,
+						},
+					},
+					FieldMask: "disable_legacy_features.value",
+				})
+				assert.Error(t, err)
+				var aerr *apierr.APIError
+				if !errors.As(err, &aerr) {
+					assert.FailNow(t, "cannot parse error message %v", err)
+				}
+				etag := aerr.Details[0].Metadata["etag"]
+				res, err := w.Settings.DisableLegacyFeatures().Get(ctx, settings.GetDisableLegacyFeaturesRequest{
+					Etag: etag,
+				})
+				// we should not be getting any error
+				assert.NoError(t, err)
+				// setting should go back to default
+				assert.Equal(t, res.DisableLegacyFeatures.Value, false)
+				return nil
+			}),
+		},
+	)
+}

settings/generic_setting.go

@@ -230,15 +230,15 @@ func (w accountSetting[T]) GetId(t *T) string {
 }
 
 func (w accountSetting[T]) GetCustomizeSchemaFunc() func(map[string]*schema.Schema) map[string]*schema.Schema {
-	if w.customizeSchemaFunc != nil {
-		return w.customizeSchemaFunc
-	}
 	return func(s map[string]*schema.Schema) map[string]*schema.Schema {
 		s[etagAttrName].Computed = true
 		// Note: this may not always be computed, but it is for the default namespace setting. If other settings
 		// are added for which setting_name is not computed, we'll need to expose this somehow as part of the setting
 		// definition.
 		s["setting_name"].Computed = true
+		if w.customizeSchemaFunc != nil {
+			return w.customizeSchemaFunc(s)
+		}
 		return s
 	}
 }

settings/resource_disable_legacy_features_setting.go

@@ -0,0 +1,45 @@
+package settings
+
+import (
+	"context"
+
+	"github.com/databricks/databricks-sdk-go"
+	"github.com/databricks/databricks-sdk-go/service/settings"
+	"github.com/databricks/terraform-provider-databricks/common"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+// Disable Legacy Features setting
+var disableLegacyFeatures = accountSetting[settings.DisableLegacyFeatures]{
+	settingStruct: settings.DisableLegacyFeatures{},
+	customizeSchemaFunc: func(s map[string]*schema.Schema) map[string]*schema.Schema {
+		common.CustomizeSchemaPath(s, "disable_legacy_features", "value").SetRequired()
+		return s
+	},
+	readFunc: func(ctx context.Context, w *databricks.AccountClient, etag string) (*settings.DisableLegacyFeatures, error) {
+		return w.Settings.DisableLegacyFeatures().Get(ctx, settings.GetDisableLegacyFeaturesRequest{
+			Etag: etag,
+		})
+	},
+	updateFunc: func(ctx context.Context, w *databricks.AccountClient, t settings.DisableLegacyFeatures) (string, error) {
+		t.SettingName = "disable_legacy_features"
+		res, err := w.Settings.DisableLegacyFeatures().Update(ctx, settings.UpdateDisableLegacyFeaturesRequest{
+			AllowMissing: true,
+			Setting:      t,
+			FieldMask:    "disable_legacy_features.value",
+		})
+		if err != nil {
+			return "", err
+		}
+		return res.Etag, nil
+	},
+	deleteFunc: func(ctx context.Context, w *databricks.AccountClient, etag string) (string, error) {
+		res, err := w.Settings.DisableLegacyFeatures().Delete(ctx, settings.DeleteDisableLegacyFeaturesRequest{
+			Etag: etag,
+		})
+		if err != nil {
+			return "", err
+		}
+		return res.Etag, err
+	},
+}