Refactored disk cloudprovider methods to use generated client; Refactored…

pkg/cloudprovider/providers/gce/BUILD

@@ -31,7 +31,6 @@ go_library(
         "gce_loadbalancer_internal.go",
         "gce_loadbalancer_naming.go",
         "gce_networkendpointgroup.go",
-        "gce_op.go",
         "gce_routes.go",
         "gce_securitypolicy.go",
         "gce_targetpool.go",

pkg/cloudprovider/providers/gce/cloud/BUILD

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "constants.go",
+        "context.go",
         "doc.go",
         "gce_projects.go",
         "gen.go",

pkg/cloudprovider/providers/gce/cloud/context.go

+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cloud
+
+import (
+	"context"
+	"time"
+)
+
+const (
+	defaultCallTimeout = 1 * time.Hour
+)
+
+// ContextWithCallTimeout returns a context with a default timeout, used for generated client calls.
+func ContextWithCallTimeout() (context.Context, context.CancelFunc) {
+	return context.WithTimeout(context.Background(), defaultCallTimeout)
+}

pkg/cloudprovider/providers/gce/cloud/meta/meta.go

@@ -160,22 +160,20 @@ var AllServices = []*ServiceInfo{
 		Resource:    "disks",
 		keyType:     Zonal,
 		serviceType: reflect.TypeOf(&ga.DisksService{}),
+		additionalMethods: []string{
+			"Resize",
 		},
-	{
-		Object:      "Disk",
-		Service:     "Disks",
-		Resource:    "disks",
-		version:     VersionAlpha,
-		keyType:     Zonal,
-		serviceType: reflect.TypeOf(&alpha.DisksService{}),
 	},
 	{
 		Object:      "Disk",
 		Service:     "RegionDisks",
 		Resource:    "disks",
-		version:     VersionAlpha,
+		version:     VersionBeta,
 		keyType:     Regional,
-		serviceType: reflect.TypeOf(&alpha.DisksService{}),
+		serviceType: reflect.TypeOf(&beta.RegionDisksService{}),
+		additionalMethods: []string{
+			"Resize",
+		},
 	},
 	{
 		Object:      "Firewall",

pkg/cloudprovider/providers/gce/gce_disks_test.go

@@ -70,9 +70,6 @@ func TestCreateDisk_Basic(t *testing.T) {
 	if !fakeManager.createDiskCalled {
 		t.Error("Never called GCE disk create.")
 	}
-	if !fakeManager.doesOpMatch {
-		t.Error("Ops used in WaitForZoneOp does not match what's returned by CreateDisk.")
-	}
 
 	// Partial check of equality between disk description sent to GCE and parameters of method.
 	diskToCreate := fakeManager.diskToCreateStable
@@ -127,9 +124,6 @@ func TestCreateRegionalDisk_Basic(t *testing.T) {
 	if !fakeManager.createDiskCalled {
 		t.Error("Never called GCE disk create.")
 	}
-	if !fakeManager.doesOpMatch {
-		t.Error("Ops used in WaitForZoneOp does not match what's returned by CreateDisk.")
-	}
 
 	// Partial check of equality between disk description sent to GCE and parameters of method.
 	diskToCreate := fakeManager.diskToCreateStable
@@ -165,7 +159,7 @@ func TestCreateDisk_DiskAlreadyExists(t *testing.T) {
 
 	// Inject disk AlreadyExists error.
 	alreadyExistsError := googleapi.ErrorItem{Reason: "alreadyExists"}
-	fakeManager.waitForOpError = &googleapi.Error{
+	fakeManager.opError = &googleapi.Error{
 		Errors: []googleapi.ErrorItem{alreadyExistsError},
 	}
 
@@ -314,9 +308,6 @@ func TestDeleteDisk_Basic(t *testing.T) {
 	if !fakeManager.deleteDiskCalled {
 		t.Error("Never called GCE disk delete.")
 	}
-	if !fakeManager.doesOpMatch {
-		t.Error("Ops used in WaitForZoneOp does not match what's returned by DeleteDisk.")
-	}
 
 }
 
@@ -647,13 +638,9 @@ type FakeServiceManager struct {
 	targetAPI     targetClientAPI
 	gceProjectID  string
 	gceRegion     string
-	opAlpha        *computealpha.Operation // Mocks an operation returned by GCE API calls
-	opBeta         *computebeta.Operation  // Mocks an operation returned by GCE API calls
-	opStable       *compute.Operation      // Mocks an operation returned by GCE API calls
-	doesOpMatch    bool
 	zonalDisks    map[string]string      // zone: diskName
 	regionalDisks map[string]sets.String // diskName: zones
-	waitForOpError error                  // Error to be returned by WaitForZoneOp or WaitForRegionalOp
+	opError       error
 
 	// Fields for TestCreateDisk
 	createDiskCalled   bool
@@ -684,12 +671,11 @@ func (manager *FakeServiceManager) CreateDiskOnCloudProvider(
 	sizeGb int64,
 	tagsStr string,
 	diskType string,
-	zone string) (gceObject, error) {
+	zone string) error {
 	manager.createDiskCalled = true
 
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
 		diskTypeURI := gceComputeAPIEndpoint + "projects/" + fmt.Sprintf(diskTypeURITemplateSingleZone, manager.gceProjectID, zone, diskType)
 		diskToCreateV1 := &compute.Disk{
 			Name:        name,
@@ -699,9 +685,8 @@ func (manager *FakeServiceManager) CreateDiskOnCloudProvider(
 		}
 		manager.diskToCreateStable = diskToCreateV1
 		manager.zonalDisks[zone] = diskToCreateV1.Name
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		manager.opBeta = &computebeta.Operation{}
 		diskTypeURI := gceComputeAPIEndpoint + "projects/" + fmt.Sprintf(diskTypeURITemplateSingleZone, manager.gceProjectID, zone, diskType)
 		diskToCreateBeta := &computebeta.Disk{
 			Name:        name,
@@ -711,9 +696,8 @@ func (manager *FakeServiceManager) CreateDiskOnCloudProvider(
 		}
 		manager.diskToCreateBeta = diskToCreateBeta
 		manager.zonalDisks[zone] = diskToCreateBeta.Name
-		return manager.opBeta, nil
+		return nil
 	case targetAlpha:
-		manager.opAlpha = &computealpha.Operation{}
 		diskTypeURI := gceComputeAPIEndpointBeta + "projects/" + fmt.Sprintf(diskTypeURITemplateSingleZone, manager.gceProjectID, zone, diskType)
 		diskToCreateAlpha := &computealpha.Disk{
 			Name:        name,
@@ -723,9 +707,9 @@ func (manager *FakeServiceManager) CreateDiskOnCloudProvider(
 		}
 		manager.diskToCreateAlpha = diskToCreateAlpha
 		manager.zonalDisks[zone] = diskToCreateAlpha.Name
-		return manager.opAlpha, nil
+		return nil
 	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
 }
 
@@ -738,13 +722,12 @@ func (manager *FakeServiceManager) CreateRegionalDiskOnCloudProvider(
 	sizeGb int64,
 	tagsStr string,
 	diskType string,
-	zones sets.String) (gceObject, error) {
+	zones sets.String) error {
 	manager.createDiskCalled = true
 	diskTypeURI := gceComputeAPIEndpointBeta + "projects/" + fmt.Sprintf(diskTypeURITemplateRegional, manager.gceProjectID, manager.gceRegion, diskType)
 
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
 		diskToCreateV1 := &compute.Disk{
 			Name:        name,
 			SizeGb:      sizeGb,
@@ -753,13 +736,13 @@ func (manager *FakeServiceManager) CreateRegionalDiskOnCloudProvider(
 		}
 		manager.diskToCreateStable = diskToCreateV1
 		manager.regionalDisks[diskToCreateV1.Name] = zones
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		return nil, fmt.Errorf("RegionalDisk CreateDisk op not supported in beta.")
+		return fmt.Errorf("RegionalDisk CreateDisk op not supported in beta.")
 	case targetAlpha:
-		return nil, fmt.Errorf("RegionalDisk CreateDisk op not supported in alpha.")
+		return fmt.Errorf("RegionalDisk CreateDisk op not supported in alpha.")
 	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
 }
 
@@ -767,39 +750,33 @@ func (manager *FakeServiceManager) AttachDiskOnCloudProvider(
 	disk *GCEDisk,
 	readWrite string,
 	instanceZone string,
-	instanceName string) (gceObject, error) {
+	instanceName string) error {
 
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		manager.opBeta = &computebeta.Operation{}
-		return manager.opBeta, nil
+		return nil
 	case targetAlpha:
-		manager.opAlpha = &computealpha.Operation{}
-		return manager.opAlpha, nil
+		return nil
 	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
 }
 
 func (manager *FakeServiceManager) DetachDiskOnCloudProvider(
 	instanceZone string,
 	instanceName string,
-	devicePath string) (gceObject, error) {
+	devicePath string) error {
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		manager.opBeta = &computebeta.Operation{}
-		return manager.opBeta, nil
+		return nil
 	case targetAlpha:
-		manager.opAlpha = &computealpha.Operation{}
-		return manager.opAlpha, nil
+		return nil
 	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
 }
 
@@ -856,13 +833,13 @@ func (manager *FakeServiceManager) GetRegionalDiskFromCloudProvider(
 func (manager *FakeServiceManager) ResizeDiskOnCloudProvider(
 	disk *GCEDisk,
 	size int64,
-	zone string) (gceObject, error) {
+	zone string) error {
 	panic("Not implmented")
 }
 
 func (manager *FakeServiceManager) RegionalResizeDiskOnCloudProvider(
 	disk *GCEDisk,
-	size int64) (gceObject, error) {
+	size int64) error {
 	panic("Not implemented")
 }
 
@@ -871,89 +848,39 @@ func (manager *FakeServiceManager) RegionalResizeDiskOnCloudProvider(
  */
 func (manager *FakeServiceManager) DeleteDiskOnCloudProvider(
 	zone string,
-	disk string) (gceObject, error) {
+	disk string) error {
 
 	manager.deleteDiskCalled = true
 	delete(manager.zonalDisks, zone)
 
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		manager.opBeta = &computebeta.Operation{}
-		return manager.opBeta, nil
+		return nil
 	case targetAlpha:
-		manager.opAlpha = &computealpha.Operation{}
-		return manager.opAlpha, nil
+		return nil
 	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
 }
 
 func (manager *FakeServiceManager) DeleteRegionalDiskOnCloudProvider(
-	disk string) (gceObject, error) {
+	disk string) error {
 
 	manager.deleteDiskCalled = true
 	delete(manager.regionalDisks, disk)
 
 	switch t := manager.targetAPI; t {
 	case targetStable:
-		manager.opStable = &compute.Operation{}
-		return manager.opStable, nil
+		return nil
 	case targetBeta:
-		manager.opBeta = &computebeta.Operation{}
-		return manager.opBeta, nil
+		return nil
 	case targetAlpha:
-		manager.opAlpha = &computealpha.Operation{}
-		return manager.opAlpha, nil
-	default:
-		return nil, fmt.Errorf("unexpected type: %T", t)
-	}
-}
-
-func (manager *FakeServiceManager) WaitForZoneOp(
-	op gceObject,
-	zone string,
-	mc *metricContext) error {
-	switch v := op.(type) {
-	case *computealpha.Operation:
-		if op.(*computealpha.Operation) == manager.opAlpha {
-			manager.doesOpMatch = true
-		}
-	case *computebeta.Operation:
-		if op.(*computebeta.Operation) == manager.opBeta {
-			manager.doesOpMatch = true
-		}
-	case *compute.Operation:
-		if op.(*compute.Operation) == manager.opStable {
-			manager.doesOpMatch = true
-		}
-	default:
-		return fmt.Errorf("unexpected type: %T", v)
-	}
-	return manager.waitForOpError
-}
-
-func (manager *FakeServiceManager) WaitForRegionalOp(
-	op gceObject, mc *metricContext) error {
-	switch v := op.(type) {
-	case *computealpha.Operation:
-		if op.(*computealpha.Operation) == manager.opAlpha {
-			manager.doesOpMatch = true
-		}
-	case *computebeta.Operation:
-		if op.(*computebeta.Operation) == manager.opBeta {
-			manager.doesOpMatch = true
-		}
-	case *compute.Operation:
-		if op.(*compute.Operation) == manager.opStable {
-			manager.doesOpMatch = true
-		}
+		return nil
 	default:
-		return fmt.Errorf("unexpected type: %T", v)
+		return fmt.Errorf("unexpected type: %T", t)
 	}
-	return manager.waitForOpError
 }
 
 func createNodeZones(zones []string) map[string]sets.String {

pkg/cloudprovider/providers/gce/gce_op.go

-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package gce
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/wait"
-
-	"github.com/golang/glog"
-	computealpha "google.golang.org/api/compute/v0.alpha"
-	computebeta "google.golang.org/api/compute/v0.beta"
-	computev1 "google.golang.org/api/compute/v1"
-	"google.golang.org/api/googleapi"
-)
-
-func (gce *GCECloud) waitForOp(op *computev1.Operation, getOperation func(operationName string) (*computev1.Operation, error), mc *metricContext) error {
-	if op == nil {
-		return mc.Observe(fmt.Errorf("operation must not be nil"))
-	}
-
-	if opIsDone(op) {
-		return getErrorFromOp(op)
-	}
-
-	opStart := time.Now()
-	opName := op.Name
-
-	return wait.Poll(operationPollInterval, operationPollTimeoutDuration, func() (bool, error) {
-		start := time.Now()
-		gce.operationPollRateLimiter.Accept()
-		duration := time.Since(start)
-		if duration > 5*time.Second {
-			glog.V(2).Infof("pollOperation: throttled %v for %v", duration, opName)
-		}
-		pollOp, err := getOperation(opName)
-		if err != nil {
-			glog.Warningf("GCE poll operation %s failed: pollOp: [%v] err: [%v] getErrorFromOp: [%v]",
-				opName, pollOp, err, getErrorFromOp(pollOp))
-		}
-
-		done := opIsDone(pollOp)
-		if done {
-			duration := time.Since(opStart)
-			if duration > 1*time.Minute {
-				// Log the JSON. It's cleaner than the %v structure.
-				enc, err := pollOp.MarshalJSON()
-				if err != nil {
-					glog.Warningf("waitForOperation: long operation (%v): %v (failed to encode to JSON: %v)",
-						duration, pollOp, err)
-				} else {
-					glog.V(2).Infof("waitForOperation: long operation (%v): %v",
-						duration, string(enc))
-				}
-			}
-		}
-
-		return done, mc.Observe(getErrorFromOp(pollOp))
-	})
-}
-
-func opIsDone(op *computev1.Operation) bool {
-	return op != nil && op.Status == "DONE"
-}
-
-func getErrorFromOp(op *computev1.Operation) error {
-	if op != nil && op.Error != nil && len(op.Error.Errors) > 0 {
-		err := &googleapi.Error{
-			Code:    int(op.HttpErrorStatusCode),
-			Message: op.Error.Errors[0].Message,
-		}
-		glog.Errorf("GCE operation failed: %v", err)
-		return err
-	}
-
-	return nil
-}
-
-func (gce *GCECloud) waitForGlobalOp(op gceObject, mc *metricContext) error {
-	return gce.waitForGlobalOpInProject(op, gce.ProjectID(), mc)
-}
-
-func (gce *GCECloud) waitForRegionOp(op gceObject, region string, mc *metricContext) error {
-	return gce.waitForRegionOpInProject(op, gce.ProjectID(), region, mc)
-}
-
-func (gce *GCECloud) waitForZoneOp(op gceObject, zone string, mc *metricContext) error {
-	return gce.waitForZoneOpInProject(op, gce.ProjectID(), zone, mc)
-}
-
-func (gce *GCECloud) waitForGlobalOpInProject(op gceObject, projectID string, mc *metricContext) error {
-	switch v := op.(type) {
-	case *computealpha.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceAlpha.GlobalOperations.Get(projectID, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computebeta.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceBeta.GlobalOperations.Get(projectID, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computev1.Operation:
-		return gce.waitForOp(op.(*computev1.Operation), func(operationName string) (*computev1.Operation, error) {
-			return gce.service.GlobalOperations.Get(projectID, operationName).Do()
-		}, mc)
-	default:
-		return fmt.Errorf("unexpected type: %T", v)
-	}
-}
-
-func (gce *GCECloud) waitForRegionOpInProject(op gceObject, projectID, region string, mc *metricContext) error {
-	switch v := op.(type) {
-	case *computealpha.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceAlpha.RegionOperations.Get(projectID, region, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computebeta.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceBeta.RegionOperations.Get(projectID, region, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computev1.Operation:
-		return gce.waitForOp(op.(*computev1.Operation), func(operationName string) (*computev1.Operation, error) {
-			return gce.service.RegionOperations.Get(projectID, region, operationName).Do()
-		}, mc)
-	default:
-		return fmt.Errorf("unexpected type: %T", v)
-	}
-}
-
-func (gce *GCECloud) waitForZoneOpInProject(op gceObject, projectID, zone string, mc *metricContext) error {
-	switch v := op.(type) {
-	case *computealpha.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceAlpha.ZoneOperations.Get(projectID, zone, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computebeta.Operation:
-		return gce.waitForOp(convertToV1Operation(op), func(operationName string) (*computev1.Operation, error) {
-			op, err := gce.serviceBeta.ZoneOperations.Get(projectID, zone, operationName).Do()
-			return convertToV1Operation(op), err
-		}, mc)
-	case *computev1.Operation:
-		return gce.waitForOp(op.(*computev1.Operation), func(operationName string) (*computev1.Operation, error) {
-			return gce.service.ZoneOperations.Get(projectID, zone, operationName).Do()
-		}, mc)
-	default:
-		return fmt.Errorf("unexpected type: %T", v)
-	}
-}
-
-func convertToV1Operation(object gceObject) *computev1.Operation {
-	enc, err := object.MarshalJSON()
-	if err != nil {
-		panic(fmt.Sprintf("Failed to encode to json: %v", err))
-	}
-	var op computev1.Operation
-	if err := json.Unmarshal(enc, &op); err != nil {
-		panic(fmt.Sprintf("Failed to convert GCE apiObject %v to v1 operation: %v", object, err))
-	}
-	return &op
-}

pkg/cloudprovider/providers/gce/gce_test.go

@@ -18,16 +18,12 @@ package gce
 
 import (
 	"context"
-	"encoding/json"
 	"reflect"
 	"strings"
 	"testing"
 
 	"golang.org/x/oauth2/google"
 
-	computealpha "google.golang.org/api/compute/v0.alpha"
-	computebeta "google.golang.org/api/compute/v0.beta"
-	computev1 "google.golang.org/api/compute/v1"
 	"k8s.io/kubernetes/pkg/cloudprovider"
 )
 
@@ -480,56 +476,6 @@ func TestGenerateCloudConfigs(t *testing.T) {
 	}
 }
 
-func TestConvertToV1Operation(t *testing.T) {
-	v1Op := getTestOperation()
-	enc, _ := v1Op.MarshalJSON()
-	var op interface{}
-	var alphaOp computealpha.Operation
-	var betaOp computebeta.Operation
-
-	if err := json.Unmarshal(enc, &alphaOp); err != nil {
-		t.Errorf("Failed to unmarshal operation: %v", err)
-	}
-
-	if err := json.Unmarshal(enc, &betaOp); err != nil {
-		t.Errorf("Failed to unmarshal operation: %v", err)
-	}
-
-	op = convertToV1Operation(&alphaOp)
-	if _, ok := op.(*computev1.Operation); ok {
-		if !reflect.DeepEqual(op, v1Op) {
-			t.Errorf("Failed to maintain consistency across conversion")
-		}
-	} else {
-		t.Errorf("Expect output to be type v1 operation, but got %v", op)
-	}
-
-	op = convertToV1Operation(&betaOp)
-	if _, ok := op.(*computev1.Operation); ok {
-		if !reflect.DeepEqual(op, v1Op) {
-			t.Errorf("Failed to maintain consistency across conversion")
-		}
-	} else {
-		t.Errorf("Expect output to be type v1 operation, but got %v", op)
-	}
-}
-
-func getTestOperation() *computev1.Operation {
-	return &computev1.Operation{
-		Name:        "test",
-		Description: "test",
-		Id:          uint64(12345),
-		Error: &computev1.OperationError{
-			Errors: []*computev1.OperationErrorErrors{
-				{
-					Code:    "555",
-					Message: "error",
-				},
-			},
-		},
-	}
-}
-
 func TestNewAlphaFeatureGate(t *testing.T) {
 	testCases := []struct {
 		alphaFeatures  []string