clean up operation code (hashicorp#267)

Author: modular-magician

google-beta/access_context_manager_operation.go

@@ -1,67 +1,24 @@
 package google
 
 import (
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/hashicorp/terraform/helper/resource"
 	"google.golang.org/api/accesscontextmanager/v1beta"
 )
 
 type AccessContextManagerOperationWaiter struct {
 	Service *accesscontextmanager.OperationsService
-	Op      *accesscontextmanager.Operation
-}
-
-func (w *AccessContextManagerOperationWaiter) RefreshFunc() resource.StateRefreshFunc {
-	return func() (interface{}, string, error) {
-		op, err := w.Service.Get(w.Op.Name).Do()
-
-		if err != nil {
-			return nil, "", err
-		}
-
-		log.Printf("[DEBUG] Got %v while polling for operation %s's 'done' status", op.Done, w.Op.Name)
-
-		return op, fmt.Sprint(op.Done), nil
-	}
+	CommonOperationWaiter
 }
 
-func (w *AccessContextManagerOperationWaiter) Conf() *resource.StateChangeConf {
-	return &resource.StateChangeConf{
-		Pending: []string{"false"},
-		Target:  []string{"true"},
-		Refresh: w.RefreshFunc(),
-	}
+func (w *AccessContextManagerOperationWaiter) QueryOp() (interface{}, error) {
+	return w.Service.Get(w.Op.Name).Do()
 }
 
-func accessContextManagerOperationWaitTime(service *accesscontextmanager.Service, op *accesscontextmanager.Operation, activity string, timeoutMin int) error {
-	if op.Done {
-		if op.Error != nil {
-			return fmt.Errorf("Error code %v, message: %s", op.Error.Code, op.Error.Message)
-		}
-		return nil
-	}
-
+func accessContextManagerOperationWaitTime(service *accesscontextmanager.Service, op *accesscontextmanager.Operation, activity string, timeoutMinutes int) error {
 	w := &AccessContextManagerOperationWaiter{
 		Service: service.Operations,
-		Op:      op,
 	}
-
-	state := w.Conf()
-	state.Delay = 10 * time.Second
-	state.Timeout = time.Duration(timeoutMin) * time.Minute
-	state.MinTimeout = 2 * time.Second
-	opRaw, err := state.WaitForState()
-	if err != nil {
-		return fmt.Errorf("Error waiting for %s: %s", activity, err)
+	if err := w.SetOp(op); err != nil {
+		return err
 	}
-
-	op = opRaw.(*accesscontextmanager.Operation)
-	if op.Error != nil {
-		return fmt.Errorf("Error code %v, message: %s", op.Error.Code, op.Error.Message)
-	}
-
-	return nil
+	return OperationWait(w, activity, timeoutMinutes)
 }

google-beta/appengine_operation.go

@@ -2,12 +2,7 @@ package google
 
 import (
 	"fmt"
-	"log"
 	"regexp"
-	"strconv"
-	"time"
-
-	"github.com/hashicorp/terraform/helper/resource"
 
 	"google.golang.org/api/appengine/v1"
 )
@@ -18,73 +13,30 @@ var (
 
 type AppEngineOperationWaiter struct {
 	Service *appengine.APIService
-	Op      *appengine.Operation
 	AppId   string
+	CommonOperationWaiter
 }
 
-func (w *AppEngineOperationWaiter) RefreshFunc() resource.StateRefreshFunc {
-	return func() (interface{}, string, error) {
-		matches := appEngineOperationIdRegexp.FindStringSubmatch(w.Op.Name)
-		if len(matches) != 2 {
-			return nil, "", fmt.Errorf("Expected %d results of parsing operation name, got %d from %s", 2, len(matches), w.Op.Name)
-		}
-		op, err := w.Service.Apps.Operations.Get(w.AppId, matches[1]).Do()
-		if err != nil {
-			return nil, "", err
-		}
-
-		log.Printf("[DEBUG] Got %v when asking for operation %q", op.Done, w.Op.Name)
-		return op, strconv.FormatBool(op.Done), nil
+func (w *AppEngineOperationWaiter) QueryOp() (interface{}, error) {
+	matches := appEngineOperationIdRegexp.FindStringSubmatch(w.Op.Name)
+	if len(matches) != 2 {
+		return nil, fmt.Errorf("Expected %d results of parsing operation name, got %d from %s", 2, len(matches), w.Op.Name)
 	}
-}
-
-func (w *AppEngineOperationWaiter) Conf() *resource.StateChangeConf {
-	return &resource.StateChangeConf{
-		Pending: []string{"false"},
-		Target:  []string{"true"},
-		Refresh: w.RefreshFunc(),
-	}
-}
-
-// AppEngineOperationError wraps appengine.Status and implements the
-// error interface so it can be returned.
-type AppEngineOperationError appengine.Status
-
-func (e AppEngineOperationError) Error() string {
-	return e.Message
+	return w.Service.Apps.Operations.Get(w.AppId, matches[1]).Do()
 }
 
 func appEngineOperationWait(client *appengine.APIService, op *appengine.Operation, appId, activity string) error {
 	return appEngineOperationWaitTime(client, op, appId, activity, 4)
 }
 
-func appEngineOperationWaitTime(client *appengine.APIService, op *appengine.Operation, appId, activity string, timeoutMin int) error {
-	if op.Done {
-		if op.Error != nil {
-			return AppEngineOperationError(*op.Error)
-		}
-		return nil
-	}
-
+func appEngineOperationWaitTime(client *appengine.APIService, op *appengine.Operation, appId, activity string, timeoutMinutes int) error {
 	w := &AppEngineOperationWaiter{
 		Service: client,
-		Op:      op,
 		AppId:   appId,
 	}
 
-	state := w.Conf()
-	state.Delay = 10 * time.Second
-	state.Timeout = time.Duration(timeoutMin) * time.Minute
-	state.MinTimeout = 2 * time.Second
-	opRaw, err := state.WaitForState()
-	if err != nil {
-		return fmt.Errorf("Error waiting for %s: %s", activity, err)
+	if err := w.SetOp(op); err != nil {
+		return err
 	}
-
-	resultOp := opRaw.(*appengine.Operation)
-	if resultOp.Error != nil {
-		return AppEngineOperationError(*resultOp.Error)
-	}
-
-	return nil
+	return OperationWait(w, activity, timeoutMinutes)
 }

google-beta/cloudfunctions_operation.go

@@ -1,77 +1,24 @@
 package google
 
 import (
-	"fmt"
-	"log"
-	"time"
-
-	"github.com/hashicorp/terraform/helper/resource"
 	"google.golang.org/api/cloudfunctions/v1"
 )
 
 type CloudFunctionsOperationWaiter struct {
 	Service *cloudfunctions.Service
-	Op      *cloudfunctions.Operation
-}
-
-func (w *CloudFunctionsOperationWaiter) RefreshFunc() resource.StateRefreshFunc {
-	return func() (interface{}, string, error) {
-		op, err := w.Service.Operations.Get(w.Op.Name).Do()
-
-		if err != nil {
-			return nil, "", err
-		}
-
-		status := "PENDING"
-		if op.Done == true {
-			status = "DONE"
-		}
-
-		log.Printf("[DEBUG] Got %q when asking for operation %q", status, w.Op.Name)
-		return op, status, nil
-	}
-}
-
-func (w *CloudFunctionsOperationWaiter) Conf() *resource.StateChangeConf {
-	return &resource.StateChangeConf{
-		Pending: []string{"PENDING"},
-		Target:  []string{"DONE"},
-		Refresh: w.RefreshFunc(),
-	}
+	CommonOperationWaiter
 }
 
-func cloudFunctionsOperationWait(client *cloudfunctions.Service,
-	op *cloudfunctions.Operation, activity string) error {
-	return cloudFunctionsOperationWaitTime(client, op, activity, 4)
+func (w *CloudFunctionsOperationWaiter) QueryOp() (interface{}, error) {
+	return w.Service.Operations.Get(w.Op.Name).Do()
 }
 
-func cloudFunctionsOperationWaitTime(client *cloudfunctions.Service, op *cloudfunctions.Operation,
-	activity string, timeoutMin int) error {
-	if op.Done {
-		if op.Error != nil {
-			return fmt.Errorf(op.Error.Message)
-		}
-		return nil
-	}
-
+func cloudFunctionsOperationWait(service *cloudfunctions.Service, op *cloudfunctions.Operation, activity string) error {
 	w := &CloudFunctionsOperationWaiter{
-		Service: client,
-		Op:      op,
+		Service: service,
 	}
-
-	state := w.Conf()
-	state.Delay = 10 * time.Second
-	state.Timeout = time.Duration(timeoutMin) * time.Minute
-	state.MinTimeout = 2 * time.Second
-	opRaw, err := state.WaitForState()
-	if err != nil {
-		return fmt.Errorf("Error waiting for %s: %s", activity, err)
-	}
-
-	resultOp := opRaw.(*cloudfunctions.Operation)
-	if resultOp.Error != nil {
-		return fmt.Errorf(resultOp.Error.Message)
+	if err := w.SetOp(op); err != nil {
+		return err
 	}
-
-	return nil
+	return OperationWait(w, activity, 4)
 }