Feature gap: Add missed fields for Reservation resource (#14181) (#23561)

[upstream:5fe392557c4bb3ac8ca45a38df86b9d8d4828734]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/14181.txt

@@ -0,0 +1,7 @@
+```release-note:enhancement
+compute: added `specific_reservation.0.instance_properties.0.maintenance_interval`, `share_settings.0.projects` and `enable_emergent_maintenance` fields to `google_compute_reservation` resource (beta)
+```
+
+```release-note:enhancement
+compute: added `specific_reservation.0.source_instance_template`, `delete_at_time`, `delete_after_duration.0.seconds`, `delete_after_duration.0.nanos` and `reservation_sharing_policy.0.service_share_type` fields to `google_compute_reservation` resource (ga)
+```

google/services/compute/resource_compute_reservation.go

@@ -87,7 +87,8 @@ character, which cannot be a dash.`,
 						},
 						"instance_properties": {
 							Type:        schema.TypeList,
-							Required:    true,
+							Computed:    true,
+							Optional:    true,
 							ForceNew:    true,
 							Description: `The instance properties for the reservation.`,
 							MaxItems:    1,
@@ -163,6 +164,14 @@ for information on available CPU platforms.`,
 									},
 								},
 							},
+							ExactlyOneOf: []string{"specific_reservation.0.instance_properties", "specific_reservation.0.source_instance_template"},
+						},
+						"source_instance_template": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Description: `Specifies the instance template to create the reservation. If you use this field, you must exclude the
+instanceProperties field.`,
+							ExactlyOneOf: []string{"specific_reservation.0.instance_properties", "specific_reservation.0.source_instance_template"},
 						},
 						"in_use_count": {
 							Type:        schema.TypeInt,
@@ -179,12 +188,64 @@ for information on available CPU platforms.`,
 				DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName,
 				Description:      `The zone where the reservation is made.`,
 			},
+			"delete_after_duration": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Description: `Duration after which the reservation will be auto-deleted by Compute Engine. Cannot be used with delete_at_time.`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"nanos": {
+							Type:          schema.TypeInt,
+							Optional:      true,
+							ForceNew:      true,
+							Description:   `Number of nanoseconds for the auto-delete duration.`,
+							ConflictsWith: []string{"delete_at_time"},
+						},
+						"seconds": {
+							Type:          schema.TypeString,
+							Optional:      true,
+							ForceNew:      true,
+							Description:   `Number of seconds for the auto-delete duration.`,
+							ConflictsWith: []string{"delete_at_time"},
+						},
+					},
+				},
+			},
+			"delete_at_time": {
+				Type:     schema.TypeString,
+				Computed: true,
+				Optional: true,
+				ForceNew: true,
+				Description: `Absolute time in future when the reservation will be auto-deleted by Compute Engine. Timestamp is represented in RFC3339 text format.
+Cannot be used with delete_after_duration.`,
+				ConflictsWith: []string{"delete_after_duration.0.seconds", "delete_after_duration.0.nanos"},
+			},
 			"description": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				ForceNew:    true,
 				Description: `An optional description of this resource.`,
 			},
+			"reservation_sharing_policy": {
+				Type:        schema.TypeList,
+				Computed:    true,
+				Optional:    true,
+				Description: `Sharing policy for reservations with Google Cloud managed services.`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"service_share_type": {
+							Type:         schema.TypeString,
+							Computed:     true,
+							Optional:     true,
+							ForceNew:     true,
+							ValidateFunc: verify.ValidateEnum([]string{"ALLOW_ALL", "DISALLOW_ALL", ""}),
+							Description:  `Sharing config for all Google Cloud services. Possible values: ["ALLOW_ALL", "DISALLOW_ALL"]`,
+						},
+					},
+				},
+			},
 			"share_settings": {
 				Type:        schema.TypeList,
 				Computed:    true,
@@ -300,6 +361,24 @@ func resourceComputeReservationCreate(d *schema.ResourceData, meta interface{})
 	} else if v, ok := d.GetOkExists("specific_reservation"); !tpgresource.IsEmptyValue(reflect.ValueOf(specificReservationProp)) && (ok || !reflect.DeepEqual(v, specificReservationProp)) {
 		obj["specificReservation"] = specificReservationProp
 	}
+	deleteAtTimeProp, err := expandComputeReservationDeleteAtTime(d.Get("delete_at_time"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("delete_at_time"); !tpgresource.IsEmptyValue(reflect.ValueOf(deleteAtTimeProp)) && (ok || !reflect.DeepEqual(v, deleteAtTimeProp)) {
+		obj["deleteAtTime"] = deleteAtTimeProp
+	}
+	deleteAfterDurationProp, err := expandComputeReservationDeleteAfterDuration(d.Get("delete_after_duration"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("delete_after_duration"); !tpgresource.IsEmptyValue(reflect.ValueOf(deleteAfterDurationProp)) && (ok || !reflect.DeepEqual(v, deleteAfterDurationProp)) {
+		obj["deleteAfterDuration"] = deleteAfterDurationProp
+	}
+	reservationSharingPolicyProp, err := expandComputeReservationReservationSharingPolicy(d.Get("reservation_sharing_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("reservation_sharing_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(reservationSharingPolicyProp)) && (ok || !reflect.DeepEqual(v, reservationSharingPolicyProp)) {
+		obj["reservationSharingPolicy"] = reservationSharingPolicyProp
+	}
 	zoneProp, err := expandComputeReservationZone(d.Get("zone"), d, config)
 	if err != nil {
 		return err
@@ -426,6 +505,12 @@ func resourceComputeReservationRead(d *schema.ResourceData, meta interface{}) er
 	if err := d.Set("specific_reservation", flattenComputeReservationSpecificReservation(res["specificReservation"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Reservation: %s", err)
 	}
+	if err := d.Set("delete_at_time", flattenComputeReservationDeleteAtTime(res["deleteAtTime"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Reservation: %s", err)
+	}
+	if err := d.Set("reservation_sharing_policy", flattenComputeReservationReservationSharingPolicy(res["reservationSharingPolicy"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Reservation: %s", err)
+	}
 	if err := d.Set("zone", flattenComputeReservationZone(res["zone"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Reservation: %s", err)
 	}
@@ -458,6 +543,18 @@ func resourceComputeReservationUpdate(d *schema.ResourceData, meta interface{})
 	} else if v, ok := d.GetOkExists("share_settings"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, shareSettingsProp)) {
 		obj["shareSettings"] = shareSettingsProp
 	}
+	deleteAfterDurationProp, err := expandComputeReservationDeleteAfterDuration(d.Get("delete_after_duration"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("delete_after_duration"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, deleteAfterDurationProp)) {
+		obj["deleteAfterDuration"] = deleteAfterDurationProp
+	}
+	reservationSharingPolicyProp, err := expandComputeReservationReservationSharingPolicy(d.Get("reservation_sharing_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("reservation_sharing_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, reservationSharingPolicyProp)) {
+		obj["reservationSharingPolicy"] = reservationSharingPolicyProp
+	}
 
 	obj, err = resourceComputeReservationUpdateEncoder(d, meta, obj)
 	if err != nil {
@@ -476,6 +573,14 @@ func resourceComputeReservationUpdate(d *schema.ResourceData, meta interface{})
 	if d.HasChange("share_settings") {
 		updateMask = append(updateMask, "shareSettings")
 	}
+
+	if d.HasChange("delete_after_duration") {
+		updateMask = append(updateMask, "deleteAfterDuration")
+	}
+
+	if d.HasChange("reservation_sharing_policy") {
+		updateMask = append(updateMask, "reservationSharingPolicy")
+	}
 	// updateMask is a URL parameter but not present in the schema, so ReplaceVars
 	// won't set it
 	url, err = transport_tpg.AddQueryParams(url, map[string]string{"updateMask": strings.Join(updateMask, ",")})
@@ -711,6 +816,8 @@ func flattenComputeReservationSpecificReservation(v interface{}, d *schema.Resou
 		flattenComputeReservationSpecificReservationInUseCount(original["inUseCount"], d, config)
 	transformed["instance_properties"] =
 		flattenComputeReservationSpecificReservationInstanceProperties(original["instanceProperties"], d, config)
+	transformed["source_instance_template"] =
+		flattenComputeReservationSpecificReservationSourceInstanceTemplate(original["sourceInstanceTemplate"], d, config)
 	return []interface{}{transformed}
 }
 func flattenComputeReservationSpecificReservationCount(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
@@ -854,6 +961,31 @@ func flattenComputeReservationSpecificReservationInstancePropertiesLocalSsdsDisk
 	return v // let terraform core handle it otherwise
 }
 
+func flattenComputeReservationSpecificReservationSourceInstanceTemplate(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeReservationDeleteAtTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeReservationReservationSharingPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["service_share_type"] =
+		flattenComputeReservationReservationSharingPolicyServiceShareType(original["serviceShareType"], d, config)
+	return []interface{}{transformed}
+}
+func flattenComputeReservationReservationSharingPolicyServiceShareType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeReservationZone(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return v
@@ -962,6 +1094,13 @@ func expandComputeReservationSpecificReservation(v interface{}, d tpgresource.Te
 		transformed["instanceProperties"] = transformedInstanceProperties
 	}
 
+	transformedSourceInstanceTemplate, err := expandComputeReservationSpecificReservationSourceInstanceTemplate(original["source_instance_template"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedSourceInstanceTemplate); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["sourceInstanceTemplate"] = transformedSourceInstanceTemplate
+	}
+
 	return transformed, nil
 }
 
@@ -1095,6 +1234,71 @@ func expandComputeReservationSpecificReservationInstancePropertiesLocalSsdsDiskS
 	return v, nil
 }
 
+func expandComputeReservationSpecificReservationSourceInstanceTemplate(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeReservationDeleteAtTime(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeReservationDeleteAfterDuration(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	transformed := make(map[string]interface{})
+
+	transformedSeconds, err := expandComputeReservationDeleteAfterDurationSeconds(original["seconds"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedSeconds); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["seconds"] = transformedSeconds
+	}
+
+	transformedNanos, err := expandComputeReservationDeleteAfterDurationNanos(original["nanos"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedNanos); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["nanos"] = transformedNanos
+	}
+
+	return transformed, nil
+}
+
+func expandComputeReservationDeleteAfterDurationSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeReservationDeleteAfterDurationNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeReservationReservationSharingPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	l := v.([]interface{})
+	if len(l) == 0 || l[0] == nil {
+		return nil, nil
+	}
+	raw := l[0]
+	original := raw.(map[string]interface{})
+	transformed := make(map[string]interface{})
+
+	transformedServiceShareType, err := expandComputeReservationReservationSharingPolicyServiceShareType(original["service_share_type"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedServiceShareType); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["serviceShareType"] = transformedServiceShareType
+	}
+
+	return transformed, nil
+}
+
+func expandComputeReservationReservationSharingPolicyServiceShareType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeReservationZone(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	f, err := tpgresource.ParseGlobalFieldValue("zones", v.(string), "project", d, config, true)
 	if err != nil {

google/services/compute/resource_compute_reservation_generated_meta.yaml

@@ -7,8 +7,12 @@ api_resource_type_kind: 'Allocation'
 fields:
   - field: 'commitment'
   - field: 'creation_timestamp'
+  - field: 'delete_after_duration.nanos'
+  - field: 'delete_after_duration.seconds'
+  - field: 'delete_at_time'
   - field: 'description'
   - field: 'name'
+  - field: 'reservation_sharing_policy.service_share_type'
   - field: 'share_settings.project_map.project_config.project_id'
   - field: 'share_settings.share_type'
   - field: 'specific_reservation.count'
@@ -19,6 +23,7 @@ fields:
   - field: 'specific_reservation.instance_properties.local_ssds.interface'
   - field: 'specific_reservation.instance_properties.machine_type'
   - field: 'specific_reservation.instance_properties.min_cpu_platform'
+  - field: 'specific_reservation.source_instance_template'
   - field: 'specific_reservation_required'
   - field: 'status'
   - field: 'zone'