Fork Sync: Update from parent repository

.github/labeler-issue-triage.yml

@@ -30,6 +30,9 @@ service/app-service:
 service/application-insights:
   - '### (|New or )Affected Resource\(s\)\/Data Source\(s\)((.|\n)*)azurerm_application_insights((.|\n)*)###'
 
+service/arc-resource-bridge:
+  - '### (|New or )Affected Resource\(s\)\/Data Source\(s\)((.|\n)*)azurerm_arc_resource_bridge_appliance((.|\n)*)###'
+
 service/attestation:
   - '### (|New or )Affected Resource\(s\)\/Data Source\(s\)((.|\n)*)azurerm_attestation_provider((.|\n)*)###'
 

.github/labeler-pull-request-triage.yml

@@ -30,6 +30,9 @@ service/app-service:
 service/application-insights:
   - internal/services/applicationinsights/**/*
 
+service/arc-resource-bridge:
+  - internal/services/arcresourcebridge/**/*
+
 service/attestation:
   - internal/services/attestation/**/*
 

.teamcity/components/generated/services.kt

@@ -10,6 +10,7 @@ var services = mapOf(
         "appconfiguration" to "App Configuration",
         "appservice" to "AppService",
         "applicationinsights" to "Application Insights",
+        "arcresourcebridge" to "Arc Resource Bridge",
         "arckubernetes" to "ArcKubernetes",
         "attestation" to "Attestation",
         "authorization" to "Authorization",

CHANGELOG.md

@@ -4,6 +4,7 @@ ENHANCEMENTS:
 
 * dependencies: downgrading to `v1.12.5` of `github.com/rickb777/date` [GH-23296]
 * `azurerm_container_app` - add support for scale rules [GH-23294]
+* `azurerm_bot_channel_directline` - add support for `user_upload_enabled`, `endpoint_parameters_enabled` and `storage_enabled` [GH-23149]
 
 BUG FIXES:
 

internal/clients/client.go

@@ -30,6 +30,7 @@ import (
 	applicationInsights "github.com/hashicorp/terraform-provider-azurerm/internal/services/applicationinsights/client"
 	appService "github.com/hashicorp/terraform-provider-azurerm/internal/services/appservice/client"
 	arckubernetes "github.com/hashicorp/terraform-provider-azurerm/internal/services/arckubernetes/client"
+	arcResourceBridge "github.com/hashicorp/terraform-provider-azurerm/internal/services/arcresourcebridge/client"
 	attestation "github.com/hashicorp/terraform-provider-azurerm/internal/services/attestation/client"
 	authorization "github.com/hashicorp/terraform-provider-azurerm/internal/services/authorization/client"
 	automanage "github.com/hashicorp/terraform-provider-azurerm/internal/services/automanage/client"
@@ -162,6 +163,7 @@ type Client struct {
 	AppPlatform                  *appPlatform.Client
 	AppService                   *appService.Client
 	ArcKubernetes                *arckubernetes.Client
+	ArcResourceBridge            *arcResourceBridge.Client
 	Attestation                  *attestation.Client
 	Authorization                *authorization.Client
 	Automanage                   *automanage.Client
@@ -314,6 +316,9 @@ func (client *Client) Build(ctx context.Context, o *common.ClientOptions) error
 	if client.ArcKubernetes, err = arckubernetes.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for ArcKubernetes: %+v", err)
 	}
+	if client.ArcResourceBridge, err = arcResourceBridge.NewClient(o); err != nil {
+		return fmt.Errorf("building clients for Arc Resource Bridge: %+v", err)
+	}
 	if client.Attestation, err = attestation.NewClient(o); err != nil {
 		return fmt.Errorf("building clients for Attestation: %+v", err)
 	}

internal/provider/services.go

@@ -13,6 +13,7 @@ import (
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/applicationinsights"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/appservice"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/arckubernetes"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/services/arcresourcebridge"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/attestation"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/authorization"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/automanage"
@@ -139,6 +140,7 @@ func SupportedTypedServices() []sdk.TypedServiceRegistration {
 		applicationinsights.Registration{},
 		appservice.Registration{},
 		arckubernetes.Registration{},
+		arcresourcebridge.Registration{},
 		authorization.Registration{},
 		automanage.Registration{},
 		automation.Registration{},

internal/services/appconfiguration/app_configuration_feature_resource.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/Azure/go-autorest/autorest"
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/appconfiguration/2023-03-01/configurationstores"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-provider-azurerm/helpers/tf"
@@ -46,7 +47,7 @@ type FeatureResourceModel struct {
 	Label                string                       `tfschema:"label"`
 	Locked               bool                         `tfschema:"locked"`
 	Tags                 map[string]interface{}       `tfschema:"tags"`
-	PercentageFilter     int                          `tfschema:"percentage_filter_value"`
+	PercentageFilter     float64                      `tfschema:"percentage_filter_value"`
 	TimewindowFilters    []TimewindowFilterParameters `tfschema:"timewindow_filter"`
 	TargetingFilters     []TargetingFilterAudience    `tfschema:"targeting_filter"`
 }
@@ -96,9 +97,9 @@ func (k FeatureResource) Arguments() map[string]*pluginsdk.Schema {
 			Default:  false,
 		},
 		"percentage_filter_value": {
-			Type:         pluginsdk.TypeInt,
+			Type:         pluginsdk.TypeFloat,
 			Optional:     true,
-			ValidateFunc: validation.IntBetween(0, 100),
+			ValidateFunc: validation.FloatBetween(0, 100),
 		},
 		"targeting_filter": {
 			Type:     pluginsdk.TypeList,
@@ -242,9 +243,64 @@ func (k FeatureResource) Create() sdk.ResourceFunc {
 				return tf.ImportAsExistsError(k.ResourceType(), nestedItemId.ID())
 			}
 
-			err = createOrUpdateFeature(ctx, client, model)
+			entity := appconfiguration.KeyValue{
+				Key:         pointer.To(featureKey),
+				Label:       pointer.To(model.Label),
+				Tags:        tags.Expand(model.Tags),
+				ContentType: pointer.To(FeatureKeyContentType),
+				Locked:      pointer.To(model.Locked),
+			}
+
+			value := FeatureValue{
+				ID:          model.Name,
+				Description: model.Description,
+				Enabled:     model.Enabled,
+			}
+
+			value.Conditions.ClientFilters.Filters = make([]interface{}, 0)
+
+			if model.PercentageFilter > 0 {
+				value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, PercentageFeatureFilter{
+					Name:       PercentageFilterName,
+					Parameters: PercentageFilterParameters{Value: model.PercentageFilter},
+				})
+			}
+
+			if len(model.TargetingFilters) > 0 {
+				for _, tgtf := range model.TargetingFilters {
+					value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, TargetingFeatureFilter{
+						Name:       TargetingFilterName,
+						Parameters: TargetingFilterParameters{Audience: tgtf},
+					})
+				}
+			}
+
+			if len(model.TimewindowFilters) > 0 {
+				for _, twf := range model.TimewindowFilters {
+					value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, TimewindowFeatureFilter{
+						Name:       TimewindowFilterName,
+						Parameters: twf,
+					})
+				}
+			}
+
+			valueBytes, err := json.Marshal(value)
 			if err != nil {
-				return fmt.Errorf("while creating feature: %+v", err)
+				return fmt.Errorf("while marshalling FeatureValue struct: %+v", err)
+			}
+			entity.Value = pointer.To(string(valueBytes))
+			if _, err = client.PutKeyValue(ctx, featureKey, model.Label, &entity, "", ""); err != nil {
+				return err
+			}
+
+			if model.Locked {
+				if _, err = client.PutLock(ctx, featureKey, model.Label, "", ""); err != nil {
+					return fmt.Errorf("while locking key/label pair %s/%s: %+v", model.Name, model.Label, err)
+				}
+			} else {
+				if _, err = client.DeleteLock(ctx, featureKey, model.Label, "", ""); err != nil {
+					return fmt.Errorf("while unlocking key/label pair %s/%s: %+v", model.Name, model.Label, err)
+				}
 			}
 
 			// https://github.com/Azure/AppConfiguration/issues/763
@@ -373,6 +429,17 @@ func (k FeatureResource) Update() sdk.ResourceFunc {
 				return err
 			}
 
+			kv, err := client.GetKeyValue(ctx, nestedItemId.Key, nestedItemId.Label, "", "", "", []appconfiguration.KeyValueFields{})
+			if err != nil {
+				return fmt.Errorf("while checking for key %q existence: %+v", *nestedItemId, err)
+			}
+
+			var fv FeatureValue
+			err = json.Unmarshal([]byte(utils.NormalizeNilableString(kv.Value)), &fv)
+			if err != nil {
+				return fmt.Errorf("while unmarshalling underlying key's value: %+v", err)
+			}
+
 			var model FeatureResourceModel
 			if err := metadata.Decode(&model); err != nil {
 				return fmt.Errorf("decoding %+v", err)
@@ -385,14 +452,104 @@ func (k FeatureResource) Update() sdk.ResourceFunc {
 
 			metadata.Client.AppConfiguration.AddToCache(*configurationStoreId, nestedItemId.ConfigurationStoreEndpoint)
 
-			if metadata.ResourceData.HasChange("tags") || metadata.ResourceData.HasChange("enabled") || metadata.ResourceData.HasChange("locked") || metadata.ResourceData.HasChange("description") {
-				// Remove the lock, if any. We will put it back again if the model says so.
-				if _, err = client.DeleteLock(ctx, nestedItemId.Key, nestedItemId.Label, "", ""); err != nil {
-					return fmt.Errorf("while unlocking key/label pair %s/%s: %+v", nestedItemId.Key, nestedItemId.Label, err)
+			// Remove the lock, if any. We will put it back again if the model says so.
+			if _, err = client.DeleteLock(ctx, nestedItemId.Key, nestedItemId.Label, "", ""); err != nil {
+				return fmt.Errorf("while unlocking key/label pair %s/%s: %+v", nestedItemId.Key, nestedItemId.Label, err)
+			}
+
+			if metadata.ResourceData.HasChange("tags") {
+				kv.Tags = tags.Expand(model.Tags)
+			}
+
+			if metadata.ResourceData.HasChange("locked") {
+				kv.Locked = pointer.To(model.Locked)
+			}
+
+			if metadata.ResourceData.HasChange("enabled") {
+				fv.Enabled = model.Enabled
+			}
+
+			if metadata.ResourceData.HasChange("description") {
+				fv.Description = model.Description
+			}
+
+			filters := make([]interface{}, 0)
+			filterChanged := false
+			timewindowFilters := make([]interface{}, 0)
+			targetingFilters := make([]interface{}, 0)
+			percentageFilter := PercentageFeatureFilter{}
+			if len(fv.Conditions.ClientFilters.Filters) > 0 {
+				for _, f := range fv.Conditions.ClientFilters.Filters {
+					switch f := f.(type) {
+					case TimewindowFeatureFilter:
+						twfp := f
+						timewindowFilters = append(timewindowFilters, twfp)
+					case TargetingFeatureFilter:
+						tfp := f
+						targetingFilters = append(targetingFilters, tfp)
+					case PercentageFeatureFilter:
+						pfp := f
+						percentageFilter = pfp
+					default:
+						return fmt.Errorf("while unmarshaling feature payload: unknown filter type %+v", f)
+					}
+				}
+			}
+
+			if metadata.ResourceData.HasChange("percentage_filter_value") {
+				filters = append(filters, PercentageFeatureFilter{
+					Name:       PercentageFilterName,
+					Parameters: PercentageFilterParameters{Value: model.PercentageFilter},
+				})
+				filterChanged = true
+			} else {
+				filters = append(filters, percentageFilter)
+			}
+
+			if metadata.ResourceData.HasChange("targeting_filter") {
+				for _, tgtf := range model.TargetingFilters {
+					filters = append(filters, TargetingFeatureFilter{
+						Name:       TargetingFilterName,
+						Parameters: TargetingFilterParameters{Audience: tgtf},
+					})
+				}
+				filterChanged = true
+			} else {
+				filters = append(filters, targetingFilters...)
+			}
+
+			if metadata.ResourceData.HasChange("timewindow_filter") {
+				for _, twf := range model.TimewindowFilters {
+					filters = append(filters, TimewindowFeatureFilter{
+						Name:       TimewindowFilterName,
+						Parameters: twf,
+					})
+				}
+				filterChanged = true
+			} else {
+				filters = append(filters, timewindowFilters...)
+			}
+
+			if filterChanged {
+				fv.Conditions.ClientFilters.Filters = filters
+			}
+
+			valueBytes, err := json.Marshal(fv)
+			if err != nil {
+				return fmt.Errorf("while marshalling FeatureValue struct: %+v", err)
+			}
+			kv.Value = pointer.To(string(valueBytes))
+			if _, err = client.PutKeyValue(ctx, nestedItemId.Key, model.Label, &kv, "", ""); err != nil {
+				return err
+			}
+
+			if model.Locked {
+				if _, err = client.PutLock(ctx, nestedItemId.Key, model.Label, "", ""); err != nil {
+					return fmt.Errorf("while locking key/label pair %s/%s: %+v", model.Name, model.Label, err)
 				}
-				err = createOrUpdateFeature(ctx, client, model)
-				if err != nil {
-					return fmt.Errorf("while updating feature: %+v", err)
+			} else {
+				if _, err = client.DeleteLock(ctx, nestedItemId.Key, model.Label, "", ""); err != nil {
+					return fmt.Errorf("while unlocking key/label pair %s/%s: %+v", model.Name, model.Label, err)
 				}
 			}
 
@@ -442,74 +599,6 @@ func (k FeatureResource) IDValidationFunc() pluginsdk.SchemaValidateFunc {
 	return validate.NestedItemId
 }
 
-func createOrUpdateFeature(ctx context.Context, client *appconfiguration.BaseClient, model FeatureResourceModel) error {
-	rawKey := model.Name
-	if model.Key != "" {
-		rawKey = model.Key
-	}
-	featureKey := fmt.Sprintf("%s/%s", FeatureKeyPrefix, rawKey)
-
-	entity := appconfiguration.KeyValue{
-		Key:         utils.String(featureKey),
-		Label:       utils.String(model.Label),
-		Tags:        tags.Expand(model.Tags),
-		ContentType: utils.String(FeatureKeyContentType),
-		Locked:      utils.Bool(model.Locked),
-	}
-
-	value := FeatureValue{
-		ID:          model.Name,
-		Description: model.Description,
-		Enabled:     model.Enabled,
-	}
-
-	value.Conditions.ClientFilters.Filters = make([]interface{}, 0)
-	if model.PercentageFilter > 0 {
-		value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, PercentageFeatureFilter{
-			Name:       PercentageFilterName,
-			Parameters: PercentageFilterParameters{Value: model.PercentageFilter},
-		})
-	}
-
-	if len(model.TargetingFilters) > 0 {
-		for _, tgtf := range model.TargetingFilters {
-			value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, TargetingFeatureFilter{
-				Name:       TargetingFilterName,
-				Parameters: TargetingFilterParameters{Audience: tgtf},
-			})
-		}
-	}
-
-	if len(model.TimewindowFilters) > 0 {
-		for _, twf := range model.TimewindowFilters {
-			value.Conditions.ClientFilters.Filters = append(value.Conditions.ClientFilters.Filters, TimewindowFeatureFilter{
-				Name:       TimewindowFilterName,
-				Parameters: twf,
-			})
-		}
-	}
-
-	valueBytes, err := json.Marshal(value)
-	if err != nil {
-		return fmt.Errorf("while marshalling FeatureValue struct: %+v", err)
-	}
-	entity.Value = utils.String(string(valueBytes))
-	if _, err = client.PutKeyValue(ctx, featureKey, model.Label, &entity, "", ""); err != nil {
-		return err
-	}
-
-	if model.Locked {
-		if _, err = client.PutLock(ctx, featureKey, model.Label, "", ""); err != nil {
-			return fmt.Errorf("while locking key/label pair %s/%s: %+v", model.Name, model.Label, err)
-		}
-	} else {
-		if _, err = client.DeleteLock(ctx, featureKey, model.Label, "", ""); err != nil {
-			return fmt.Errorf("while unlocking key/label pair %s/%s: %+v", model.Name, model.Label, err)
-		}
-	}
-
-	return nil
-}
 func (k FeatureResource) StateUpgraders() sdk.StateUpgradeData {
 	return sdk.StateUpgradeData{
 		SchemaVersion: 1,