Add support for target_tcp_proxy (hashicorp#528)

google/provider.go

@@ -97,6 +97,7 @@ func Provider() terraform.ResourceProvider {
 			"google_compute_subnetwork":                    resourceComputeSubnetwork(),
 			"google_compute_target_http_proxy":             resourceComputeTargetHttpProxy(),
 			"google_compute_target_https_proxy":            resourceComputeTargetHttpsProxy(),
+			"google_compute_target_tcp_proxy":              resourceComputeTargetTcpProxy(),
 			"google_compute_target_pool":                   resourceComputeTargetPool(),
 			"google_compute_url_map":                       resourceComputeUrlMap(),
 			"google_compute_vpn_gateway":                   resourceComputeVpnGateway(),

google/resource_compute_target_tcp_proxy.go

@@ -0,0 +1,169 @@
+package google
+
+import (
+	"fmt"
+	"log"
+	"strconv"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"google.golang.org/api/compute/v1"
+)
+
+func resourceComputeTargetTcpProxy() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceComputeTargetTcpProxyCreate,
+		Read:   resourceComputeTargetTcpProxyRead,
+		Delete: resourceComputeTargetTcpProxyDelete,
+		Update: resourceComputeTargetTcpProxyUpdate,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"backend_service": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"proxy_header": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Default:  "NONE",
+			},
+			"description": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"proxy_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"project": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"self_link": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceComputeTargetTcpProxyCreate(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	proxy := &compute.TargetTcpProxy{
+		Name:        d.Get("name").(string),
+		Service:     d.Get("backend_service").(string),
+		ProxyHeader: d.Get("proxy_header").(string),
+		Description: d.Get("description").(string),
+	}
+
+	log.Printf("[DEBUG] TargetTcpProxy insert request: %#v", proxy)
+	op, err := config.clientCompute.TargetTcpProxies.Insert(
+		project, proxy).Do()
+	if err != nil {
+		return fmt.Errorf("Error creating TargetTcpProxy: %s", err)
+	}
+
+	err = computeOperationWait(config, op, project, "Creating Target Tcp Proxy")
+	if err != nil {
+		return err
+	}
+
+	d.SetId(proxy.Name)
+
+	return resourceComputeTargetTcpProxyRead(d, meta)
+}
+
+func resourceComputeTargetTcpProxyUpdate(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	d.Partial(true)
+
+	if d.HasChange("proxy_header") {
+		proxy_header := d.Get("proxy_header").(string)
+		proxy_header_payload := &compute.TargetTcpProxiesSetProxyHeaderRequest{
+			ProxyHeader: proxy_header,
+		}
+		op, err := config.clientCompute.TargetTcpProxies.SetProxyHeader(
+			project, d.Id(), proxy_header_payload).Do()
+		if err != nil {
+			return fmt.Errorf("Error updating target: %s", err)
+		}
+
+		err = computeOperationWait(config, op, project, "Updating Target Tcp Proxy")
+		if err != nil {
+			return err
+		}
+
+		d.SetPartial("proxy_header")
+	}
+
+	d.Partial(false)
+
+	return resourceComputeTargetTcpProxyRead(d, meta)
+}
+
+func resourceComputeTargetTcpProxyRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	proxy, err := config.clientCompute.TargetTcpProxies.Get(
+		project, d.Id()).Do()
+	if err != nil {
+		return handleNotFoundError(err, d, fmt.Sprintf("Target TCP Proxy %q", d.Get("name").(string)))
+	}
+
+	d.Set("self_link", proxy.SelfLink)
+	d.Set("proxy_id", strconv.FormatUint(proxy.Id, 10))
+
+	return nil
+}
+
+func resourceComputeTargetTcpProxyDelete(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+
+	project, err := getProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	// Delete the TargetTcpProxy
+	log.Printf("[DEBUG] TargetTcpProxy delete request")
+	op, err := config.clientCompute.TargetTcpProxies.Delete(
+		project, d.Id()).Do()
+	if err != nil {
+		return fmt.Errorf("Error deleting TargetTcpProxy: %s", err)
+	}
+
+	err = computeOperationWait(config, op, project, "Deleting Target Tcp Proxy")
+	if err != nil {
+		return err
+	}
+
+	d.SetId("")
+	return nil
+}

