Merge branch 'master' of /home/ubuntu/terraform-vendor

google/resource_compute_backend_service.go

@@ -139,6 +139,12 @@ func resourceComputeBackendService() *schema.Resource {
 				Optional: true,
 				Computed: true,
 			},
+
+			"connection_draining_timeout_sec": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+				Default:  0,
+			},
 		},
 	}
 }
@@ -185,6 +191,14 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{
 		service.EnableCDN = v.(bool)
 	}
 
+	if v, ok := d.GetOk("connection_draining_timeout_sec"); ok {
+		connectionDraining := &compute.ConnectionDraining{
+			DrainingTimeoutSec: int64(v.(int)),
+		}
+
+		service.ConnectionDraining = connectionDraining
+	}
+
 	project, err := getProject(d, config)
 	if err != nil {
 		return err
@@ -235,8 +249,9 @@ func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{})
 	d.Set("timeout_sec", service.TimeoutSec)
 	d.Set("fingerprint", service.Fingerprint)
 	d.Set("self_link", service.SelfLink)
-
 	d.Set("backend", flattenBackends(service.Backends))
+	d.Set("connection_draining_timeout_sec", service.ConnectionDraining.DrainingTimeoutSec)
+
 	d.Set("health_checks", service.HealthChecks)
 
 	return nil
@@ -279,6 +294,14 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{
 		service.TimeoutSec = int64(v.(int))
 	}
 
+	if d.HasChange("connection_draining_timeout_sec") {
+		connectionDraining := &compute.ConnectionDraining{
+			DrainingTimeoutSec: int64(d.Get("connection_draining_timeout_sec").(int)),
+		}
+
+		service.ConnectionDraining = connectionDraining
+	}
+
 	if d.HasChange("session_affinity") {
 		service.SessionAffinity = d.Get("session_affinity").(string)
 	}

google/resource_compute_backend_service_test.go

@@ -114,6 +114,63 @@ func TestAccComputeBackendService_withBackendAndUpdate(t *testing.T) {
 	}
 }
 
