Multiple Google Cloud Platform improvements and new resources

.gitignore

@@ -17,3 +17,5 @@ website/node_modules
 *.tfstate
 *.log
 *.bak
+*~
+.*.swp

builtin/providers/google/provider.go

@@ -31,12 +31,15 @@ func Provider() terraform.ResourceProvider {
  },
 
  ResourcesMap: map[string]*schema.Resource{
- "google_compute_address": resourceComputeAddress(),
- "google_compute_disk": resourceComputeDisk(),
- "google_compute_firewall": resourceComputeFirewall(),
- "google_compute_instance": resourceComputeInstance(),
- "google_compute_network": resourceComputeNetwork(),
- "google_compute_route": resourceComputeRoute(),
+ "google_compute_address": resourceComputeAddress(),
+ "google_compute_disk": resourceComputeDisk(),
+ "google_compute_firewall": resourceComputeFirewall(),
+ "google_compute_forwarding_rule": resourceComputeForwardingRule(),
+ "google_compute_http_health_check": resourceComputeHttpHealthCheck(),
+ "google_compute_instance": resourceComputeInstance(),
+ "google_compute_network": resourceComputeNetwork(),
+ "google_compute_route": resourceComputeRoute(),
+ "google_compute_target_pool": resourceComputeTargetPool(),
  },
 
  ConfigureFunc: providerConfigure,
@@ -57,3 +60,5 @@ func providerConfigure(d *schema.ResourceData) (interface{}, error) {
 
  return &config, nil
 }
+
+// vim: ts=4:sw=4:noet

builtin/providers/google/resource_compute_address.go

@@ -27,6 +27,12 @@ func resourceComputeAddress() *schema.Resource {
  Type: schema.TypeString,
  Computed: true,
  },
+
+ "selfLink": &schema.Schema{
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
  },
  }
 }
@@ -90,6 +96,7 @@ func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error
  }
 
  d.Set("address", addr.Address)
+ d.Set("selfLink", addr.SelfLink)
 
  return nil
 }
@@ -98,6 +105,7 @@ func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) erro
  config := meta.(*Config)
 
  // Delete the address
