Sync bitbucket and GitHub

Author: carchi8py

CHANGELOG.md

@@ -1,3 +1,15 @@
+## 27.2.0
+
+NEW FEATURES:
+* resource/cvo_gcp: Added support for `iops` and `throughput` parameters during GCP CVO creation with `hyperdisk-balanced` volume type.
+* resource/aggregate: Added support for `iops` and `throughput` parameters during aggregate creation with `hyperdisk-balanced` provider volume type.
+* resource/aggregate: Added support for in-place update of `iops` and `throughput` on existing `hyperdisk-balanced` aggregates without requiring resource recreation.
+
+ENHANCEMENTS:
+* resource/aggregate: Added `Computed` attribute for `iops` and `throughput` to support import and drift detection by reading actual values from the API.
+* resource/aggregate: Added conditional `ForceNew` via `CustomizeDiff` for `iops` and `throughput` — in-place update for `hyperdisk-balanced`, destroy+recreate for other volume types (backward compatible).
+* resource/aggregate: Updated import to populate `iops` and `throughput` from the API response.
+
 ## 27.1.0 
 
 NEW FEATURES: 

cloudmanager/aggregate.go

@@ -116,6 +116,13 @@ type increaseAggregateCapacityRequest struct {
 	CapacityToAdd        diskSize `structs:"capacityToAdd"`
 }
 