+func TestAccComputeBackendService_withConnectionDraining(t *testing.T) {
+	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	var svc compute.BackendService
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeBackendService_withConnectionDraining(serviceName, checkName, 10),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeBackendServiceExists(
+						"google_compute_backend_service.foobar", &svc),
+				),
+			},
+		},
+	})
+
+	if svc.ConnectionDraining.DrainingTimeoutSec != 10 {
+		t.Errorf("Expected ConnectionDraining.DrainingTimeoutSec == 10, got %d", svc.ConnectionDraining.DrainingTimeoutSec)
+	}
+}
+
+func TestAccComputeBackendService_withConnectionDrainingAndUpdate(t *testing.T) {
+	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	var svc compute.BackendService
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeBackendServiceDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeBackendService_withConnectionDraining(serviceName, checkName, 10),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeBackendServiceExists(
+						"google_compute_backend_service.foobar", &svc),
+				),
+			},
+			resource.TestStep{
+				Config: testAccComputeBackendService_basic(serviceName, checkName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeBackendServiceExists(
+						"google_compute_backend_service.foobar", &svc),
+				),
+			},
+		},
+	})
+
+	if svc.ConnectionDraining.DrainingTimeoutSec != 0 {
+		t.Errorf("Expected ConnectionDraining.DrainingTimeoutSec == 0, got %d", svc.ConnectionDraining.DrainingTimeoutSec)
+	}
+}
+
 func testAccCheckComputeBackendServiceDestroy(s *terraform.State) error {
 	config := testAccProvider.Meta().(*Config)
 
@@ -342,3 +399,20 @@ resource "google_compute_http_health_check" "zero" {
 }
 `, serviceName, affinityName, checkName)
 }
+
+func testAccComputeBackendService_withConnectionDraining(serviceName, checkName string, drainingTimeout int64) string {
+	return fmt.Sprintf(`
+resource "google_compute_backend_service" "foobar" {
+  name          = "%s"
+  health_checks = ["${google_compute_http_health_check.zero.self_link}"]
+  connection_draining_timeout_sec = %v
+}
+
+resource "google_compute_http_health_check" "zero" {
+  name               = "%s"
+  request_path       = "/"
+  check_interval_sec = 1
+  timeout_sec        = 1
+}
+`, serviceName, drainingTimeout, checkName)
+}

google/resource_compute_instance_group.go

@@ -67,7 +67,9 @@ func resourceComputeInstanceGroup() *schema.Resource {
 
 			"network": {
 				Type:     schema.TypeString,
+				Optional: true,
 				Computed: true,
+				ForceNew: true,
 			},
 
 			"project": {
@@ -129,6 +131,10 @@ func resourceComputeInstanceGroupCreate(d *schema.ResourceData, meta interface{}
 		instanceGroup.NamedPorts = getNamedPorts(v.([]interface{}))
 	}
 
+	if v, ok := d.GetOk("network"); ok {
+		instanceGroup.Network = v.(string)
+	}
+
 	log.Printf("[DEBUG] InstanceGroup insert request: %#v", instanceGroup)
 	op, err := config.clientCompute.InstanceGroups.Insert(
 		project, d.Get("zone").(string), instanceGroup).Do()

google/resource_compute_instance_group_test.go

@@ -90,6 +90,32 @@ func TestAccComputeInstanceGroup_outOfOrderInstances(t *testing.T) {
 	})
 }
 
+func TestAccComputeInstanceGroup_network(t *testing.T) {
+	var instanceGroup compute.InstanceGroup
+	var instanceName = fmt.Sprintf("instancegroup-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccComputeInstanceGroup_destroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeInstanceGroup_network(instanceName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccComputeInstanceGroup_exists(
+						"google_compute_instance_group.with_instance", &instanceGroup),
+					testAccComputeInstanceGroup_hasCorrectNetwork(
+						"google_compute_instance_group.with_instance", "google_compute_network.ig_network", &instanceGroup),
+					testAccComputeInstanceGroup_exists(
+						"google_compute_instance_group.without_instance", &instanceGroup),
+					testAccComputeInstanceGroup_hasCorrectNetwork(
+						"google_compute_instance_group.without_instance", "google_compute_network.ig_network", &instanceGroup),
+				),
+			},
+		},
+	})
+}
+
 func testAccComputeInstanceGroup_destroy(s *terraform.State) error {
 	config := testAccProvider.Meta().(*Config)
 
@@ -201,6 +227,44 @@ func testAccComputeInstanceGroup_named_ports(n string, np map[string]int64, inst
 	}
 }
 
+func testAccComputeInstanceGroup_hasCorrectNetwork(nInstanceGroup string, nNetwork string, instanceGroup *compute.InstanceGroup) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		config := testAccProvider.Meta().(*Config)
+
+		rsInstanceGroup, ok := s.RootModule().Resources[nInstanceGroup]
+		if !ok {
+			return fmt.Errorf("Not found: %s", nInstanceGroup)
+		}
+		if rsInstanceGroup.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+		instanceGroup, err := config.clientCompute.InstanceGroups.Get(
+			config.Project, rsInstanceGroup.Primary.Attributes["zone"], rsInstanceGroup.Primary.ID).Do()
+		if err != nil {
+			return err
+		}
+
+		rsNetwork, ok := s.RootModule().Resources[nNetwork]
+		if !ok {
+			return fmt.Errorf("Not found: %s", nNetwork)
+		}
+		if rsNetwork.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+		network, err := config.clientCompute.Networks.Get(
+			config.Project, rsNetwork.Primary.ID).Do()
+		if err != nil {
+			return err
+		}
+
+		if instanceGroup.Network != network.SelfLink {
+			return fmt.Errorf("network incorrect: actual=%s vs expected=%s", instanceGroup.Network, network.SelfLink)
+		}
+
+		return nil
+	}
+}
+
 func testAccComputeInstanceGroup_basic(instance string) string {
 	return fmt.Sprintf(`
 	resource "google_compute_instance" "ig_instance" {
@@ -237,7 +301,7 @@ func testAccComputeInstanceGroup_basic(instance string) string {
 		description = "Terraform test instance group empty"
 		name = "%s-empty"
 		zone = "us-central1-c"
-			named_port {
+		named_port {
 			name = "http"
 			port = "8080"
 		}
@@ -365,3 +429,40 @@ func testAccComputeInstanceGroup_outOfOrderInstances(instance string) string {
 		}
 	}`, instance, instance, instance)
 }
+
+func testAccComputeInstanceGroup_network(instance string) string {
+	return fmt.Sprintf(`
+	resource "google_compute_network" "ig_network" {
+		name = "%[1]s"
+		auto_create_subnetworks = true
+	}
+
+	resource "google_compute_instance" "ig_instance" {
+		name = "%[1]s"
+		machine_type = "n1-standard-1"
+		can_ip_forward = false
+		zone = "us-central1-c"
+
+		disk {
+			image = "debian-8-jessie-v20160803"
+		}
+
+		network_interface {
+			network = "${google_compute_network.ig_network.name}"
+		}
+	}
+
+	resource "google_compute_instance_group" "with_instance" {
+		description = "Terraform test instance group"
+		name = "%[1]s-with-instance"
+		zone = "us-central1-c"
+		instances = [ "${google_compute_instance.ig_instance.self_link}" ]
+	}
+
+	resource "google_compute_instance_group" "without_instance" {
+		description = "Terraform test instance group"
+		name = "%[1]s-without-instance"
+		zone = "us-central1-c"
+		network = "${google_compute_network.ig_network.self_link}"
+	}`, instance)
+}

google/resource_compute_subnetwork.go

@@ -14,6 +14,7 @@ func resourceComputeSubnetwork() *schema.Resource {
 	return &schema.Resource{
 		Create: resourceComputeSubnetworkCreate,
 		Read:   resourceComputeSubnetworkRead,
+		Update: resourceComputeSubnetworkUpdate,
 		Delete: resourceComputeSubnetworkDelete,
 
 		Schema: map[string]*schema.Schema{
@@ -61,7 +62,6 @@ func resourceComputeSubnetwork() *schema.Resource {
 			"private_ip_google_access": &schema.Schema{
 				Type:     schema.TypeBool,
 				Optional: true,
-				ForceNew: true,
 			},
 
 			"self_link": &schema.Schema{
@@ -161,6 +161,46 @@ func resourceComputeSubnetworkRead(d *schema.ResourceData, meta interface{}) err
 	return nil
 }
 
+func resourceComputeSubnetworkUpdate(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+
+	region, err := getRegion(d, config)
+	if err != nil {
+		return err
+	}
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	d.Partial(true)
+
+	if d.HasChange("private_ip_google_access") {
+		subnetworksSetPrivateIpGoogleAccessRequest := &compute.SubnetworksSetPrivateIpGoogleAccessRequest{
+			PrivateIpGoogleAccess: d.Get("private_ip_google_access").(bool),
+		}
+
+		log.Printf("[DEBUG] Updating Subnetwork PrivateIpGoogleAccess %q: %#v", d.Id(), subnetworksSetPrivateIpGoogleAccessRequest)
+		op, err := config.clientCompute.Subnetworks.SetPrivateIpGoogleAccess(
+			project, region, d.Get("name").(string), subnetworksSetPrivateIpGoogleAccessRequest).Do()
+		if err != nil {
+			return fmt.Errorf("Error updating subnetwork PrivateIpGoogleAccess: %s", err)
+		}
+
+		err = computeOperationWaitRegion(config, op, project, region, "Updating Subnetwork PrivateIpGoogleAccess")
+		if err != nil {
+			return err
+		}
+
+		d.SetPartial("private_ip_google_access")
+	}
+
+	d.Partial(false)
+
+	return resourceComputeSubnetworkRead(d, meta)
+}
+
 func resourceComputeSubnetworkDelete(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 

google/resource_compute_subnetwork_test.go

@@ -14,13 +14,18 @@ func TestAccComputeSubnetwork_basic(t *testing.T) {
 	var subnetwork1 compute.Subnetwork
 	var subnetwork2 compute.Subnetwork
 
+	cnName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	subnetwork1Name := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	subnetwork2Name := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	subnetwork3Name := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
 		Providers:    testAccProviders,
 		CheckDestroy: testAccCheckComputeSubnetworkDestroy,
 		Steps: []resource.TestStep{
 			resource.TestStep{
-				Config: testAccComputeSubnetwork_basic,
+				Config: testAccComputeSubnetwork_basic(cnName, subnetwork1Name, subnetwork2Name, subnetwork3Name),
 				Check: resource.ComposeTestCheckFunc(
 					testAccCheckComputeSubnetworkExists(
 						"google_compute_subnetwork.network-ref-by-url", &subnetwork1),
@@ -32,6 +37,39 @@ func TestAccComputeSubnetwork_basic(t *testing.T) {
 	})
 }
 
+func TestAccComputeSubnetwork_update(t *testing.T) {
+	var subnetwork compute.Subnetwork
+
+	cnName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+	subnetworkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeSubnetworkDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeSubnetwork_update1(cnName, subnetworkName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeSubnetworkExists(
+						"google_compute_subnetwork.network-with-private-google-access", &subnetwork),
+				),
+			},
+			resource.TestStep{
+				Config: testAccComputeSubnetwork_update2(cnName, subnetworkName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeSubnetworkExists(
+						"google_compute_subnetwork.network-with-private-google-access", &subnetwork),
+				),
+			},
+		},
+	})
+
+	if subnetwork.PrivateIpGoogleAccess {
+		t.Errorf("Expected PrivateIpGoogleAccess to be false, got %v", subnetwork.PrivateIpGoogleAccess)
+	}
+}
+
 func testAccCheckComputeSubnetworkDestroy(s *terraform.State) error {
 	config := testAccProvider.Meta().(*Config)
 
@@ -81,14 +119,15 @@ func testAccCheckComputeSubnetworkExists(n string, subnetwork *compute.Subnetwor
 	}
 }
 
-var testAccComputeSubnetwork_basic = fmt.Sprintf(`
+func testAccComputeSubnetwork_basic(cnName, subnetwork1Name, subnetwork2Name, subnetwork3Name string) string {
+	return fmt.Sprintf(`
 resource "google_compute_network" "custom-test" {
-	name = "network-test-%s"
+	name = "%s"
 	auto_create_subnetworks = false
 }
 
 resource "google_compute_subnetwork" "network-ref-by-url" {
-	name = "subnetwork-test-%s"
+	name = "%s"
 	ip_cidr_range = "10.0.0.0/16"
 	region = "us-central1"
 	network = "${google_compute_network.custom-test.self_link}"
@@ -96,18 +135,51 @@ resource "google_compute_subnetwork" "network-ref-by-url" {
 
 
 resource "google_compute_subnetwork" "network-ref-by-name" {
-	name = "subnetwork-test-%s"
+	name = "%s"
 	ip_cidr_range = "10.1.0.0/16"
 	region = "us-central1"
 	network = "${google_compute_network.custom-test.name}"
 }
 
 resource "google_compute_subnetwork" "network-with-private-google-access" {
-	name = "subnetwork-test-%s"
+	name = "%s"
 	ip_cidr_range = "10.2.0.0/16"
 	region = "us-central1"
 	network = "${google_compute_network.custom-test.self_link}"
 	private_ip_google_access = true
 }
+`, cnName, subnetwork1Name, subnetwork2Name, subnetwork3Name)
+}
 
-`, acctest.RandString(10), acctest.RandString(10), acctest.RandString(10), acctest.RandString(10))
+func testAccComputeSubnetwork_update1(cnName, subnetworkName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_network" "custom-test" {
+	name = "%s"
+	auto_create_subnetworks = false
+}
+
+resource "google_compute_subnetwork" "network-with-private-google-access" {
+	name = "%s"
+	ip_cidr_range = "10.2.0.0/16"
+	region = "us-central1"
+	network = "${google_compute_network.custom-test.self_link}"
+	private_ip_google_access = true
+}
+`, cnName, subnetworkName)
+}
+
+func testAccComputeSubnetwork_update2(cnName, subnetworkName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_network" "custom-test" {
+	name = "%s"
+	auto_create_subnetworks = false
+}
+
+resource "google_compute_subnetwork" "network-with-private-google-access" {
+	name = "%s"
+	ip_cidr_range = "10.2.0.0/16"
+	region = "us-central1"
+	network = "${google_compute_network.custom-test.self_link}"
+}
+`, cnName, subnetworkName)
+}

google/sqladmin_operation.go

@@ -66,6 +66,7 @@ func sqladminOperationWait(config *Config, op *sqladmin.Operation, activity stri
 	state := w.Conf()
 	state.Timeout = 10 * time.Minute
 	state.MinTimeout = 2 * time.Second
+	state.Delay = 5 * time.Second
 	opRaw, err := state.WaitForState()
 	if err != nil {
 		return fmt.Errorf("Error waiting for %s (op %s): %s", activity, op.Name, err)