google/resource_compute_target_tcp_proxy_test.go

@@ -0,0 +1,156 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccComputeTargetTcpProxy_basic(t *testing.T) {
+	target := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+	backend := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+	hc := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeTargetTcpProxyDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeTargetTcpProxy_basic1(target, backend, hc),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeTargetTcpProxyExists(
+						"google_compute_target_tcp_proxy.foobar"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccComputeTargetTcpProxy_update(t *testing.T) {
+	target := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+	backend := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+	hc := fmt.Sprintf("ttcp-test-%s", acctest.RandString(10))
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeTargetTcpProxyDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeTargetTcpProxy_basic1(target, backend, hc),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeTargetTcpProxyExists(
+						"google_compute_target_tcp_proxy.foobar"),
+				),
+			},
+			resource.TestStep{
+				Config: testAccComputeTargetTcpProxy_basic2(target, backend, hc),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckComputeTargetTcpProxyExists(
+						"google_compute_target_tcp_proxy.foobar"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckComputeTargetTcpProxyDestroy(s *terraform.State) error {
+	config := testAccProvider.Meta().(*Config)
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "google_compute_target_tcp_proxy" {
+			continue
+		}
+
+		_, err := config.clientCompute.TargetTcpProxies.Get(
+			config.Project, rs.Primary.ID).Do()
+		if err == nil {
+			return fmt.Errorf("TargetTcpProxy still exists")
+		}
+	}
+
+	return nil
+}
+
+func testAccCheckComputeTargetTcpProxyExists(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No ID is set")
+		}
+
+		config := testAccProvider.Meta().(*Config)
+
+		found, err := config.clientCompute.TargetTcpProxies.Get(
+			config.Project, rs.Primary.ID).Do()
+		if err != nil {
+			return err
+		}
+
+		if found.Name != rs.Primary.ID {
+			return fmt.Errorf("TargetTcpProxy not found")
+		}
+
+		return nil
+	}
+}
+
+func testAccComputeTargetTcpProxy_basic1(target, backend, hc string) string {
+	return fmt.Sprintf(`
+	resource "google_compute_target_tcp_proxy" "foobar" {
+		description = "Resource created for Terraform acceptance testing"
+		name = "%s"
+		backend_service = "${google_compute_backend_service.foobar.self_link}"
+		proxy_header = "NONE"
+	}
+
+	resource "google_compute_backend_service" "foobar" {
+		name = "%s"
+		protocol    = "TCP"
+		health_checks = ["${google_compute_health_check.zero.self_link}"]
+	}
+
+	resource "google_compute_health_check" "zero" {
+		name = "%s"
+		check_interval_sec = 1
+		timeout_sec = 1
+		tcp_health_check {
+			port = "443"
+		}
+	}
+	`, target, backend, hc)
+}
+
+func testAccComputeTargetTcpProxy_basic2(target, backend, hc string) string {
+	return fmt.Sprintf(`
+	resource "google_compute_target_tcp_proxy" "foobar" {
+		description = "Resource created for Terraform acceptance testing"
+		name = "%s"
+		backend_service = "${google_compute_backend_service.foobar.self_link}"
+		proxy_header = "PROXY_V1"
+	}
+
+	resource "google_compute_backend_service" "foobar" {
+		name = "%s"
+		protocol    = "TCP"
+		health_checks = ["${google_compute_health_check.zero.self_link}"]
+	}
+
+	resource "google_compute_health_check" "zero" {
+		name = "%s"
+		check_interval_sec = 1
+		timeout_sec = 1
+		tcp_health_check {
+			port = "443"
+		}
+	}
+	`, target, backend, hc)
+}