+type updateAggregateIopsThroughputRequest struct {
+	WorkingEnvironmentID string `structs:"workingEnvironmentId"`
+	Name                 string `structs:"name"`
+	Iops                 int    `structs:"iops,omitempty"`
+	Throughput           int    `structs:"throughput,omitempty"`
+}
+
 // get aggregate by workingEnvironmentId+aggregate name
 func (c *Client) getAggregate(request aggregateRequest, name string, sourceWorkingEnvironmentType string, clientID string, isSaaS bool, connectorIP string) (aggregateResult, error) {
 	log.Printf("getAggregate %s", name)
@@ -367,6 +374,45 @@ func (c *Client) increaseAggregateCapacity(request increaseAggregateCapacityRequ
 	return err
 }
 
+func (c *Client) updateAggregateIopsThroughput(request updateAggregateIopsThroughputRequest, clientID string, isSaaS bool, connectorIP string) error {
+	log.Printf("updateAggregateIopsThroughput for aggregate %s (iops: %d, throughput: %d)", request.Name, request.Iops, request.Throughput)
+
+	params := structs.Map(request)
+	hostType := "CloudManagerHost"
+	if !isSaaS {
+		hostType = "http://" + connectorIP
+	}
+
+	var baseURL string
+	rootURL, _, err := c.getAPIRoot(request.WorkingEnvironmentID, clientID, isSaaS, connectorIP)
+	if err != nil {
+		log.Print("updateAggregateIopsThroughput: Cannot get API root.")
+		return err
+	}
+
+	baseURL = fmt.Sprintf("%s/aggregates/%s/%s", rootURL, request.WorkingEnvironmentID, request.Name)
+
+	statusCode, response, onCloudRequestID, err := c.CallAPIMethod("PUT", baseURL, params, c.Token, hostType, clientID)
+	if err != nil {
+		log.Print("updateAggregateIopsThroughput request failed")
+		return err
+	}
+
+	responseError := apiResponseChecker(statusCode, response, "updateAggregateIopsThroughput")
+	if responseError != nil {
+		return responseError
+	}
+
+	log.Print("Wait for aggregate IOPS/throughput update.")
+	if isSaaS {
+		err = c.waitOnCompletion(onCloudRequestID, "Aggregate", "update IOPS/throughput", 15, 60, clientID)
+	} else {
+		err = c.waitOnCompletionForNotSaas(onCloudRequestID, "Aggregate", "update IOPS/throughput", 15, 60, clientID, connectorIP)
+	}
+
+	return err
+}
+
 // flattenCapacity: convert struct size + unit
 func flattenCapacity(c capacity) interface{} {
 	flattened := make(map[string]interface{})

cloudmanager/cvo_gcp.go

@@ -28,6 +28,7 @@ type createCVOGCPDetails struct {
 	VsaMetadata             vsaMetadata             `structs:"vsaMetadata"`
 	GCPVolumeSize           diskSize                `structs:"gcpVolumeSize"`
 	GCPVolumeType           string                  `structs:"gcpVolumeType"`
+	GcpPerformance          gcpPerformance          `structs:"gcpPerformance,omitempty"`
 	SubnetID                string                  `structs:"subnetId"`
 	SubnetPath              string                  `structs:"subnetPath"`
 	Project                 string                  `structs:"project"`
@@ -56,6 +57,12 @@ type gcpLabels struct {
 	LabelValue string `structs:"labelValue,omitempty"`
 }
 
+// gcpPerformance for setting IOPS and throughput on hyperdisk-balanced
+type gcpPerformance struct {
+	Iops       int `structs:"iops,omitempty"`
+	Throughput int `structs:"throughput,omitempty"`
+}
+
 // gcpSVMs the input for adding SVMs to a CVO HA
 type gcpSVM struct {
 	SvmName             string `structs:"svmName"`

cloudmanager/resource_netapp_cloudmanager_aggregate.go

@@ -75,14 +75,16 @@ func resourceAggregate() *schema.Resource {
 				ValidateFunc: validation.StringInSlice([]string{"NONE", "S3", "Blob", "cloudStorage"}, true),
 			},
 			"iops": {
-				Type:     schema.TypeInt,
-				Optional: true,
-				ForceNew: true,
+				Type:        schema.TypeInt,
+				Optional:    true,
+				Computed:    true,
+				Description: "Provisioned IOPS. Applicable when provider_volume_type is 'io1', 'gp3', or 'hyperdisk-balanced'. For 'hyperdisk-balanced', valid range is 3000-160000.",
 			},
 			"throughput": {
-				Type:     schema.TypeInt,
-				Optional: true,
-				ForceNew: true,
+				Type:        schema.TypeInt,
+				Optional:    true,
+				Computed:    true,
+				Description: "Provisioned throughput in MBps. Applicable when provider_volume_type is 'gp3' or 'hyperdisk-balanced'. For 'hyperdisk-balanced', valid range is 140-2400.",
 			},
 			"connector_ip": {
 				Type:     schema.TypeString,
@@ -215,6 +217,18 @@ func resourceAggregateCreate(d *schema.ResourceData, meta interface{}) error {
 				log.Printf("CreateAggregate: provider_volume_type is gp3, but throughput is not configured.")
 			}
 		}
+		if aggregate.ProviderVolumeType == "hyperdisk-balanced" {
+			if a, ok := d.GetOk("iops"); ok {
+				aggregate.Iops = a.(int)
+			} else {
+				log.Printf("CreateAggregate: provider_volume_type is hyperdisk-balanced, but iops is not configured.")
+			}
+			if a, ok := d.GetOk("throughput"); ok {
+				aggregate.Throughput = a.(int)
+			} else {
+				log.Printf("CreateAggregate: provider_volume_type is hyperdisk-balanced, but throughput is not configured.")
+			}
+		}
 	}
 	if a, ok := d.GetOk("capacity_tier"); ok {
 		if a.(string) != "NONE" {
@@ -299,9 +313,13 @@ func resourceAggregateRead(d *schema.ResourceData, meta interface{}) error {
 		d.SetId(aggr.Name)
 		d.Set("number_of_disks", len(aggr.Disks))
 		d.Set("working_environment_name", workingEnv.Name)
-		d.Set("disk_size_size", aggr.ProviderVolumes[0].Size.Size)
-		d.Set("disk_size_unit", aggr.ProviderVolumes[0].Size.Unit)
-		d.Set("provider_volume_type", aggr.ProviderVolumes[0].DiskType)
+		if len(aggr.ProviderVolumes) > 0 {
+			d.Set("disk_size_size", aggr.ProviderVolumes[0].Size.Size)
+			d.Set("disk_size_unit", aggr.ProviderVolumes[0].Size.Unit)
+			d.Set("provider_volume_type", aggr.ProviderVolumes[0].DiskType)
+			d.Set("iops", aggr.ProviderVolumes[0].Iops)
+			d.Set("throughput", aggr.ProviderVolumes[0].Throughput)
+		}
 	}
 
 	if aggr.Name != d.Get("name").(string) {
@@ -313,6 +331,10 @@ func resourceAggregateRead(d *schema.ResourceData, meta interface{}) error {
 	d.Set("total_capacity_unit", aggr.TotalCapacity.Unit)
 	d.Set("available_capacity_size", aggr.AvailableCapacity.Size)
 	d.Set("available_capacity_unit", aggr.AvailableCapacity.Unit)
+	if len(aggr.ProviderVolumes) > 0 {
+		d.Set("iops", aggr.ProviderVolumes[0].Iops)
+		d.Set("throughput", aggr.ProviderVolumes[0].Throughput)
+	}
 
 	return nil
 }
@@ -413,6 +435,26 @@ func resourceAggregateUpdate(d *schema.ResourceData, meta interface{}) error {
 		}
 	}
 
+	// Handle IOPS/Throughput update (hyperdisk-balanced only, enforced by CustomizeDiff)
+	if d.HasChange("iops") || d.HasChange("throughput") {
+		updateRequest := updateAggregateIopsThroughputRequest{
+			WorkingEnvironmentID: workingEnvDetail.PublicID,
+			Name:                 request.Name,
+		}
+		if d.HasChange("iops") {
+			updateRequest.Iops = d.Get("iops").(int)
+		}
+		if d.HasChange("throughput") {
+			updateRequest.Throughput = d.Get("throughput").(int)
+		}
+
+		err := client.updateAggregateIopsThroughput(updateRequest, clientID, isSaaS, connectorIP)
+		if err != nil {
+			return fmt.Errorf("failed to update aggregate IOPS/throughput: %v", err)
+		}
+		log.Printf("Successfully updated IOPS/throughput for aggregate %s", request.Name)
+	}
+
 	// Handle disk count update
 	if d.HasChange("number_of_disks") {
 		expectNumber := d.Get("number_of_disks")
@@ -536,6 +578,18 @@ func resourceAggregateCustomizeDiff(diff *schema.ResourceDiff, v interface{}) er
 		return fmt.Errorf("increase_capacity_size is required when increase_capacity_unit is specified")
 	}
 
+	// For non-hyperdisk-balanced volume types, force replacement on iops/throughput changes
+	// to preserve backward compatibility (gp3, io1, etc. previously had ForceNew: true)
+	providerVolumeType := diff.Get("provider_volume_type").(string)
+	if providerVolumeType != "hyperdisk-balanced" {
+		if diff.HasChange("iops") {
+			diff.ForceNew("iops")
+		}
+		if diff.HasChange("throughput") {
+			diff.ForceNew("throughput")
+		}
+	}
+
 	return nil
 }
 

cloudmanager/resource_netapp_cloudmanager_cvo_gcp.go

@@ -59,7 +59,7 @@ func resourceCVOGCP() *schema.Resource {
 				Optional:     true,
 				ForceNew:     true,
 				Default:      "pd-ssd",
-				ValidateFunc: validation.StringInSlice([]string{"pd-balanced", "pd-standard", "pd-ssd"}, false),
+				ValidateFunc: validation.StringInSlice([]string{"pd-balanced", "pd-standard", "pd-ssd", "hyperdisk-balanced"}, false),
 			},
 			"gcp_volume_size": {
 				Type:     schema.TypeInt,
@@ -74,6 +74,18 @@ func resourceCVOGCP() *schema.Resource {
 				Default:      "TB",
 				ValidateFunc: validation.StringInSlice([]string{"GB", "TB"}, false),
 			},
+			"iops": {
+				Type:        schema.TypeInt,
+				Optional:    true,
+				ForceNew:    true,
+				Description: "Provisioned IOPS for the initial aggregate. Only applicable when gcp_volume_type is 'hyperdisk-balanced'. Valid range is 3000-160000. To update IOPS after creation, use the netapp-cloudmanager_aggregate resource.",
+			},
+			"throughput": {
+				Type:        schema.TypeInt,
+				Optional:    true,
+				ForceNew:    true,
+				Description: "Provisioned throughput for the initial aggregate. Only applicable when gcp_volume_type is 'hyperdisk-balanced'. Valid range is 140-2400. To update throughput after creation, use the netapp-cloudmanager_aggregate resource.",
+			},
 			"ontap_version": {
 				Type:     schema.TypeString,
 				Optional: true,
@@ -416,6 +428,14 @@ func resourceCVOGCPCreate(d *schema.ResourceData, meta interface{}) error {
 	cvoDetails.DataEncryptionType = d.Get("data_encryption_type").(string)
 	cvoDetails.WorkspaceID = d.Get("workspace_id").(string)
 	cvoDetails.GCPVolumeType = d.Get("gcp_volume_type").(string)
+	if cvoDetails.GCPVolumeType == "hyperdisk-balanced" {
+		if c, ok := d.GetOk("iops"); ok {
+			cvoDetails.GcpPerformance.Iops = c.(int)
+		}
+		if c, ok := d.GetOk("throughput"); ok {
+			cvoDetails.GcpPerformance.Throughput = c.(int)
+		}
+	}
 	cvoDetails.SvmPassword = d.Get("svm_password").(string)
 	if c, ok := d.GetOk("svm_name"); ok {
 		cvoDetails.SvmName = c.(string)
@@ -967,6 +987,14 @@ func resourceCVOGCPCustomizeDiff(diff *schema.ResourceDiff, v interface{}) error
 		}
 	}
 
+	//Validate iops/throughput only allowed for hyperdisk-balanced
+	gcpVolumeType := diff.Get("gcp_volume_type").(string)
+	_, hasIops := diff.GetOk("iops")
+	_, hasThroughput := diff.GetOk("throughput")
+	if (hasIops || hasThroughput) && gcpVolumeType != "hyperdisk-balanced" {
+		return fmt.Errorf("performance parameters (iops, throughput) can only be specified when gcp_volume_type is 'hyperdisk-balanced', current type is '%s'", gcpVolumeType)
+	}
+
 	// WORM validation
 	wormLength, lengthOk := diff.GetOk("worm_retention_period_length")
 	wormUnit, unitOk := diff.GetOk("worm_retention_period_unit")

website/docs/d/volume.html.markdown

@@ -41,7 +41,7 @@ The following attributes are exported in addition to the arguments listed above:
 * `svm_name` - The name of the SVM.
 * `size` - The volume size, supported with decimal numbers.
 * `size_unit` - ['Byte' or 'KB' or 'MB' or 'GB' or 'TB'].
-* `provider_volume_type` - The underlying cloud provider volume type. For AWS: ['gp3', 'gp2', 'io1', 'st1', 'sc1']. For Azure: ['Premium_LRS','Standard_LRS','StandardSSD_LRS']. For GCP: ['pd-balanced', 'pd-ssd','pd-standard']
+* `provider_volume_type` - The underlying cloud provider volume type. For AWS: ['gp3', 'gp2', 'io1', 'st1', 'sc1']. For Azure: ['Premium_LRS','Standard_LRS','StandardSSD_LRS']. For GCP: ['pd-balanced', 'pd-ssd','pd-standard', 'hyperdisk-balanced']
 * `enable_thin_provisioning` - Enable thin provisioning. The default is 'true'.
 * `enable_compression` - Enable compression. The default is 'true'.
 * `enable_deduplication` - Enable deduplication. The default is 'true'.

website/docs/r/aggregate.html.markdown

@@ -67,6 +67,24 @@ resource "netapp-cloudmanager_aggregate" "cl-aggregate-with-capacity" {
   increase_capacity_unit = "GB"
 }
 ```
+**Create netapp-cloudmanager_aggregate with GCP hyperdisk-balanced and custom IOPS/Throughput (C3 instance only) :**
+
+```
+resource "netapp-cloudmanager_aggregate" "gcp-hyperdisk-aggr" {
+  provider = netapp-cloudmanager
+  name = "aggr_hyperdisk"
+  working_environment_id = netapp-cloudmanager_cvo_gcp.cvo-gcp.id
+  client_id = netapp-cloudmanager_connector_gcp.cm-gcp.client_id
+  number_of_disks = 1
+  provider_volume_type = "hyperdisk-balanced"
+  disk_size_size = 100
+  disk_size_unit = "GB"
+  
+  # IOPS and throughput configuration 
+  iops                 = 5000
+  throughput           = 500
+}
+```
 
 ## Argument Reference
 
@@ -85,10 +103,10 @@ The following arguments are supported:
 * `disk_size_size` - (Optional, Forces new resource) The required size of the disks. The max number depends on the `provider_volume_type`. Details in this document: AWS: [https://docs.netapp.com/us-en/cloud-volumes-ontap-relnotes/reference-limits-aws.html#aggregate-limits] Azure: [https://docs.netapp.com/us-en/cloud-volumes-ontap-relnotes/reference-limits-azure.html#aggregate-limits] GCP: [https://docs.netapp.com/us-en/cloud-volumes-ontap-relnotes/reference-limits-gcp.html#disk-and-tiering-limits] **Note: Must be provided together with `disk_size_unit`**
 * `disk_size_unit` - (Optional, Forces new resource) The disk size unit ['GB' or 'TB']. **Note: Must be provided together with `disk_size_size`**
 * `home_node` - (Optional, Forces new resource) The home node that the new aggregate should belong to. The default is the first node.
-* `provider_volume_type` - (Optional, Forces new resource) The cloud provider volume type. For AWS: ['gp3', 'gp2', 'io1', 'st1', 'sc1']. For Azure: ['Premium_LRS','Standard_LRS','StandardSSD_LRS']. For GCP: ['pd-balanced', 'pd-ssd','pd-standard']
+* `provider_volume_type` - (Optional, Forces new resource) The cloud provider volume type. For AWS: ['gp3', 'gp2', 'io1', 'st1', 'sc1']. For Azure: ['Premium_LRS','Standard_LRS','StandardSSD_LRS']. For GCP: ['pd-balanced', 'pd-ssd','pd-standard', 'hyperdisk-balanced']
 * `capacity_tier` - (Optional, Forces new resource) The aggregate's capacity tier for tiering cold data to object storage: ['S3', 'Blob', 'cloudStorage']. The default values for each cloud provider are as follows: Amazon => 'S3', Azure => 'Blob', GCP => 'cloudStorage'. If NONE, the capacity tier won't be set on aggregate creation.
-* `iops` - (Optional, Forces new resource) Provisioned IOPS. Needed only when 'providerVolumeType' is 'io1' or 'gp3'
-* `throughput` - (Optional, Forces new resource) Required only when 'providerVolumeType' is 'gp3'.
+* `iops` - (Optional) Provisioned IOPS. Applicable when 'providerVolumeType' is 'io1', 'gp3', or 'hyperdisk-balanced'. For 'hyperdisk-balanced', valid range is 3000-160000. Can be updated in-place for 'hyperdisk-balanced'; for other disk types, changing this value requires resource recreation.
+* `throughput` - (Optional) Provisioned throughput in MBps. Applicable when 'providerVolumeType' is 'gp3' or 'hyperdisk-balanced'. For 'hyperdisk-balanced', valid range is 140-2400. Can be updated in-place for 'hyperdisk-balanced'; for other disk types, changing this value requires resource recreation.
 * `initial_ev_aggregate_size` - (Optional, Forces new resource) Initial size for EBS Elastic Volumes aggregate (AWS only). This enables the aggregate to support capacity expansion using Amazon EBS Elastic Volumes. **Creation time only** - cannot be modified after aggregate creation. **Note: Must be provided together with `initial_ev_aggregate_unit`**
 * `initial_ev_aggregate_unit` - (Optional, Forces new resource) Unit for initial EBS Elastic Volumes aggregate size (GB, TB, GiB, or TiB). Only used with `initial_ev_aggregate_size`. Defaults to 'GB' if not specified. **Creation time only** - cannot be modified after aggregate creation. **Note: Must be provided together with `initial_ev_aggregate_size`**
 * `increase_capacity_size` - (Optional, Computed) Additional capacity to add to the aggregate using Amazon EBS Elastic Volumes. **Only supported for AWS aggregates with EBS Elastic Volumes enabled**. **Update operation only** - cannot be used during aggregate creation. The aggregate must be created with `initial_ev_aggregate_size` to support capacity increases. **Important:** After a successful capacity increase operation, remove the parameter from your configuration to prevent unnecessary state changes and achieve idempotency in subsequent Terraform runs. **Note: Must be provided together with `increase_capacity_unit`**