add support for network tiers (#1530)

* add support for network tiers

* Update resource_compute_forwarding_rule.go

google/compute_instance_helpers.go

@@ -49,6 +49,7 @@ func flattenAccessConfigs(accessConfigs []*computeBeta.AccessConfig) ([]map[stri
 	for i, ac := range accessConfigs {
 		flattened[i] = map[string]interface{}{
 			"nat_ip":          ac.NatIP,
+			"network_tier":    ac.NetworkTier,
 			"assigned_nat_ip": ac.NatIP,
 		}
 		if ac.SetPublicPtr {
@@ -103,8 +104,9 @@ func expandAccessConfigs(configs []interface{}) []*computeBeta.AccessConfig {
 	for i, raw := range configs {
 		data := raw.(map[string]interface{})
 		acs[i] = &computeBeta.AccessConfig{
-			Type:  "ONE_TO_ONE_NAT",
-			NatIP: data["nat_ip"].(string),
+			Type:        "ONE_TO_ONE_NAT",
+			NatIP:       data["nat_ip"].(string),
+			NetworkTier: data["network_tier"].(string),
 		}
 		if ptr, ok := data["public_ptr_domain_name"]; ok && ptr != "" {
 			acs[i].SetPublicPtr = true

google/resource_compute_address.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/helper/validation"
-	"google.golang.org/api/compute/v1"
+	computeBeta "google.golang.org/api/compute/v0.beta"
 )
 
 const (
@@ -65,6 +65,13 @@ func resourceComputeAddress() *schema.Resource {
 				Computed: true,
 			},
 
+			"network_tier": &schema.Schema{
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     true,
+				ValidateFunc: validation.StringInSlice([]string{"PREMIUM", "STANDARD"}, false),
+			},
+
 			"project": &schema.Schema{
 				Type:     schema.TypeString,
 				Optional: true,
@@ -101,14 +108,15 @@ func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) erro
 	}
 
 	// Build the address parameter
-	address := &compute.Address{
+	address := &computeBeta.Address{
 		Name:        d.Get("name").(string),
 		AddressType: d.Get("address_type").(string),
 		Subnetwork:  d.Get("subnetwork").(string),
 		Address:     d.Get("address").(string),
+		NetworkTier: d.Get("network_tier").(string),
 	}
 
-	op, err := config.clientCompute.Addresses.Insert(project, region, address).Do()
+	op, err := config.clientComputeBeta.Addresses.Insert(project, region, address).Do()
 	if err != nil {
 		return fmt.Errorf("Error creating address: %s", err)
 	}
@@ -136,7 +144,7 @@ func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error
 		return err
 	}
 
-	addr, err := config.clientCompute.Addresses.Get(
+	addr, err := config.clientComputeBeta.Addresses.Get(
 		addressId.Project, addressId.Region, addressId.Name).Do()
 	if err != nil {
 		return handleNotFoundError(err, d, fmt.Sprintf("Address %q", d.Get("name").(string)))
@@ -151,6 +159,7 @@ func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error
 	d.Set("address", addr.Address)
 	d.Set("self_link", addr.SelfLink)
 	d.Set("name", addr.Name)
+	d.Set("network_tier", addr.NetworkTier)
 	d.Set("project", addressId.Project)
 	d.Set("region", GetResourceNameFromSelfLink(addr.Region))
 
@@ -166,7 +175,7 @@ func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) erro
 	}
 
 	// Delete the address
-	op, err := config.clientCompute.Addresses.Delete(
+	op, err := config.clientComputeBeta.Addresses.Delete(
 		addressId.Project, addressId.Region, addressId.Name).Do()
 	if err != nil {
 		return fmt.Errorf("Error deleting address: %s", err)

google/resource_compute_address_test.go

@@ -101,6 +101,26 @@ func TestAccComputeAddress_basic(t *testing.T) {
 	})
 }
 
+func TestAccComputeAddress_networkTier(t *testing.T) {
+	t.Parallel()
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeAddressDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeAddress_networkTier(acctest.RandString(10)),
+			},
+			resource.TestStep{
+				ResourceName:      "google_compute_address.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func TestAccComputeAddress_internal(t *testing.T) {
 	var addr computeBeta.Address
 
@@ -273,3 +293,11 @@ resource "google_compute_address" "internal_with_subnet_and_address" {
 		i, // google_compute_address.internal_with_subnet_and_address name
 	)
 }
+
+func testAccComputeAddress_networkTier(i string) string {
+	return fmt.Sprintf(`
+resource "google_compute_address" "foobar" {
+	name         = "address-test-%s"
+	network_tier = "STANDARD"
+}`, i)
+}

google/resource_compute_forwarding_rule.go

@@ -5,6 +5,8 @@ import (
 	"log"
 
 	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/helper/validation"
+	computeBeta "google.golang.org/api/compute/v0.beta"
 	"google.golang.org/api/compute/v1"
 )
 
@@ -26,8 +28,9 @@ func resourceComputeForwardingRule() *schema.Resource {
 			},
 
 			"target": &schema.Schema{
-				Type:     schema.TypeString,
-				Optional: true,
+				Type:             schema.TypeString,
+				Optional:         true,
+				DiffSuppressFunc: compareSelfLinkRelativePaths,
 			},
 
 			"backend_service": &schema.Schema{
@@ -72,6 +75,13 @@ func resourceComputeForwardingRule() *schema.Resource {
 				DiffSuppressFunc: compareSelfLinkOrResourceName,
 			},
 
+			"network_tier": &schema.Schema{
+				Type:         schema.TypeString,
+				Optional:     true,
+				ForceNew:     true,
+				ValidateFunc: validation.StringInSlice([]string{"PREMIUM", "STANDARD"}, false),
+			},
+
 			"port_range": &schema.Schema{
 				Type:             schema.TypeString,
 				Optional:         true,
@@ -147,7 +157,7 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 		ports = append(ports, v.(string))
 	}
 
-	frule := &compute.ForwardingRule{
+	frule := &computeBeta.ForwardingRule{
 		BackendService:      d.Get("backend_service").(string),
 		IPAddress:           d.Get("ip_address").(string),
 		IPProtocol:          d.Get("ip_protocol").(string),
@@ -155,14 +165,15 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 		LoadBalancingScheme: d.Get("load_balancing_scheme").(string),
 		Name:                d.Get("name").(string),
 		Network:             network.RelativeLink(),
+		NetworkTier:         d.Get("network_tier").(string),
 		PortRange:           d.Get("port_range").(string),
 		Ports:               ports,
 		Subnetwork:          subnetwork.RelativeLink(),
-		Target:              d.Get("target").(string),
+		Target:              ConvertSelfLinkToV1(d.Get("target").(string)),
 	}
 
 	log.Printf("[DEBUG] ForwardingRule insert request: %#v", frule)
-	op, err := config.clientCompute.ForwardingRules.Insert(
+	op, err := config.clientComputeBeta.ForwardingRules.Insert(
 		project, region, frule).Do()
 	if err != nil {
 		return fmt.Errorf("Error creating ForwardingRule: %s", err)
@@ -171,7 +182,7 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 	// It probably maybe worked, so store the ID now
 	d.SetId(frule.Name)
 
-	err = computeOperationWait(config.clientCompute, op, project, "Creating Fowarding Rule")
+	err = computeSharedOperationWait(config.clientCompute, op, project, "Creating Fowarding Rule")
 	if err != nil {
 		return err
 	}
@@ -229,7 +240,7 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
 		return err
 	}
 
-	frule, err := config.clientCompute.ForwardingRules.Get(
+	frule, err := config.clientComputeBeta.ForwardingRules.Get(
 		project, region, d.Id()).Do()
 	if err != nil {
 		return handleNotFoundError(err, d, fmt.Sprintf("Forwarding Rule %q", d.Get("name").(string)))
@@ -241,6 +252,7 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
 	d.Set("description", frule.Description)
 	d.Set("load_balancing_scheme", frule.LoadBalancingScheme)
 	d.Set("network", frule.Network)
+	d.Set("network_tier", frule.NetworkTier)
 	d.Set("port_range", frule.PortRange)
 	d.Set("ports", frule.Ports)
 	d.Set("project", project)

google/resource_compute_forwarding_rule_test.go

@@ -118,6 +118,30 @@ func TestAccComputeForwardingRule_internalLoadBalancing(t *testing.T) {
 	})
 }
 
+func TestAccComputeForwardingRule_networkTier(t *testing.T) {
+	t.Parallel()
+
+	poolName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+	ruleName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeForwardingRuleDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeForwardingRule_networkTier(poolName, ruleName),
+			},
+
+			resource.TestStep{
+				ResourceName:      "google_compute_forwarding_rule.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testAccCheckComputeForwardingRuleDestroy(s *terraform.State) error {
 	config := testAccProvider.Meta().(*Config)
 
@@ -254,3 +278,22 @@ resource "google_compute_forwarding_rule" "foobar2" {
 }
 `, serviceName, checkName, networkName, ruleName1, networkName, ruleName2)
 }
+
+func testAccComputeForwardingRule_networkTier(poolName, ruleName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_target_pool" "foobar-tp" {
+  description = "Resource created for Terraform acceptance testing"
+  instances   = ["us-central1-a/foo", "us-central1-b/bar"]
+  name        = "%s"
+}
+resource "google_compute_forwarding_rule" "foobar" {
+  description = "Resource created for Terraform acceptance testing"
+  ip_protocol = "UDP"
+  name        = "%s"
+  port_range  = "80-81"
+  target      = "${google_compute_target_pool.foobar-tp.self_link}"
+
+  network_tier = "STANDARD"
+}
+`, poolName, ruleName)
+}

google/resource_compute_instance.go

@@ -355,6 +355,12 @@ func resourceComputeInstance() *schema.Resource {
 										Computed: true,
 									},
 
+									"network_tier": &schema.Schema{
+										Type:         schema.TypeString,
+										Optional:     true,
+										ValidateFunc: validation.StringInSlice([]string{"PREMIUM", "STANDARD"}, false),
+									},
+
 									// It's unclear why this field exists, as
 									// nat_ip can be both optional and computed.
 									// Consider deprecating it.
@@ -1096,20 +1102,22 @@ func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) err
 			accessConfigsCount := d.Get(prefix + ".access_config.#").(int)
 			for j := 0; j < accessConfigsCount; j++ {
 				acPrefix := fmt.Sprintf("%s.access_config.%d", prefix, j)
-				ac := &compute.AccessConfig{
-					Type:  "ONE_TO_ONE_NAT",
-					NatIP: d.Get(acPrefix + ".nat_ip").(string),
+				ac := &computeBeta.AccessConfig{
+					Type:        "ONE_TO_ONE_NAT",
+					NatIP:       d.Get(acPrefix + ".nat_ip").(string),
+					NetworkTier: d.Get(acPrefix + ".network_tier").(string),
 				}
 				if ptr, ok := d.GetOk(acPrefix + ".public_ptr_domain_name"); ok && ptr != "" {
 					ac.SetPublicPtr = true
 					ac.PublicPtrDomainName = ptr.(string)
 				}
-				op, err := config.clientCompute.Instances.AddAccessConfig(
+
+				op, err := config.clientComputeBeta.Instances.AddAccessConfig(
 					project, zone, d.Id(), networkName, ac).Do()
 				if err != nil {
 					return fmt.Errorf("Error adding new access_config: %s", err)
 				}
-				opErr := computeOperationWaitTime(config.clientCompute, op, project, "new access_config to add", int(d.Timeout(schema.TimeoutUpdate).Minutes()))
+				opErr := computeSharedOperationWaitTime(config.clientCompute, op, project, int(d.Timeout(schema.TimeoutUpdate).Minutes()), "new access_config to add")
 				if opErr != nil {
 					return opErr
 				}

google/resource_compute_instance_template.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/helper/validation"
 	computeBeta "google.golang.org/api/compute/v0.beta"
 	"google.golang.org/api/googleapi"
 )
@@ -237,6 +238,11 @@ func resourceComputeInstanceTemplate() *schema.Resource {
 										ForceNew: true,
 										Computed: true,
 									},
+									"network_tier": &schema.Schema{
+										Type:         schema.TypeString,
+										Optional:     true,
+										ValidateFunc: validation.StringInSlice([]string{"PREMIUM", "STANDARD"}, false),
+									},
 									// Instance templates will never have an
 									// 'assigned NAT IP', but we need this in
 									// the schema to allow us to share flatten

google/resource_compute_instance_template_test.go

@@ -99,6 +99,26 @@ func TestAccComputeInstanceTemplate_IP(t *testing.T) {
 	})
 }
 
+func TestAccComputeInstanceTemplate_networkTier(t *testing.T) {
+	t.Parallel()
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeInstanceTemplateDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeInstanceTemplate_networkTier(),
+			},
+			resource.TestStep{
+				ResourceName:      "google_compute_instance_template.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func TestAccComputeInstanceTemplate_networkIP(t *testing.T) {
 	t.Parallel()
 
@@ -804,6 +824,25 @@ resource "google_compute_instance_template" "foobar" {
 }`, acctest.RandString(10), acctest.RandString(10))
 }
 
+func testAccComputeInstanceTemplate_networkTier() string {
+	return fmt.Sprintf(`
+resource "google_compute_instance_template" "foobar" {
+	name = "instancet-test-%s"
+	machine_type = "n1-standard-1"
+
+	disk {
+		source_image = "debian-8-jessie-v20160803"
+	}
+
+	network_interface {
+		network = "default"
+		access_config {
+			network_tier = "STANDARD"
+		}
+	}
+}`, acctest.RandString(10))
+}
+
 func testAccComputeInstanceTemplate_networkIP(networkIP string) string {
 	return fmt.Sprintf(`
 resource "google_compute_instance_template" "foobar" {

google/resource_compute_instance_test.go

@@ -243,6 +243,29 @@ func TestAccComputeInstance_GenerateIP(t *testing.T) {
 	})
 }
 
+func TestAccComputeInstance_networkTier(t *testing.T) {
+	var instance compute.Instance
+	var instanceName = fmt.Sprintf("instance-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeInstanceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeInstance_networkTier(instanceName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeInstanceExists(
+						"google_compute_instance.foobar", &instance),
+					testAccCheckComputeInstanceAccessConfigHasIP(&instance),
+					testAccCheckComputeInstanceHasAssignedIP,
+				),
+			},
+			computeInstanceImportStep("us-central1-a", instanceName, []string{}),
+		},
+	})
+}
+
 func TestAccComputeInstance_diskEncryption(t *testing.T) {
 	t.Parallel()
 
@@ -1855,6 +1878,29 @@ resource "google_compute_instance" "foobar" {
 `, instance)
 }
 
+func testAccComputeInstance_networkTier(instance string) string {
+	return fmt.Sprintf(`
+resource "google_compute_instance" "foobar" {
+	name         = "%s"
+	machine_type = "n1-standard-1"
+	zone         = "us-central1-a"
+
+	boot_disk {
+		initialize_params{
+			image = "debian-8-jessie-v20160803"
+		}
+	}
+
+	network_interface {
+		network = "default"
+		access_config {
+			network_tier = "STANDARD"
+		}
+	}
+}
+`, instance)
+}
+
 func testAccComputeInstance_disks_encryption(bootEncryptionKey string, diskNameToEncryptionKey map[string]*compute.CustomerEncryptionKey, instance string) string {
 	diskNames := []string{}
 	for k, _ := range diskNameToEncryptionKey {