Main (#13943) (#22818)

[upstream:7f199d95bafc97b9f2a7533f486f21e5f051ea96]

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

Author: modular-magician

.changelog/13943.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+alloydb: added `activation_policy` field to `google_alloydb_instance` resource
+```

google/services/alloydb/resource_alloydb_instance.go

@@ -84,6 +84,20 @@ Example: {instance_type = google_alloydb_cluster.<secondary_cluster_name>.cluste
 If the instance type is SECONDARY, the terraform delete instance operation does not delete the secondary instance but abandons it instead.
 Use deletion_policy = "FORCE" in the associated secondary cluster and delete the cluster forcefully to delete the secondary cluster as well its associated secondary instance.
 Users can undo the delete secondary instance action by importing the deleted secondary instance by calling terraform import. Possible values: ["PRIMARY", "READ_POOL", "SECONDARY"]`,
+			},
+			"activation_policy": {
+				Type:         schema.TypeString,
+				Computed:     true,
+				Optional:     true,
+				ValidateFunc: verify.ValidateEnum([]string{"ACTIVATION_POLICY_UNSPECIFIED", "ALWAYS", "NEVER", ""}),
+				Description: `'Specifies whether an instance needs to spin up. Once the instance is
+active, the activation policy can be updated to the 'NEVER' to stop the
+instance. Likewise, the activation policy can be updated to 'ALWAYS' to
+start the instance.
+There are restrictions around when an instance can/cannot be activated (for
+example, a read pool instance should be stopped before stopping primary
+etc.). Please refer to the API documentation for more details.
+Possible values are: 'ACTIVATION_POLICY_UNSPECIFIED', 'ALWAYS', 'NEVER'.' Possible values: ["ACTIVATION_POLICY_UNSPECIFIED", "ALWAYS", "NEVER"]`,
 			},
 			"annotations": {
 				Type:     schema.TypeMap,
@@ -477,6 +491,12 @@ func resourceAlloydbInstanceCreate(d *schema.ResourceData, meta interface{}) err
 	} else if v, ok := d.GetOkExists("availability_type"); !tpgresource.IsEmptyValue(reflect.ValueOf(availabilityTypeProp)) && (ok || !reflect.DeepEqual(v, availabilityTypeProp)) {
 		obj["availabilityType"] = availabilityTypeProp
 	}
