Add support for google_compute_target_tcp_proxy

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,171 @@
+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,
+			},
+
+			"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),
+	}
+
+	if v, ok := d.GetOk("description"); ok {
+		proxy.Description = v.(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("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,119 @@
+package google
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccComputeTargeTcpProxy_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"),
+				),
+			},
+		},
+	})
+}
+
+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}"
+	}
+
+	resource "google_compute_backend_service" "foobar" {
+		name = "%s"
+		health_checks = ["${google_compute_http_health_check.zero.self_link}"]
+	}
+
+	resource "google_compute_http_health_check" "zero" {
+		name = "%s"
+		request_path = "/"
+		check_interval_sec = 1
+		timeout_sec = 1
+	}
+	`, target, backend, hc)
+}

website/docs/r/compute_target_tcp_proxy.html.markdown

@@ -0,0 +1,72 @@
+---
+layout: "google"
+page_title: "Google: google_compute_target_tcp_proxy"
+sidebar_current: "docs-google-compute-target-tcp-proxy"
+description: |-
+  Creates a Target TCP Proxy resource in GCE.
+---
+
+# google\_compute\_target\_tcp\_proxy
+
+Creates a target TCP proxy resource in GCE. For more information see
+[the official
+documentation](https://cloud.google.com/compute/docs/load-balancing/tcp-ssl/tcp-proxy) and
+[API](https://cloud.google.com/compute/docs/reference/latest/targetTcpProxies).
+
+
+## Example Usage
+
+```hcl
+resource "google_compute_target_tcp_proxy" "default" {
+  name = "test"
+  description = "test"
+  backend_service = "${google_compute_backend_service.default.self_link}"
+}
+
+resource "google_compute_backend_service" "default" {
+  name        = "default-backend"
+  protocol    = "TCP"
+  timeout_sec = 10
+
+  health_checks = ["${google_compute_health_check.default.self_link}"]
+}
+
+resource "google_compute_health_check" "default" {
+  name = "default"
+  timeout_sec        = 1
+  check_interval_sec = 1
+
+  tcp_health_check {
+    port = "443"
+  }
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `name` - (Required) A unique name for the resource, required by GCE. Changing
+    this forces a new resource to be created.
+
+* `backend_service` - (Required) The URL of a Backend Service resource to receive the matched traffic.
+
+* `proxy_header` - (Optional) Type of proxy header to append before sending
+    data to the backend, either NONE or PROXY_V1 (default NONE).
+
+- - -
+
+* `description` - (Optional) A description of this resource. Changing this
+    forces a new resource to be created.
+
+* `project` - (Optional) The project in which the resource belongs. If it
+    is not provided, the provider project is used.
+
+## Attributes Reference
+
+In addition to the arguments listed above, the following computed attributes are
+exported:
+
+* `id` - A unique ID assigned by GCE.
+
+* `self_link` - The URI of the created resource.

website/google.erb

@@ -226,6 +226,10 @@
       <a href="/docs/providers/google/r/compute_target_https_proxy.html">google_compute_target_https_proxy</a>
       </li>
 
+      <li<%= sidebar_current("docs-google-compute-target-tcp-proxy") %>>
+      <a href="/docs/providers/google/r/compute_target_tcp_proxy.html">google_compute_target_tcp_proxy</a>
+      </li>
+
       <li<%= sidebar_current("docs-google-compute-target-pool") %>>
       <a href="/docs/providers/google/r/compute_target_pool.html">google_compute_target_pool</a>
       </li>