+ log.Printf("[DEBUG] address delete request")
  op, err := config.clientCompute.Addresses.Delete(
  config.Project, config.Region, d.Id()).Do()
  if err != nil {

builtin/providers/google/resource_compute_forwarding_rule.go

@@ -0,0 +1,220 @@
+package google
+
+import (
+ "fmt"
+ "log"
+ "time"
+
+ "code.google.com/p/google-api-go-client/compute/v1"
+ "code.google.com/p/google-api-go-client/googleapi"
+ "github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceComputeForwardingRule() *schema.Resource {
+ return &schema.Resource{
+ Create: resourceComputeForwardingRuleCreate,
+ Read: resourceComputeForwardingRuleRead,
+ Delete: resourceComputeForwardingRuleDelete,
+ Update: resourceComputeForwardingRuleUpdate,
+
+ Schema: map[string]*schema.Schema{
+ "IPAddress": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ ForceNew: true,
+ Computed: true,
+ },
+
+ "IPProtocol": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ ForceNew: true,
+ Computed: true,
+ },
+
+ "description": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ ForceNew: true,
+ },
+
+ "name": &schema.Schema{
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: true,
+ },
+
+ "portRange": &schema.Schema{
+ Type: schema.TypeString,
+ Optional: true,
+ ForceNew: true,
+ },
+
+ "selfLink": &schema.Schema{
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "target": &schema.Schema{
+ Type: schema.TypeString,
+ Required: true,
+ ForceNew: false,
+ },
+ },
+ }
+}
+
+func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{}) error {
+ config := meta.(*Config)
+
+ frule := &compute.ForwardingRule{
+ IPAddress: d.Get("IPAddress").(string),
+ IPProtocol: d.Get("IPProtocol").(string),
+ Description: d.Get("description").(string),
+ Name: d.Get("name").(string),
+ PortRange: d.Get("portRange").(string),
+ Target: d.Get("target").(string),
+ }
+
+ log.Printf("[DEBUG] ForwardingRule insert request: %#v", frule)
+ op, err := config.clientCompute.ForwardingRules.Insert(
+ config.Project, config.Region, frule).Do()
+ if err != nil {
+ return fmt.Errorf("Error creating ForwardingRule: %s", err)
+ }
+
+ // It probably maybe worked, so store the ID now
+ d.SetId(frule.Name)
+
+ // Wait for the operation to complete
+ w := &OperationWaiter{
+ Service: config.clientCompute,
+ Op: op,
+ Region: config.Region,
+ Project: config.Project,
+ Type: OperationWaitRegion,
+ }
+ state := w.Conf()
+ state.Timeout = 2 * time.Minute
+ state.MinTimeout = 1 * time.Second
+ opRaw, err := state.WaitForState()
+ if err != nil {
+ return fmt.Errorf("Error waiting for ForwardingRule to create: %s", err)
+ }
+ op = opRaw.(*compute.Operation)
+ if op.Error != nil {
+ // The resource didn't actually create
+ d.SetId("")
+
+ // Return the error
+ return OperationError(*op.Error)
+ }
+
+ return resourceComputeForwardingRuleRead(d, meta)
+}
+
+func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{}) error {
+ config := meta.(*Config)
+
+ d.Partial(true)
+
+ if d.HasChange("target") {
+ target_name := d.Get("target").(string)
+ target_ref := &compute.TargetReference{Target: target_name}
+ op, err := config.clientCompute.ForwardingRules.SetTarget(
+ config.Project, config.Region, d.Id(), target_ref).Do()
+ if err != nil {
+ return fmt.Errorf("Error updating target: %s", err)
+ }
+
+ // Wait for the operation to complete
+ w := &OperationWaiter{
+ Service: config.clientCompute,
+ Op: op,
+ Region: config.Region,
+ Project: config.Project,
+ Type: OperationWaitRegion,
+ }
+ state := w.Conf()
+ state.Timeout = 2 * time.Minute
+ state.MinTimeout = 1 * time.Second
+ opRaw, err := state.WaitForState()
+ if err != nil {
+ return fmt.Errorf("Error waiting for ForwardingRule to update target: %s", err)
+ }
+ op = opRaw.(*compute.Operation)
+ if op.Error != nil {
+ // The resource didn't actually create
+ d.SetId("")
+
+ // Return the error
+ return OperationError(*op.Error)
+ }
+ d.SetPartial("target")
+ }
+
+ d.Partial(false)
+
+ return resourceComputeForwardingRuleRead(d, meta)
+}
+
+func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{}) error {
+ config := meta.(*Config)
+
+ frule, err := config.clientCompute.ForwardingRules.Get(
+ config.Project, config.Region, d.Id()).Do()
+ if err != nil {
+ if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
+ // The resource doesn't exist anymore
+ d.SetId("")
+
+ return nil
+ }
+
+ return fmt.Errorf("Error reading ForwardingRule: %s", err)
+ }
+
+ d.Set("IPAddress", frule.IPAddress)
+ d.Set("IPProtocol", frule.IPProtocol)
+ d.Set("selfLink", frule.SelfLink)
+
+ return nil
+}
+
+func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{}) error {
+ config := meta.(*Config)
+
+ // Delete the ForwardingRule
+ log.Printf("[DEBUG] ForwardingRule delete request")
+ op, err := config.clientCompute.ForwardingRules.Delete(
+ config.Project, config.Region, d.Id()).Do()
+ if err != nil {
+ return fmt.Errorf("Error deleting ForwardingRule: %s", err)
+ }
+
+ // Wait for the operation to complete
+ w := &OperationWaiter{
+ Service: config.clientCompute,
+ Op: op,
+ Region: config.Region,
+ Project: config.Project,
+ Type: OperationWaitRegion,
+ }
+ state := w.Conf()
+ state.Timeout = 2 * time.Minute
+ state.MinTimeout = 1 * time.Second
+ opRaw, err := state.WaitForState()
+ if err != nil {
+ return fmt.Errorf("Error waiting for ForwardingRule to delete: %s", err)
+ }
+ op = opRaw.(*compute.Operation)
+ if op.Error != nil {
+ // Return the error
+ return OperationError(*op.Error)
+ }
+
+ d.SetId("")
+ return nil
+}
+
+// vim: ts=4:sw=4:noet