+	activationPolicyProp, err := expandAlloydbInstanceActivationPolicy(d.Get("activation_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("activation_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(activationPolicyProp)) && (ok || !reflect.DeepEqual(v, activationPolicyProp)) {
+		obj["activationPolicy"] = activationPolicyProp
+	}
 	instanceTypeProp, err := expandAlloydbInstanceInstanceType(d.Get("instance_type"), d, config)
 	if err != nil {
 		return err
@@ -652,6 +672,9 @@ func resourceAlloydbInstanceRead(d *schema.ResourceData, meta interface{}) error
 	if err := d.Set("availability_type", flattenAlloydbInstanceAvailabilityType(res["availabilityType"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Instance: %s", err)
 	}
+	if err := d.Set("activation_policy", flattenAlloydbInstanceActivationPolicy(res["activationPolicy"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Instance: %s", err)
+	}
 	if err := d.Set("instance_type", flattenAlloydbInstanceInstanceType(res["instanceType"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Instance: %s", err)
 	}
@@ -730,6 +753,12 @@ func resourceAlloydbInstanceUpdate(d *schema.ResourceData, meta interface{}) err
 	} else if v, ok := d.GetOkExists("availability_type"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, availabilityTypeProp)) {
 		obj["availabilityType"] = availabilityTypeProp
 	}
+	activationPolicyProp, err := expandAlloydbInstanceActivationPolicy(d.Get("activation_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("activation_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, activationPolicyProp)) {
+		obj["activationPolicy"] = activationPolicyProp
+	}
 	queryInsightsConfigProp, err := expandAlloydbInstanceQueryInsightsConfig(d.Get("query_insights_config"), d, config)
 	if err != nil {
 		return err
@@ -804,6 +833,10 @@ func resourceAlloydbInstanceUpdate(d *schema.ResourceData, meta interface{}) err
 		updateMask = append(updateMask, "availabilityType")
 	}
 
+	if d.HasChange("activation_policy") {
+		updateMask = append(updateMask, "activationPolicy")
+	}
+
 	if d.HasChange("query_insights_config") {
 		updateMask = append(updateMask, "queryInsightsConfig")
 	}
@@ -1033,6 +1066,10 @@ func flattenAlloydbInstanceAvailabilityType(v interface{}, d *schema.ResourceDat
 	return v
 }
 
+func flattenAlloydbInstanceActivationPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenAlloydbInstanceInstanceType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
@@ -1402,6 +1439,10 @@ func expandAlloydbInstanceAvailabilityType(v interface{}, d tpgresource.Terrafor
 	return v, nil
 }
 
+func expandAlloydbInstanceActivationPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandAlloydbInstanceInstanceType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }

google/services/alloydb/resource_alloydb_instance_generated_meta.yaml

@@ -5,6 +5,7 @@ api_service_name: 'alloydb.googleapis.com'
 api_version: 'v1'
 api_resource_type_kind: 'Instance'
 fields:
+  - field: 'activation_policy'
   - field: 'annotations'
   - field: 'availability_type'
   - field: 'client_connection_config.require_connectors'

google/services/alloydb/resource_alloydb_instance_test.go

@@ -130,6 +130,99 @@ func TestAccAlloydbInstance_createInstanceWithMandatoryFields(t *testing.T) {
 	})
 }
 
+// This test passes if we are able to create a primary instance STOP it and then START it back again
+func TestAccAlloydbInstance_stopstart(t *testing.T) {
+	t.Parallel()
+
+	suffix := acctest.RandString(t, 10)
+	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "alloydbinstance-clientconnectionconfig")
+
+	context := map[string]interface{}{
+		"random_suffix": suffix,
+		"network_name":  networkName,
+	}
+
+	contextStop := map[string]interface{}{
+		"random_suffix":     suffix,
+		"network_name":      networkName,
+		"activation_policy": "NEVER",
+	}
+
+	contextStart := map[string]interface{}{
+		"random_suffix":     suffix,
+		"network_name":      networkName,
+		"activation_policy": "ALWAYS",
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckAlloydbInstanceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAlloydbInstance_createInstanceWithMandatoryFields(context),
+			},
+			{
+				ResourceName:            "google_alloydb_instance.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"cluster", "instance_id", "reconciling", "update_time"},
+			},
+			{
+				Config: testAccAlloydbInstance_updateActivationPolicy(contextStop),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("google_alloydb_instance.default", "activation_policy", "NEVER"),
+					resource.TestCheckResourceAttr("google_alloydb_instance.default", "state", "STOPPED"),
+				),
+			},
+			{
+				ResourceName:            "google_alloydb_instance.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"cluster", "instance_id", "reconciling", "update_time", "labels", "terraform_labels"},
+			},
+			{
+				Config: testAccAlloydbInstance_updateActivationPolicy(contextStart),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("google_alloydb_instance.default", "activation_policy", "ALWAYS"),
+					resource.TestCheckResourceAttr("google_alloydb_instance.default", "state", "READY"),
+				),
+			},
+			{
+				ResourceName:            "google_alloydb_instance.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"cluster", "instance_id", "reconciling", "update_time", "labels", "terraform_labels"},
+			},
+		},
+	})
+}
+
+func testAccAlloydbInstance_updateActivationPolicy(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_alloydb_instance" "default" {
+  cluster       = google_alloydb_cluster.default.name
+  instance_id   = "tf-test-alloydb-instance%{random_suffix}"
+  instance_type = "PRIMARY"
+  activation_policy = "%{activation_policy}"
+}
+
+resource "google_alloydb_cluster" "default" {
+  cluster_id = "tf-test-alloydb-cluster%{random_suffix}"
+  location   = "us-central1"
+  network_config {
+    network = data.google_compute_network.default.id
+  }
+}
+
+data "google_project" "project" {}
+
+data "google_compute_network" "default" {
+  name = "%{network_name}"
+}
+`, context)
+}
+
 func testAccAlloydbInstance_createInstanceWithMandatoryFields(context map[string]interface{}) string {
 	return acctest.Nprintf(`
 resource "google_alloydb_instance" "default" {

website/docs/r/alloydb_instance.html.markdown

@@ -230,6 +230,18 @@ The following arguments are supported:
   Possible values are: `AVAILABILITY_TYPE_UNSPECIFIED`, `ZONAL`, `REGIONAL`.'
   Possible values are: `AVAILABILITY_TYPE_UNSPECIFIED`, `ZONAL`, `REGIONAL`.
 
+* `activation_policy` -
+  (Optional)
+  'Specifies whether an instance needs to spin up. Once the instance is
+  active, the activation policy can be updated to the `NEVER` to stop the
+  instance. Likewise, the activation policy can be updated to `ALWAYS` to
+  start the instance.
+  There are restrictions around when an instance can/cannot be activated (for
+  example, a read pool instance should be stopped before stopping primary
+  etc.). Please refer to the API documentation for more details.
+  Possible values are: `ACTIVATION_POLICY_UNSPECIFIED`, `ALWAYS`, `NEVER`.'
+  Possible values are: `ACTIVATION_POLICY_UNSPECIFIED`, `ALWAYS`, `NEVER`.
+
 * `query_insights_config` -
   (Optional)
   Configuration for query insights.