compute: Add scheduling.termination_time field to compute_instance resources (#12791) (#9479)

[upstream:fc3eeaab049d020371a96176262f2495ee9f7121]

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

Author: modular-magician

.changelog/12791.txt

@@ -0,0 +1,15 @@
+```release-note:enhancement
+compute: added `scheduling.termination_time` field to `google_compute_instance` resource
+```
+```release-note:enhancement
+compute: added `scheduling.termination_time` field to `google_compute_instance_from_machine_image` resource
+```
+```release-note:enhancement
+compute: added `scheduling.termination_time` field to `google_compute_instance_from_template` resource
+```
+```release-note:enhancement
+compute: added `scheduling.termination_time` field to `google_compute_instance_template` resource
+```
+```release-note:enhancement
+compute: added `scheduling.termination_time` field to `google_compute_region_instance_template` resource
+```

google-beta/services/compute/compute_instance_helpers.go

@@ -195,6 +195,9 @@ func expandScheduling(v interface{}) (*compute.Scheduling, error) {
 		scheduling.LocalSsdRecoveryTimeout = transformedLocalSsdRecoveryTimeout
 		scheduling.ForceSendFields = append(scheduling.ForceSendFields, "LocalSsdRecoveryTimeout")
 	}
+	if v, ok := original["termination_time"]; ok {
+		scheduling.TerminationTime = v.(string)
+	}
 	return scheduling, nil
 }
 
