From 158af9d0d4a934f8900d05c6eca4423075c88db5 Mon Sep 17 00:00:00 2001 From: Lars Wander Date: Thu, 24 Sep 2015 16:30:12 -0400 Subject: [PATCH] Refactored wait code to delete duplicated code & share functionality --- builtin/providers/google/compute_operation.go | 158 ++++++++++++++++++ builtin/providers/google/operation.go | 82 --------- .../google/resource_compute_address.go | 44 +---- .../google/resource_compute_autoscaler.go | 64 +------ .../resource_compute_backend_service.go | 64 +------ .../providers/google/resource_compute_disk.go | 53 +----- .../google/resource_compute_firewall.go | 61 +------ .../resource_compute_forwarding_rule.go | 66 +------- .../resource_compute_http_health_check.go | 64 +------ .../google/resource_compute_instance.go | 39 +---- ...resource_compute_instance_group_manager.go | 53 +----- .../resource_compute_instance_template.go | 44 +---- .../google/resource_compute_network.go | 42 +---- .../resource_compute_project_metadata.go | 31 +--- .../google/resource_compute_route.go | 42 +---- .../google/resource_compute_target_pool.go | 69 ++------ .../google/resource_compute_vpn_gateway.go | 4 +- .../google/resource_compute_vpn_tunnel.go | 30 +--- 18 files changed, 238 insertions(+), 772 deletions(-) create mode 100644 builtin/providers/google/compute_operation.go delete mode 100644 builtin/providers/google/operation.go diff --git a/builtin/providers/google/compute_operation.go b/builtin/providers/google/compute_operation.go new file mode 100644 index 000000000..987e983b4 --- /dev/null +++ b/builtin/providers/google/compute_operation.go @@ -0,0 +1,158 @@ +package google + +import ( + "bytes" + "fmt" + "log" + "time" + + "github.com/hashicorp/terraform/helper/resource" + "google.golang.org/api/compute/v1" +) + +// OperationWaitType is an enum specifying what type of operation +// we're waiting on. +type ComputeOperationWaitType byte + +const ( + ComputeOperationWaitInvalid ComputeOperationWaitType = iota + ComputeOperationWaitGlobal + ComputeOperationWaitRegion + ComputeOperationWaitZone +) + +type ComputeOperationWaiter struct { + Service *compute.Service + Op *compute.Operation + Project string + Region string + Type ComputeOperationWaitType + Zone string +} + +func (w *ComputeOperationWaiter) RefreshFunc() resource.StateRefreshFunc { + return func() (interface{}, string, error) { + var op *compute.Operation + var err error + + switch w.Type { + case ComputeOperationWaitGlobal: + op, err = w.Service.GlobalOperations.Get( + w.Project, w.Op.Name).Do() + case ComputeOperationWaitRegion: + op, err = w.Service.RegionOperations.Get( + w.Project, w.Region, w.Op.Name).Do() + case ComputeOperationWaitZone: + op, err = w.Service.ZoneOperations.Get( + w.Project, w.Zone, w.Op.Name).Do() + default: + return nil, "bad-type", fmt.Errorf( + "Invalid wait type: %#v", w.Type) + } + + if err != nil { + return nil, "", err + } + + log.Printf("[DEBUG] Got %q when asking for operation %q", op.Status, w.Op.Name) + + return op, op.Status, nil + } +} + +func (w *ComputeOperationWaiter) Conf() *resource.StateChangeConf { + return &resource.StateChangeConf{ + Pending: []string{"PENDING", "RUNNING"}, + Target: "DONE", + Refresh: w.RefreshFunc(), + } +} + +// ComputeOperationError wraps compute.OperationError and implements the +// error interface so it can be returned. +type ComputeOperationError compute.OperationError + +func (e ComputeOperationError) Error() string { + var buf bytes.Buffer + + for _, err := range e.Errors { + buf.WriteString(err.Message + "\n") + } + + return buf.String() +} + +func computeOperationWaitGlobal(config *Config, op *compute.Operation, activity string) error { + w := &ComputeOperationWaiter{ + Service: config.clientCompute, + Op: op, + Project: config.Project, + Type: ComputeOperationWaitGlobal, + } + + state := w.Conf() + state.Delay = 10 * time.Second + state.Timeout = 4 * time.Minute + state.MinTimeout = 2 * time.Second + opRaw, err := state.WaitForState() + if err != nil { + return fmt.Errorf("Error waiting for %s: %s", activity, err) + } + + op = opRaw.(*compute.Operation) + if op.Error != nil { + return ComputeOperationError(*op.Error) + } + + return nil +} + +func computeOperationWaitRegion(config *Config, op *compute.Operation, region, activity string) error { + w := &ComputeOperationWaiter{ + Service: config.clientCompute, + Op: op, + Project: config.Project, + Type: ComputeOperationWaitRegion, + Region: region, + } + + state := w.Conf() + state.Delay = 10 * time.Second + state.Timeout = 4 * time.Minute + state.MinTimeout = 2 * time.Second + opRaw, err := state.WaitForState() + if err != nil { + return fmt.Errorf("Error waiting for %s: %s", activity, err) + } + + op = opRaw.(*compute.Operation) + if op.Error != nil { + return ComputeOperationError(*op.Error) + } + + return nil +} + +func computeOperationWaitZone(config *Config, op *compute.Operation, zone, activity string) error { + w := &ComputeOperationWaiter{ + Service: config.clientCompute, + Op: op, + Project: config.Project, + Zone: zone, + Type: ComputeOperationWaitZone, + } + state := w.Conf() + state.Delay = 10 * time.Second + state.Timeout = 4 * time.Minute + state.MinTimeout = 2 * time.Second + opRaw, err := state.WaitForState() + if err != nil { + return fmt.Errorf("Error waiting for %s: %s", activity, err) + } + op = opRaw.(*compute.Operation) + if op.Error != nil { + // Return the error + return ComputeOperationError(*op.Error) + } + return nil +} diff --git a/builtin/providers/google/operation.go b/builtin/providers/google/operation.go deleted file mode 100644 index 0971e3f5b..000000000 --- a/builtin/providers/google/operation.go +++ /dev/null @@ -1,82 +0,0 @@ -package google - -import ( - "bytes" - "fmt" - "log" - - "github.com/hashicorp/terraform/helper/resource" - "google.golang.org/api/compute/v1" -) - -// OperationWaitType is an enum specifying what type of operation -// we're waiting on. -type OperationWaitType byte - -const ( - OperationWaitInvalid OperationWaitType = iota - OperationWaitGlobal - OperationWaitRegion - OperationWaitZone -) - -type OperationWaiter struct { - Service *compute.Service - Op *compute.Operation - Project string - Region string - Type OperationWaitType - Zone string -} - -func (w *OperationWaiter) RefreshFunc() resource.StateRefreshFunc { - return func() (interface{}, string, error) { - var op *compute.Operation - var err error - - switch w.Type { - case OperationWaitGlobal: - op, err = w.Service.GlobalOperations.Get( - w.Project, w.Op.Name).Do() - case OperationWaitRegion: - op, err = w.Service.RegionOperations.Get( - w.Project, w.Region, w.Op.Name).Do() - case OperationWaitZone: - op, err = w.Service.ZoneOperations.Get( - w.Project, w.Zone, w.Op.Name).Do() - default: - return nil, "bad-type", fmt.Errorf( - "Invalid wait type: %#v", w.Type) - } - - if err != nil { - return nil, "", err - } - - log.Printf("[DEBUG] Got %q when asking for operation %q", op.Status, w.Op.Name) - - return op, op.Status, nil - } -} - -func (w *OperationWaiter) Conf() *resource.StateChangeConf { - return &resource.StateChangeConf{ - Pending: []string{"PENDING", "RUNNING"}, - Target: "DONE", - Refresh: w.RefreshFunc(), - } -} - -// OperationError wraps compute.OperationError and implements the -// error interface so it can be returned. -type OperationError compute.OperationError - -func (e OperationError) Error() string { - var buf bytes.Buffer - - for _, err := range e.Errors { - buf.WriteString(err.Message + "\n") - } - - return buf.String() -} diff --git a/builtin/providers/google/resource_compute_address.go b/builtin/providers/google/resource_compute_address.go index 721d67d14..0027df230 100644 --- a/builtin/providers/google/resource_compute_address.go +++ b/builtin/providers/google/resource_compute_address.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -65,28 +64,9 @@ func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) erro // It probably maybe worked, so store the ID now d.SetId(addr.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Region: region, - Type: OperationWaitRegion, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitRegion(config, op, region, "Creating Address") if err != nil { - return fmt.Errorf("Error waiting for address 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 err } return resourceComputeAddressRead(d, meta) @@ -128,25 +108,9 @@ func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) erro return fmt.Errorf("Error deleting address: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Region: region, - Type: OperationWaitRegion, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitRegion(config, op, region, "Deleting Address") if err != nil { - return fmt.Errorf("Error waiting for address to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_autoscaler.go b/builtin/providers/google/resource_compute_autoscaler.go index 10b7c84ef..8539c62b3 100644 --- a/builtin/providers/google/resource_compute_autoscaler.go +++ b/builtin/providers/google/resource_compute_autoscaler.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -224,28 +223,9 @@ func resourceComputeAutoscalerCreate(d *schema.ResourceData, meta interface{}) e // It probably maybe worked, so store the ID now d.SetId(scaler.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitZone, - Zone: zone.Name, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitZone(config, op, zone.Name, "Creating Autoscaler") if err != nil { - return fmt.Errorf("Error waiting for Autoscaler 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 err } return resourceComputeAutoscalerRead(d, meta) @@ -292,25 +272,9 @@ func resourceComputeAutoscalerUpdate(d *schema.ResourceData, meta interface{}) e // It probably maybe worked, so store the ID now d.SetId(scaler.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitZone, - Zone: zone, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitZone(config, op, zone, "Updating Autoscaler") if err != nil { - return fmt.Errorf("Error waiting for Autoscaler to update: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } return resourceComputeAutoscalerRead(d, meta) @@ -326,25 +290,9 @@ func resourceComputeAutoscalerDelete(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("Error deleting autoscaler: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitZone, - Zone: zone, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitZone(config, op, zone, "Deleting Autoscaler") if err != nil { - return fmt.Errorf("Error waiting for Autoscaler to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_backend_service.go b/builtin/providers/google/resource_compute_backend_service.go index a8826f8e4..cbd722d38 100644 --- a/builtin/providers/google/resource_compute_backend_service.go +++ b/builtin/providers/google/resource_compute_backend_service.go @@ -5,7 +5,6 @@ import ( "fmt" "log" "regexp" - "time" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -165,28 +164,9 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{ d.SetId(service.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Region: config.Region, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Backend Service") if err != nil { - return fmt.Errorf("Error waiting for backend service 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 err } return resourceComputeBackendServiceRead(d, meta) @@ -261,25 +241,9 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{ d.SetId(service.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Region: config.Region, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Updating Backend Service") if err != nil { - return fmt.Errorf("Error waiting for backend service to update: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } return resourceComputeBackendServiceRead(d, meta) @@ -295,25 +259,9 @@ func resourceComputeBackendServiceDelete(d *schema.ResourceData, meta interface{ return fmt.Errorf("Error deleting backend service: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Region: config.Region, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Backend Service") if err != nil { - return fmt.Errorf("Error waiting for backend service to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_disk.go b/builtin/providers/google/resource_compute_disk.go index 7202e45d9..1118702d6 100644 --- a/builtin/providers/google/resource_compute_disk.go +++ b/builtin/providers/google/resource_compute_disk.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -128,37 +127,10 @@ func resourceComputeDiskCreate(d *schema.ResourceData, meta interface{}) error { // It probably maybe worked, so store the ID now d.SetId(disk.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Zone: d.Get("zone").(string), - Type: OperationWaitZone, - } - state := w.Conf() - - if disk.SourceSnapshot != "" { - //creating disk from snapshot takes some time - state.Timeout = 10 * time.Minute - } else { - state.Timeout = 2 * time.Minute - } - - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Creating Disk") if err != nil { - return fmt.Errorf("Error waiting for disk to create: %s", err) + return 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 resourceComputeDiskRead(d, meta) } @@ -193,25 +165,10 @@ func resourceComputeDiskDelete(d *schema.ResourceData, meta interface{}) error { return fmt.Errorf("Error deleting disk: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Zone: d.Get("zone").(string), - Type: OperationWaitZone, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + zone := d.Get("zone").(string) + err = computeOperationWaitZone(config, op, zone, "Creating Disk") if err != nil { - return fmt.Errorf("Error waiting for disk to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_firewall.go b/builtin/providers/google/resource_compute_firewall.go index 2a2433a87..1cec2c826 100644 --- a/builtin/providers/google/resource_compute_firewall.go +++ b/builtin/providers/google/resource_compute_firewall.go @@ -4,7 +4,6 @@ import ( "bytes" "fmt" "sort" - "time" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -135,27 +134,9 @@ func resourceComputeFirewallCreate(d *schema.ResourceData, meta interface{}) err // It probably maybe worked, so store the ID now d.SetId(firewall.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Firewall") if err != nil { - return fmt.Errorf("Error waiting for firewall 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 err } return resourceComputeFirewallRead(d, meta) @@ -198,24 +179,9 @@ func resourceComputeFirewallUpdate(d *schema.ResourceData, meta interface{}) err return fmt.Errorf("Error updating firewall: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Updating Firewall") if err != nil { - return fmt.Errorf("Error waiting for firewall to update: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.Partial(false) @@ -233,24 +199,9 @@ func resourceComputeFirewallDelete(d *schema.ResourceData, meta interface{}) err return fmt.Errorf("Error deleting firewall: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Firewall") if err != nil { - return fmt.Errorf("Error waiting for firewall to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_forwarding_rule.go b/builtin/providers/google/resource_compute_forwarding_rule.go index 0c905ead7..ac4851e51 100644 --- a/builtin/providers/google/resource_compute_forwarding_rule.go +++ b/builtin/providers/google/resource_compute_forwarding_rule.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -94,28 +93,9 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{ // 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: region, - Project: config.Project, - Type: OperationWaitRegion, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitRegion(config, op, region, "Creating Fowarding Rule") 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 err } return resourceComputeForwardingRuleRead(d, meta) @@ -137,29 +117,11 @@ func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{ return fmt.Errorf("Error updating target: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Region: region, - Project: config.Project, - Type: OperationWaitRegion, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitRegion(config, op, region, "Updating Forwarding Rule") if err != nil { - return fmt.Errorf("Error waiting for ForwardingRule to update target: %s", err) + return 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") } @@ -206,25 +168,9 @@ func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{ return fmt.Errorf("Error deleting ForwardingRule: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Region: region, - Project: config.Project, - Type: OperationWaitRegion, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitRegion(config, op, region, "Deleting Forwarding Rule") 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) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_http_health_check.go b/builtin/providers/google/resource_compute_http_health_check.go index 4dfe3a03d..c53267afd 100644 --- a/builtin/providers/google/resource_compute_http_health_check.go +++ b/builtin/providers/google/resource_compute_http_health_check.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -121,27 +120,9 @@ func resourceComputeHttpHealthCheckCreate(d *schema.ResourceData, meta interface // It probably maybe worked, so store the ID now d.SetId(hchk.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Http Health Check") if err != nil { - return fmt.Errorf("Error waiting for HttpHealthCheck 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 err } return resourceComputeHttpHealthCheckRead(d, meta) @@ -190,27 +171,9 @@ func resourceComputeHttpHealthCheckUpdate(d *schema.ResourceData, meta interface // It probably maybe worked, so store the ID now d.SetId(hchk.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Updating Http Health Check") if err != nil { - return fmt.Errorf("Error waiting for HttpHealthCheck to patch: %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 err } return resourceComputeHttpHealthCheckRead(d, meta) @@ -254,24 +217,9 @@ func resourceComputeHttpHealthCheckDelete(d *schema.ResourceData, meta interface return fmt.Errorf("Error deleting HttpHealthCheck: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Http Health Check") if err != nil { - return fmt.Errorf("Error waiting for HttpHealthCheck to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_instance.go b/builtin/providers/google/resource_compute_instance.go index 2a03a7f94..987964641 100644 --- a/builtin/providers/google/resource_compute_instance.go +++ b/builtin/providers/google/resource_compute_instance.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -273,32 +272,6 @@ func getInstance(config *Config, d *schema.ResourceData) (*compute.Instance, err return instance, nil } -func resourceOperationWaitZone( - config *Config, op *compute.Operation, zone string, activity string) error { - - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Zone: zone, - Type: OperationWaitZone, - } - state := w.Conf() - state.Delay = 10 * time.Second - state.Timeout = 10 * time.Minute - state.MinTimeout = 2 * time.Second - opRaw, err := state.WaitForState() - if err != nil { - return fmt.Errorf("Error waiting for %s: %s", activity, err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) - } - return nil -} - func resourceComputeInstanceCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -521,7 +494,7 @@ func resourceComputeInstanceCreate(d *schema.ResourceData, meta interface{}) err d.SetId(instance.Name) // Wait for the operation to complete - waitErr := resourceOperationWaitZone(config, op, zone.Name, "instance to create") + waitErr := computeOperationWaitZone(config, op, zone.Name, "instance to create") if waitErr != nil { // The resource didn't actually create d.SetId("") @@ -703,7 +676,7 @@ func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) err return fmt.Errorf("Error updating metadata: %s", err) } - opErr := resourceOperationWaitZone(config, op, zone, "metadata to update") + opErr := computeOperationWaitZone(config, op, zone, "metadata to update") if opErr != nil { return opErr } @@ -723,7 +696,7 @@ func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) err return fmt.Errorf("Error updating tags: %s", err) } - opErr := resourceOperationWaitZone(config, op, zone, "tags to update") + opErr := computeOperationWaitZone(config, op, zone, "tags to update") if opErr != nil { return opErr } @@ -764,7 +737,7 @@ func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) err if err != nil { return fmt.Errorf("Error deleting old access_config: %s", err) } - opErr := resourceOperationWaitZone(config, op, zone, "old access_config to delete") + opErr := computeOperationWaitZone(config, op, zone, "old access_config to delete") if opErr != nil { return opErr } @@ -783,7 +756,7 @@ func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) err if err != nil { return fmt.Errorf("Error adding new access_config: %s", err) } - opErr := resourceOperationWaitZone(config, op, zone, "new access_config to add") + opErr := computeOperationWaitZone(config, op, zone, "new access_config to add") if opErr != nil { return opErr } @@ -809,7 +782,7 @@ func resourceComputeInstanceDelete(d *schema.ResourceData, meta interface{}) err } // Wait for the operation to complete - opErr := resourceOperationWaitZone(config, op, zone, "instance to delete") + opErr := computeOperationWaitZone(config, op, zone, "instance to delete") if opErr != nil { return opErr } diff --git a/builtin/providers/google/resource_compute_instance_group_manager.go b/builtin/providers/google/resource_compute_instance_group_manager.go index 9651c935f..ed48b26d5 100644 --- a/builtin/providers/google/resource_compute_instance_group_manager.go +++ b/builtin/providers/google/resource_compute_instance_group_manager.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" @@ -82,26 +81,6 @@ func resourceComputeInstanceGroupManager() *schema.Resource { } } -func waitOpZone(config *Config, op *compute.Operation, zone string, - resource string, action string) (*compute.Operation, error) { - - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Zone: zone, - Type: OperationWaitZone, - } - state := w.Conf() - state.Timeout = 8 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() - if err != nil { - return nil, fmt.Errorf("Error waiting for %s to %s: %s", resource, action, err) - } - return opRaw.(*compute.Operation), nil -} - func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -143,16 +122,10 @@ func resourceComputeInstanceGroupManagerCreate(d *schema.ResourceData, meta inte d.SetId(manager.Name) // Wait for the operation to complete - op, err = waitOpZone(config, op, d.Get("zone").(string), "InstanceGroupManager", "create") + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Creating InstanceGroupManager") if err != nil { return err } - if op.Error != nil { - // The resource didn't actually create - d.SetId("") - // Return the error - return OperationError(*op.Error) - } return resourceComputeInstanceGroupManagerRead(d, meta) } @@ -208,13 +181,10 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte } // Wait for the operation to complete - op, err = waitOpZone(config, op, d.Get("zone").(string), "InstanceGroupManager", "update TargetPools") + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Updating InstanceGroupManager") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } d.SetPartial("target_pools") } @@ -233,13 +203,10 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte } // Wait for the operation to complete - op, err = waitOpZone(config, op, d.Get("zone").(string), "InstanceGroupManager", "update instance template") + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Updating InstanceGroupManager") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } d.SetPartial("instance_template") } @@ -257,13 +224,10 @@ func resourceComputeInstanceGroupManagerUpdate(d *schema.ResourceData, meta inte } // Wait for the operation to complete - op, err = waitOpZone(config, op, d.Get("zone").(string), "InstanceGroupManager", "update target_size") + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Updating InstanceGroupManager") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } } d.SetPartial("target_size") @@ -284,17 +248,10 @@ func resourceComputeInstanceGroupManagerDelete(d *schema.ResourceData, meta inte } // Wait for the operation to complete - op, err = waitOpZone(config, op, d.Get("zone").(string), "InstanceGroupManager", "delete") + err = computeOperationWaitZone(config, op, d.Get("zone").(string), "Deleting InstanceGroupManager") if err != nil { return err } - if op.Error != nil { - // The resource didn't actually create - d.SetId("") - - // Return the error - return OperationError(*op.Error) - } d.SetId("") return nil diff --git a/builtin/providers/google/resource_compute_instance_template.go b/builtin/providers/google/resource_compute_instance_template.go index 060f4bb39..c0e367c16 100644 --- a/builtin/providers/google/resource_compute_instance_template.go +++ b/builtin/providers/google/resource_compute_instance_template.go @@ -2,7 +2,6 @@ package google import ( "fmt" - "time" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -401,28 +400,9 @@ func resourceComputeInstanceTemplateCreate(d *schema.ResourceData, meta interfac // Store the ID now d.SetId(instanceTemplate.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Delay = 10 * time.Second - state.Timeout = 10 * time.Minute - state.MinTimeout = 2 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Instance Template") if err != nil { - return fmt.Errorf("Error waiting for instance template 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 err } return resourceComputeInstanceTemplateRead(d, meta) @@ -467,25 +447,9 @@ func resourceComputeInstanceTemplateDelete(d *schema.ResourceData, meta interfac return fmt.Errorf("Error deleting instance template: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Delay = 5 * time.Second - state.Timeout = 5 * time.Minute - state.MinTimeout = 2 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Instance Template") if err != nil { - return fmt.Errorf("Error waiting for instance template to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_network.go b/builtin/providers/google/resource_compute_network.go index 5e581eff2..5a61f2ad6 100644 --- a/builtin/providers/google/resource_compute_network.go +++ b/builtin/providers/google/resource_compute_network.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -60,27 +59,9 @@ func resourceComputeNetworkCreate(d *schema.ResourceData, meta interface{}) erro // It probably maybe worked, so store the ID now d.SetId(network.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Network") if err != nil { - return fmt.Errorf("Error waiting for network 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 err } return resourceComputeNetworkRead(d, meta) @@ -118,24 +99,9 @@ func resourceComputeNetworkDelete(d *schema.ResourceData, meta interface{}) erro return fmt.Errorf("Error deleting network: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Network") if err != nil { - return fmt.Errorf("Error waiting for network to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_project_metadata.go b/builtin/providers/google/resource_compute_project_metadata.go index 3471d9110..83b6fb0df 100644 --- a/builtin/providers/google/resource_compute_project_metadata.go +++ b/builtin/providers/google/resource_compute_project_metadata.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" // "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -30,30 +29,6 @@ func resourceComputeProjectMetadata() *schema.Resource { } } -func resourceOperationWaitGlobal(config *Config, op *compute.Operation, activity string) error { - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - - 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 %s: %s", activity, err) - } - - op = opRaw.(*compute.Operation) - if op.Error != nil { - return OperationError(*op.Error) - } - - return nil -} - func resourceComputeProjectMetadataCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -92,7 +67,7 @@ func resourceComputeProjectMetadataCreate(d *schema.ResourceData, meta interface log.Printf("[DEBUG] SetCommonMetadata: %d (%s)", op.Id, op.SelfLink) - return resourceOperationWaitGlobal(config, op, "SetCommonMetadata") + return computeOperationWaitGlobal(config, op, "SetCommonMetadata") } err := MetadataRetryWrapper(createMD) @@ -153,7 +128,7 @@ func resourceComputeProjectMetadataUpdate(d *schema.ResourceData, meta interface // Optimistic locking requires the fingerprint received to match // the fingerprint we send the server, if there is a mismatch then we // are working on old data, and must retry - return resourceOperationWaitGlobal(config, op, "SetCommonMetadata") + return computeOperationWaitGlobal(config, op, "SetCommonMetadata") } err := MetadataRetryWrapper(updateMD) @@ -186,7 +161,7 @@ func resourceComputeProjectMetadataDelete(d *schema.ResourceData, meta interface log.Printf("[DEBUG] SetCommonMetadata: %d (%s)", op.Id, op.SelfLink) - err = resourceOperationWaitGlobal(config, op, "SetCommonMetadata") + err = computeOperationWaitGlobal(config, op, "SetCommonMetadata") if err != nil { return err } diff --git a/builtin/providers/google/resource_compute_route.go b/builtin/providers/google/resource_compute_route.go index 53176c871..82b43d358 100644 --- a/builtin/providers/google/resource_compute_route.go +++ b/builtin/providers/google/resource_compute_route.go @@ -3,7 +3,6 @@ package google import ( "fmt" "log" - "time" "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/helper/schema" @@ -171,27 +170,9 @@ func resourceComputeRouteCreate(d *schema.ResourceData, meta interface{}) error // It probably maybe worked, so store the ID now d.SetId(route.Name) - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Creating Route") if err != nil { - return fmt.Errorf("Error waiting for route 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 err } return resourceComputeRouteRead(d, meta) @@ -228,24 +209,9 @@ func resourceComputeRouteDelete(d *schema.ResourceData, meta interface{}) error return fmt.Errorf("Error deleting route: %s", err) } - // Wait for the operation to complete - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitGlobal, - } - state := w.Conf() - state.Timeout = 2 * time.Minute - state.MinTimeout = 1 * time.Second - opRaw, err := state.WaitForState() + err = computeOperationWaitGlobal(config, op, "Deleting Route") if err != nil { - return fmt.Errorf("Error waiting for route to delete: %s", err) - } - op = opRaw.(*compute.Operation) - if op.Error != nil { - // Return the error - return OperationError(*op.Error) + return err } d.SetId("") diff --git a/builtin/providers/google/resource_compute_target_pool.go b/builtin/providers/google/resource_compute_target_pool.go index 83611e2bd..37af4a1e7 100644 --- a/builtin/providers/google/resource_compute_target_pool.go +++ b/builtin/providers/google/resource_compute_target_pool.go @@ -4,7 +4,6 @@ import ( "fmt" "log" "strings" - "time" "github.com/hashicorp/terraform/helper/schema" "google.golang.org/api/compute/v1" @@ -79,26 +78,6 @@ func convertStringArr(ifaceArr []interface{}) []string { return arr } -func waitOp(config *Config, op *compute.Operation, - resource string, action string) (*compute.Operation, error) { - - 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 nil, fmt.Errorf("Error waiting for %s to %s: %s", resource, action, err) - } - return opRaw.(*compute.Operation), nil -} - // Healthchecks need to exist before being referred to from the target pool. func convertHealthChecks(config *Config, names []string) ([]string, error) { urls := make([]string, len(names)) @@ -171,16 +150,10 @@ func resourceComputeTargetPoolCreate(d *schema.ResourceData, meta interface{}) e // It probably maybe worked, so store the ID now d.SetId(tpool.Name) - op, err = waitOp(config, op, "TargetPool", "create") + err = computeOperationWaitRegion(config, op, config.Region, "Creating Target Pool") if err != nil { return err } - if op.Error != nil { - // The resource didn't actually create - d.SetId("") - // Return the error - return OperationError(*op.Error) - } return resourceComputeTargetPoolRead(d, meta) } @@ -246,14 +219,11 @@ func resourceComputeTargetPoolUpdate(d *schema.ResourceData, meta interface{}) e if err != nil { return fmt.Errorf("Error updating health_check: %s", err) } - op, err = waitOp(config, op, "TargetPool", "removing HealthChecks") + + err = computeOperationWaitRegion(config, op, config.Region, "Updating Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - addReq := &compute.TargetPoolsAddHealthCheckRequest{ HealthChecks: make([]*compute.HealthCheckReference, len(add)), } @@ -265,14 +235,11 @@ func resourceComputeTargetPoolUpdate(d *schema.ResourceData, meta interface{}) e if err != nil { return fmt.Errorf("Error updating health_check: %s", err) } - op, err = waitOp(config, op, "TargetPool", "adding HealthChecks") + + err = computeOperationWaitRegion(config, op, config.Region, "Updating Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - d.SetPartial("health_checks") } @@ -302,14 +269,11 @@ func resourceComputeTargetPoolUpdate(d *schema.ResourceData, meta interface{}) e if err != nil { return fmt.Errorf("Error updating instances: %s", err) } - op, err = waitOp(config, op, "TargetPool", "adding instances") + + err = computeOperationWaitRegion(config, op, config.Region, "Updating Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - removeReq := &compute.TargetPoolsRemoveInstanceRequest{ Instances: make([]*compute.InstanceReference, len(remove)), } @@ -321,14 +285,11 @@ func resourceComputeTargetPoolUpdate(d *schema.ResourceData, meta interface{}) e if err != nil { return fmt.Errorf("Error updating instances: %s", err) } - op, err = waitOp(config, op, "TargetPool", "removing instances") + + err = computeOperationWaitRegion(config, op, config.Region, "Updating Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - d.SetPartial("instances") } @@ -343,14 +304,10 @@ func resourceComputeTargetPoolUpdate(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("Error updating backup_pool: %s", err) } - op, err = waitOp(config, op, "TargetPool", "updating backup_pool") + err = computeOperationWaitRegion(config, op, config.Region, "Updating Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - d.SetPartial("backup_pool") } @@ -390,14 +347,10 @@ func resourceComputeTargetPoolDelete(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("Error deleting TargetPool: %s", err) } - op, err = waitOp(config, op, "TargetPool", "delete") + err = computeOperationWaitRegion(config, op, config.Region, "Deleting Target Pool") if err != nil { return err } - if op.Error != nil { - return OperationError(*op.Error) - } - d.SetId("") return nil } diff --git a/builtin/providers/google/resource_compute_vpn_gateway.go b/builtin/providers/google/resource_compute_vpn_gateway.go index 01a6c4b94..ba25aeb1f 100644 --- a/builtin/providers/google/resource_compute_vpn_gateway.go +++ b/builtin/providers/google/resource_compute_vpn_gateway.go @@ -69,7 +69,7 @@ func resourceComputeVpnGatewayCreate(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("Error Inserting VPN Gateway %s into network %s: %s", name, network, err) } - err = resourceOperationWaitRegion(config, op, region, "Inserting VPN Gateway") + err = computeOperationWaitRegion(config, op, region, "Inserting VPN Gateway") if err != nil { return fmt.Errorf("Error Waiting to Insert VPN Gateway %s into network %s: %s", name, network, err) } @@ -111,7 +111,7 @@ func resourceComputeVpnGatewayDelete(d *schema.ResourceData, meta interface{}) e return fmt.Errorf("Error Reading VPN Gateway %s: %s", name, err) } - err = resourceOperationWaitRegion(config, op, region, "Deleting VPN Gateway") + err = computeOperationWaitRegion(config, op, region, "Deleting VPN Gateway") if err != nil { return fmt.Errorf("Error Waiting to Delete VPN Gateway %s: %s", name, err) } diff --git a/builtin/providers/google/resource_compute_vpn_tunnel.go b/builtin/providers/google/resource_compute_vpn_tunnel.go index 55848d546..172f96a90 100644 --- a/builtin/providers/google/resource_compute_vpn_tunnel.go +++ b/builtin/providers/google/resource_compute_vpn_tunnel.go @@ -2,7 +2,6 @@ package google import ( "fmt" - "time" "github.com/hashicorp/terraform/helper/schema" @@ -66,31 +65,6 @@ func resourceComputeVpnTunnel() *schema.Resource { } } -func resourceOperationWaitRegion(config *Config, op *compute.Operation, region, activity string) error { - w := &OperationWaiter{ - Service: config.clientCompute, - Op: op, - Project: config.Project, - Type: OperationWaitRegion, - Region: region, - } - - 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 %s: %s", activity, err) - } - - op = opRaw.(*compute.Operation) - if op.Error != nil { - return OperationError(*op.Error) - } - - return nil -} - func resourceComputeVpnTunnelCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -125,7 +99,7 @@ func resourceComputeVpnTunnelCreate(d *schema.ResourceData, meta interface{}) er return fmt.Errorf("Error Inserting VPN Tunnel %s : %s", name, err) } - err = resourceOperationWaitRegion(config, op, region, "Inserting VPN Tunnel") + err = computeOperationWaitRegion(config, op, region, "Inserting VPN Tunnel") if err != nil { return fmt.Errorf("Error Waiting to Insert VPN Tunnel %s: %s", name, err) } @@ -169,7 +143,7 @@ func resourceComputeVpnTunnelDelete(d *schema.ResourceData, meta interface{}) er return fmt.Errorf("Error Reading VPN Tunnel %s: %s", name, err) } - err = resourceOperationWaitRegion(config, op, region, "Deleting VPN Tunnel") + err = computeOperationWaitRegion(config, op, region, "Deleting VPN Tunnel") if err != nil { return fmt.Errorf("Error Waiting to Delete VPN Tunnel %s: %s", name, err) }