Add beta Serverless Connector features (hashicorp#4568) (hashicorp#3042)

Co-authored-by: upodroid <[email protected]> Signed-off-by: Modular Magician <[email protected]> Co-authored-by: upodroid <[email protected]>
jcanseco · Mar 10, 2021 · a376341 · a376341
1 parent 8e07b18
commit a376341
Show file tree

Hide file tree

Showing 7 changed files with 323 additions and 19 deletions.
diff --git a/.changelog/4568.txt b/.changelog/4568.txt
@@ -0,0 +1,3 @@
+```release-note:enhancement
+vpcaccess: added `subnet`, `machine_type` beta fields to `google_vpc_access_connector`
+```
diff --git a/google-beta/config.go b/google-beta/config.go
@@ -246,7 +246,7 @@ var SpannerDefaultBasePath = "https://spanner.googleapis.com/v1/"
 var SQLDefaultBasePath = "https://sqladmin.googleapis.com/sql/v1beta4/"
 var StorageDefaultBasePath = "https://storage.googleapis.com/storage/v1/"
 var TPUDefaultBasePath = "https://tpu.googleapis.com/v1/"
-var VPCAccessDefaultBasePath = "https://vpcaccess.googleapis.com/v1/"
+var VPCAccessDefaultBasePath = "https://vpcaccess.googleapis.com/v1beta1/"
 var WorkflowsDefaultBasePath = "https://workflows.googleapis.com/v1beta/"
 
 var DefaultClientScopes = []string{

diff --git a/google-beta/resource_vpc_access_connector.go b/google-beta/resource_vpc_access_connector.go
@@ -41,23 +41,32 @@ func resourceVPCAccessConnector() *schema.Resource {
 		},
 
 		Schema: map[string]*schema.Schema{
-			"ip_cidr_range": {
-				Type:        schema.TypeString,
-				Required:    true,
-				ForceNew:    true,
-				Description: `The range of internal addresses that follows RFC 4632 notation. Example: '10.132.0.0/28'.`,
-			},
 			"name": {
 				Type:        schema.TypeString,
 				Required:    true,
 				ForceNew:    true,
 				Description: `The name of the resource (Max 25 characters).`,
 			},
-			"network": {
+			"ip_cidr_range": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     true,
+				Description:  `The range of internal addresses that follows RFC 4632 notation. Example: '10.132.0.0/28'.`,
+				RequiredWith: []string{"network"},
+			},
+			"machine_type": {
 				Type:        schema.TypeString,
-				Required:    true,
+				Optional:    true,
+				ForceNew:    true,
+				Description: `Machine type of VM Instance underlying connector. Default is e2-micro`,
+				Default:     "e2-micro",
+			},
+			"max_instances": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Optional:    true,
 				ForceNew:    true,
-				Description: `Name of a VPC network.`,
+				Description: `Maximum value of instances in autoscaling group underlying the connector.`,
 			},
 			"max_throughput": {
 				Type:         schema.TypeInt,
@@ -67,6 +76,13 @@ func resourceVPCAccessConnector() *schema.Resource {
 				Description:  `Maximum throughput of the connector in Mbps, must be greater than 'min_throughput'. Default is 1000.`,
 				Default:      1000,
 			},
+			"min_instances": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Optional:    true,
+				ForceNew:    true,
+				Description: `Minimum value of instances in autoscaling group underlying the connector.`,
+			},
 			"min_throughput": {
 				Type:         schema.TypeInt,
 				Optional:     true,
@@ -75,13 +91,46 @@ func resourceVPCAccessConnector() *schema.Resource {
 				Description:  `Minimum throughput of the connector in Mbps. Default and min is 200.`,
 				Default:      200,
 			},
+			"network": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     true,
+				Description:  `Name of the VPC network. Required if 'ip_cidr_range' is set.`,
+				ExactlyOneOf: []string{"network", "subnet.0.name"},
+			},
 			"region": {
 				Type:        schema.TypeString,
 				Computed:    true,
 				Optional:    true,
 				ForceNew:    true,
 				Description: `Region where the VPC Access connector resides. If it is not provided, the provider region is used.`,
 			},
+			"subnet": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				ForceNew:    true,
+				Description: `The subnet in which to house the connector`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:     schema.TypeString,
+							Optional: true,
+							ForceNew: true,
+							Description: `Subnet name (relative, not fully qualified). E.g. if the full subnet selfLink is
+https://compute.googleapis.com/compute/v1/projects/{project}/regions/{region}/subnetworks/{subnetName} the correct input for this field would be {subnetName}"`,
+							ExactlyOneOf: []string{"network", "subnet.0.name"},
+						},
+						"project_id": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Optional:    true,
+							ForceNew:    true,
+							Description: `Project in which the subnet exists. If not set, this project is assumed to be the project for which the connector create request was issued.`,
+						},
+					},
+				},
+			},
 			"self_link": {
 				Type:        schema.TypeString,
 				Computed:    true,
@@ -129,18 +178,42 @@ func resourceVPCAccessConnectorCreate(d *schema.ResourceData, meta interface{})
 	} else if v, ok := d.GetOkExists("ip_cidr_range"); !isEmptyValue(reflect.ValueOf(ipCidrRangeProp)) && (ok || !reflect.DeepEqual(v, ipCidrRangeProp)) {
 		obj["ipCidrRange"] = ipCidrRangeProp
 	}