@@ -337,6 +340,7 @@ func flattenScheduling(resp *compute.Scheduling) []map[string]interface{} {
 		"provisioning_model":          resp.ProvisioningModel,
 		"instance_termination_action": resp.InstanceTerminationAction,
 		"availability_domain":         resp.AvailabilityDomain,
+		"termination_time":            resp.TerminationTime,
 	}
 
 	if resp.AutomaticRestart != nil {
@@ -778,7 +782,8 @@ func schedulingHasChangeRequiringReboot(d *schema.ResourceData) bool {
 
 	return hasNodeAffinitiesChanged(oScheduling, newScheduling) ||
 		hasMaxRunDurationChanged(oScheduling, newScheduling) ||
-		hasGracefulShutdownChangedWithReboot(d, oScheduling, newScheduling)
+		hasGracefulShutdownChangedWithReboot(d, oScheduling, newScheduling) ||
+		hasTerminationTimeChanged(oScheduling, newScheduling)
 }
 
 // Terraform doesn't correctly calculate changes on schema.Set, so we do it manually
@@ -830,6 +835,24 @@ func schedulingHasChangeWithoutReboot(d *schema.ResourceData) bool {
 	return false
 }
 
+func hasTerminationTimeChanged(oScheduling, nScheduling map[string]interface{}) bool {
+	oTerminationTime := oScheduling["termination_time"].(string)
+	nTerminationTime := nScheduling["termination_time"].(string)
+
+	if len(oTerminationTime) == 0 && len(nTerminationTime) == 0 {
+		return false
+	}
+	if len(oTerminationTime) == 0 || len(nTerminationTime) == 0 {
+		return true
+	}
+
+	if oTerminationTime != nTerminationTime {
+		return true
+	}
+
+	return false
+}
+
 func hasGracefulShutdownChangedWithReboot(d *schema.ResourceData, oScheduling, nScheduling map[string]interface{}) bool {
 	allow_stopping_for_update := d.Get("allow_stopping_for_update").(bool)
 	if !allow_stopping_for_update {

google-beta/services/compute/compute_instance_helpers_test.go

@@ -0,0 +1,41 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+package compute
+
+import (
+	"testing"
+)
+
+func TestHasTerminationTimeChanged(t *testing.T) {
+	t.Parallel()
+	cases := map[string]struct {
+		Old, New map[string]interface{}
+		Expect   bool
+	}{
+		"empty": {
+			Old:    map[string]interface{}{"termination_time": ""},
+			New:    map[string]interface{}{"termination_time": ""},
+			Expect: false,
+		},
+		"new": {
+			Old:    map[string]interface{}{"termination_time": ""},
+			New:    map[string]interface{}{"termination_time": "2025-01-31T15:04:05Z"},
+			Expect: true,
+		},
+		"changed": {
+			Old:    map[string]interface{}{"termination_time": "2025-01-30T15:04:05Z"},
+			New:    map[string]interface{}{"termination_time": "2025-01-31T15:04:05Z"},
+			Expect: true,
+		},
+		"same": {
+			Old:    map[string]interface{}{"termination_time": "2025-01-30T15:04:05Z"},
+			New:    map[string]interface{}{"termination_time": "2025-01-30T15:04:05Z"},
+			Expect: false,
+		},
+	}
+	for tn, tc := range cases {
+		if hasTerminationTimeChanged(tc.Old, tc.New) != tc.Expect {
+			t.Errorf("%s: expected %t for whether termination time matched for old = %q, new = %q", tn, tc.Expect, tc.Old, tc.New)
+		}
+	}
+}

google-beta/services/compute/resource_compute_instance.go

@@ -92,6 +92,7 @@ var (
 		"scheduling.0.min_node_cpus",
 		"scheduling.0.provisioning_model",
 		"scheduling.0.instance_termination_action",
+		"scheduling.0.termination_time",
 		"scheduling.0.availability_domain",
 		"scheduling.0.max_run_duration",
 		"scheduling.0.on_instance_stop_action",
@@ -884,6 +885,15 @@ func ResourceComputeInstance() *schema.Resource {
 							AtLeastOneOf: schedulingKeys,
 							Description:  `Specifies the action GCE should take when SPOT VM is preempted.`,
 						},
+						"termination_time": {
+							Type:         schema.TypeString,
+							Optional:     true,
+							ForceNew:     true,
+							AtLeastOneOf: schedulingKeys,
+							Description: `Specifies the timestamp, when the instance will be terminated,
+in RFC3339 text format. If specified, the instance termination action
+will be performed at the termination time.`,
+						},
 						"availability_domain": {
 							Type:         schema.TypeInt,
 							Optional:     true,

google-beta/services/compute/resource_compute_instance_from_machine_image_test.go

@@ -5,6 +5,7 @@ package compute_test
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
@@ -76,6 +77,35 @@ func TestAccComputeInstanceFromMachineImage_maxRunDuration(t *testing.T) {
 	})
 }
 
+func TestAccComputeInstanceFromMachineImage_terminationTime(t *testing.T) {
+	t.Parallel()
+
+	var instance compute.Instance
+	instanceName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	generatedInstanceName := fmt.Sprintf("tf-test-generated-%s", acctest.RandString(t, 10))
+	resourceName := "google_compute_instance_from_machine_image.foobar"
+	now := time.Now().UTC()
+	terminationTime := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 9999, now.Location()).Format(time.RFC3339)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderBetaFactories(t),
+		CheckDestroy:             testAccCheckComputeInstanceFromMachineImageDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeInstanceFromMachineImage_terminationTime(instanceName, generatedInstanceName, terminationTime),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeInstanceExists(t, resourceName, &instance),
+
+					// Check that fields were set based on the template
+					resource.TestCheckResourceAttr(resourceName, "scheduling.0.automatic_restart", "false"),
+					resource.TestCheckResourceAttr(resourceName, "scheduling.0.termination_time", terminationTime),
+				),
+			},
+		},
+	})
+}
+
 func TestAccComputeInstanceFromMachineImage_localSsdRecoveryTimeout(t *testing.T) {
 	t.Parallel()
 
@@ -699,6 +729,65 @@ resource "google_compute_instance_from_machine_image" "foobar" {
 `, instance, instance, newInstance)
 }
 
+func testAccComputeInstanceFromMachineImage_terminationTime(instance, newInstance, terminationTime string) string {
+	return fmt.Sprintf(`
+resource "google_compute_instance" "vm" {
+  provider     = google-beta
+
+  boot_disk {
+    initialize_params {
+      image = "debian-cloud/debian-12"
+    }
+  }
+
+  name         = "%s"
+  machine_type = "n1-standard-1"
+
+  network_interface {
+    network = "default"
+  }
+
+  metadata = {
+    foo = "bar"
+  }
+
+  scheduling {
+    automatic_restart = false
+    instance_termination_action = "STOP"
+    termination_time = "%s"
+  }
+
+}
+
+resource "google_compute_machine_image" "foobar" {
+  provider        = google-beta
+  name            = "%s"
+  source_instance = google_compute_instance.vm.self_link
+}
+
+resource "google_compute_instance_from_machine_image" "foobar" {
+  provider = google-beta
+  name = "%s"
+  zone = "us-central1-a"
+
+  source_machine_image = google_compute_machine_image.foobar.self_link
+
+  labels = {
+    my_key = "my_value"
+  }
+  scheduling {
+    automatic_restart = false
+    provisioning_model = "STANDARD"
+    instance_termination_action = "STOP"
+    termination_time = "%s"
+    on_instance_stop_action {
+      discard_local_ssd = true
+    }
+  }
+}
+`, instance, terminationTime, instance, newInstance, terminationTime)
+}
+
 func testAccComputeInstanceFromMachineImage_localSsdRecoveryTimeout(instance, newInstance string) string {
 	return fmt.Sprintf(`
 resource "google_compute_instance" "vm" {

google-beta/services/compute/resource_compute_instance_from_template_test.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"regexp"
 	"testing"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
@@ -397,6 +398,32 @@ func TestAccComputeInstanceFromTemplate_overrideScheduling(t *testing.T) {
 	})
 }
 
+func TestAccComputeInstanceFromTemplate_TerminationTime(t *testing.T) {
+	t.Parallel()
+
+	var instance compute.Instance
+	instanceName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	templateName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	templateDisk := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	resourceName := "google_compute_instance_from_template.inst"
+	now := time.Now().UTC()
+	terminationTime := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 9999, now.Location()).Format(time.RFC3339)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeInstanceFromTemplateDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeInstanceFromTemplate_terminationTime(templateDisk, templateName, terminationTime, instanceName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeInstanceExists(t, resourceName, &instance),
+				),
+			},
+		},
+	})
+}
+
 func TestAccComputeInstanceFromTemplate_overrideMetadataDotStartupScript(t *testing.T) {
 	var instance compute.Instance
 	instanceName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
@@ -1462,6 +1489,61 @@ resource "google_compute_instance_from_template" "inst" {
 `, templateDisk, template, instance)
 }
 
+func testAccComputeInstanceFromTemplate_terminationTime(templateDisk, template, termination_time, instance string) string {
+	return fmt.Sprintf(`
+data "google_compute_image" "my_image" {
+  family  = "debian-11"
+  project = "debian-cloud"
+}
+
+resource "google_compute_disk" "foobar" {
+  name  = "%s"
+  image = data.google_compute_image.my_image.self_link
+  size  = 10
+  type  = "pd-ssd"
+  zone  = "us-central1-a"
+}
+
+resource "google_compute_instance_template" "foobar" {
+  name         = "%s"
+  machine_type = "e2-medium"
+
+  disk {
+    source      = google_compute_disk.foobar.name
+    auto_delete = false
+    boot        = true
+  }
+
+  network_interface {
+    network = "default"
+  }
+
+  metadata = {
+    foo = "bar"
+  }
+
+  scheduling {
+    instance_termination_action = "STOP"
+    termination_time = "%s"
+  }
+
+  can_ip_forward = true
+}
+
+resource "google_compute_instance_from_template" "inst" {
+  name = "%s"
+  zone = "us-central1-a"
+
+  source_instance_template = google_compute_instance_template.foobar.self_link
+
+  scheduling {
+    instance_termination_action = "STOP"
+    termination_time = "%s"
+  }
+}
+`, templateDisk, template, termination_time, instance, termination_time)
+}
+
 func testAccComputeInstanceFromTemplate_overrideMetadataDotStartupScript(instance, template string) string {
 	return fmt.Sprintf(`
 data "google_compute_image" "my_image" {

google-beta/services/compute/resource_compute_instance_template.go

@@ -34,6 +34,7 @@ var (
 		"scheduling.0.availability_domain",
 		"scheduling.0.max_run_duration",
 		"scheduling.0.on_instance_stop_action",
+		"scheduling.0.termination_time",
 		"scheduling.0.maintenance_interval",
 		"scheduling.0.host_error_timeout_seconds",
 		"scheduling.0.graceful_shutdown",
@@ -766,6 +767,15 @@ be from 0 to 999,999,999 inclusive.`,
 								},
 							},
 						},
+						"termination_time": {
+							Type:         schema.TypeString,
+							Optional:     true,
+							ForceNew:     true,
+							AtLeastOneOf: schedulingKeys,
+							Description: `Specifies the timestamp, when the instance will be terminated,
+in RFC3339 text format. If specified, the instance termination action
+will be performed at the termination time.`,
+						},
 						"host_error_timeout_seconds": {
 							Type:        schema.TypeInt,
 							Optional:    true,