diff --git a/google/provider.go b/google/provider.go index 24ba686f001..6785b3fd7a8 100644 --- a/google/provider.go +++ b/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(), diff --git a/google/resource_compute_target_tcp_proxy.go b/google/resource_compute_target_tcp_proxy.go new file mode 100644 index 00000000000..8be350e739c --- /dev/null +++ b/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 +} diff --git a/google/resource_compute_target_tcp_proxy_test.go b/google/resource_compute_target_tcp_proxy_test.go new file mode 100644 index 00000000000..7212bfa9c49 --- /dev/null +++ b/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) +} diff --git a/website/docs/r/compute_target_tcp_proxy.html.markdown b/website/docs/r/compute_target_tcp_proxy.html.markdown new file mode 100644 index 00000000000..c3231064706 --- /dev/null +++ b/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: + +* `proxy_id` - A unique ID assigned by GCE. + +* `self_link` - The URI of the created resource. diff --git a/website/google.erb b/website/google.erb index 57463781827..e7499ef3250 100644 --- a/website/google.erb +++ b/website/google.erb @@ -226,6 +226,10 @@ google_compute_target_https_proxy + > + google_compute_target_tcp_proxy + + > google_compute_target_pool