+	machineTypeProp, err := expandVPCAccessConnectorMachineType(d.Get("machine_type"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("machine_type"); !isEmptyValue(reflect.ValueOf(machineTypeProp)) && (ok || !reflect.DeepEqual(v, machineTypeProp)) {
+		obj["machineType"] = machineTypeProp
+	}
 	minThroughputProp, err := expandVPCAccessConnectorMinThroughput(d.Get("min_throughput"), d, config)
 	if err != nil {
 		return err
 	} else if v, ok := d.GetOkExists("min_throughput"); !isEmptyValue(reflect.ValueOf(minThroughputProp)) && (ok || !reflect.DeepEqual(v, minThroughputProp)) {
 		obj["minThroughput"] = minThroughputProp
 	}
+	minInstancesProp, err := expandVPCAccessConnectorMinInstances(d.Get("min_instances"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("min_instances"); !isEmptyValue(reflect.ValueOf(minInstancesProp)) && (ok || !reflect.DeepEqual(v, minInstancesProp)) {
+		obj["minInstances"] = minInstancesProp
+	}
+	maxInstancesProp, err := expandVPCAccessConnectorMaxInstances(d.Get("max_instances"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("max_instances"); !isEmptyValue(reflect.ValueOf(maxInstancesProp)) && (ok || !reflect.DeepEqual(v, maxInstancesProp)) {
+		obj["maxInstances"] = maxInstancesProp
+	}
 	maxThroughputProp, err := expandVPCAccessConnectorMaxThroughput(d.Get("max_throughput"), d, config)
 	if err != nil {
 		return err
 	} else if v, ok := d.GetOkExists("max_throughput"); !isEmptyValue(reflect.ValueOf(maxThroughputProp)) && (ok || !reflect.DeepEqual(v, maxThroughputProp)) {
 		obj["maxThroughput"] = maxThroughputProp
 	}
+	subnetProp, err := expandVPCAccessConnectorSubnet(d.Get("subnet"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("subnet"); !isEmptyValue(reflect.ValueOf(subnetProp)) && (ok || !reflect.DeepEqual(v, subnetProp)) {
+		obj["subnet"] = subnetProp
+	}
 
 	obj, err = resourceVPCAccessConnectorEncoder(d, meta, obj)
 	if err != nil {
@@ -277,12 +350,24 @@ func resourceVPCAccessConnectorRead(d *schema.ResourceData, meta interface{}) er
 	if err := d.Set("state", flattenVPCAccessConnectorState(res["state"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Connector: %s", err)
 	}
+	if err := d.Set("machine_type", flattenVPCAccessConnectorMachineType(res["machineType"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Connector: %s", err)
+	}
 	if err := d.Set("min_throughput", flattenVPCAccessConnectorMinThroughput(res["minThroughput"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Connector: %s", err)
 	}
+	if err := d.Set("min_instances", flattenVPCAccessConnectorMinInstances(res["minInstances"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Connector: %s", err)
+	}
+	if err := d.Set("max_instances", flattenVPCAccessConnectorMaxInstances(res["maxInstances"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Connector: %s", err)
+	}
 	if err := d.Set("max_throughput", flattenVPCAccessConnectorMaxThroughput(res["maxThroughput"], d, config)); err != nil {
 		return fmt.Errorf("Error reading Connector: %s", err)
 	}
+	if err := d.Set("subnet", flattenVPCAccessConnectorSubnet(res["subnet"], d, config)); err != nil {
+		return fmt.Errorf("Error reading Connector: %s", err)
+	}
 
 	return nil
 }
@@ -372,6 +457,10 @@ func flattenVPCAccessConnectorState(v interface{}, d *schema.ResourceData, confi
 	return v
 }
 
+func flattenVPCAccessConnectorMachineType(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	return v
+}
+
 func flattenVPCAccessConnectorMinThroughput(v interface{}, d *schema.ResourceData, config *Config) interface{} {
 	// Handles the string fixed64 format
 	if strVal, ok := v.(string); ok {
@@ -389,6 +478,40 @@ func flattenVPCAccessConnectorMinThroughput(v interface{}, d *schema.ResourceDat
 	return v // let terraform core handle it otherwise
 }
 
+func flattenVPCAccessConnectorMinInstances(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
+func flattenVPCAccessConnectorMaxInstances(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
 func flattenVPCAccessConnectorMaxThroughput(v interface{}, d *schema.ResourceData, config *Config) interface{} {
 	// Handles the string fixed64 format
 	if strVal, ok := v.(string); ok {
@@ -406,6 +529,29 @@ func flattenVPCAccessConnectorMaxThroughput(v interface{}, d *schema.ResourceDat
 	return v // let terraform core handle it otherwise
 }
 
+func flattenVPCAccessConnectorSubnet(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["name"] =
+		flattenVPCAccessConnectorSubnetName(original["name"], d, config)
+	transformed["project_id"] =
+		flattenVPCAccessConnectorSubnetProjectId(original["projectId"], d, config)
+	return []interface{}{transformed}
+}
+func flattenVPCAccessConnectorSubnetName(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	return v
+}
+
+func flattenVPCAccessConnectorSubnetProjectId(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	return v
+}
+
 func expandVPCAccessConnectorName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
 	return v, nil
 }
@@ -418,14 +564,60 @@ func expandVPCAccessConnectorIpCidrRange(v interface{}, d TerraformResourceData,
 	return v, nil
 }
 
+func expandVPCAccessConnectorMachineType(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandVPCAccessConnectorMinThroughput(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
 	return v, nil
 }
 
+func expandVPCAccessConnectorMinInstances(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandVPCAccessConnectorMaxInstances(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandVPCAccessConnectorMaxThroughput(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
 	return v, nil
 }
 
+func expandVPCAccessConnectorSubnet(v interface{}, d TerraformResourceData, config *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{})
+
+	transformedName, err := expandVPCAccessConnectorSubnetName(original["name"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedName); val.IsValid() && !isEmptyValue(val) {
+		transformed["name"] = transformedName
+	}
+
+	transformedProjectId, err := expandVPCAccessConnectorSubnetProjectId(original["project_id"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedProjectId); val.IsValid() && !isEmptyValue(val) {
+		transformed["projectId"] = transformedProjectId
+	}
+
+	return transformed, nil
+}
+
+func expandVPCAccessConnectorSubnetName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandVPCAccessConnectorSubnetProjectId(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
 func resourceVPCAccessConnectorEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
 	delete(obj, "name")
 	return obj, nil

diff --git a/google-beta/resource_vpc_access_connector_generated_test.go b/google-beta/resource_vpc_access_connector_generated_test.go
@@ -61,6 +61,55 @@ resource "google_vpc_access_connector" "connector" {
 `, context)
 }
 
+func TestAccVPCAccessConnector_vpcAccessConnectorSharedVPCExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": randString(t, 10),
+	}
+
+	vcrTest(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProvidersOiCS,
+		ExternalProviders: map[string]resource.ExternalProvider{
+			"random": {},
+		},
+		CheckDestroy: testAccCheckVPCAccessConnectorDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccVPCAccessConnector_vpcAccessConnectorSharedVPCExample(context),
+			},
+		},
+	})
+}
+
+func testAccVPCAccessConnector_vpcAccessConnectorSharedVPCExample(context map[string]interface{}) string {
+	return Nprintf(`
+resource "google_vpc_access_connector" "connector" {
+  provider      = google-beta
+  name          = "tf-test-vpc-con%{random_suffix}"
+  subnet {
+    name = google_compute_subnetwork.custom_test.name
+  }
+  machine_type = "e2-standard-4"
+}
+
+resource "google_compute_subnetwork" "custom_test" {
+  provider      = google-beta
+  name          = "tf-test-vpc-con%{random_suffix}"
+  ip_cidr_range = "10.2.0.0/28"
+  region        = "us-central1"
+  network       = google_compute_network.custom_test.id
+}
+
+resource "google_compute_network" "custom_test" {
+  provider                = google-beta
+  name                    = "tf-test-vpc-con%{random_suffix}"
+  auto_create_subnetworks = false
+}
+`, context)
+}
+
 func testAccCheckVPCAccessConnectorDestroyProducer(t *testing.T) func(s *terraform.State) error {
 	return func(s *terraform.State) error {
 		for name, rs := range s.RootModule().Resources {