github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 19:31:44 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #51539 from saad-ali/enableAlphaGCEDiskAPI

Browse Source 
Automatic merge from submit-queue (batch tested with PRs 51439, 51361, 51140, 51539, 51585)

Enable alpha GCE disk API

This PR builds on top of #50467 to allow the GCE disk API to use either the alpha or stable APIs.

CC @freehan
This commit is contained in:
Kubernetes Submit Queue 2017-08-30 03:59:35 -07:00 committed by GitHub
commit a0fe767fa5
5 changed files with 390 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
pkg/cloudprovider/providers/gce/gce.go
View File

@ -131,16 +131,36 @@ type GCECloud struct {
type ServiceManager interface {
// Creates a new persistent disk on GCE with the given disk spec.
CreateDisk(project string, zone string, disk *compute.Disk) (*compute.Operation, error)
CreateDisk(
name string,
sizeGb int64,
tagsStr string,
diskTypeURI string,
zone string) (gceObject, error)
// Attach a persistent disk on GCE with the given disk spec to the specified instance.
AttachDisk(diskName string,
diskKind string,
diskZone string,
readWrite string,
source string,
diskType string,
instanceName string) (gceObject, error)
// Detach a persistent disk on GCE with the given disk spec from the specified instance.
DetachDisk(
instanceZone string,
instanceName string,
devicePath string) (gceObject, error)
// Gets the persistent disk from GCE with the given diskName.
GetDisk(project string, zone string, diskName string) (*compute.Disk, error)
GetDisk(project string, zone string, diskName string) (*GCEDisk, error)
// Deletes the persistent disk from GCE with the given diskName.
DeleteDisk(project string, zone string, disk string) (*compute.Operation, error)
DeleteDisk(project string, zone string, disk string) (gceObject, error)
// Waits until GCE reports the given operation in the given zone as done.
WaitForZoneOp(op *compute.Operation, zone string, mc *metricContext) error
WaitForZoneOp(op gceObject, zone string, mc *metricContext) error
}
type GCEServiceManager struct {
@ -717,29 +737,118 @@ func newOauthClient(tokenSource oauth2.TokenSource) (*http.Client, error) {
}
func (manager *GCEServiceManager) CreateDisk(
project string,
zone string,
disk *compute.Disk) (*compute.Operation, error) {
name string,
sizeGb int64,
tagsStr string,
diskTypeURI string,
zone string) (gceObject, error) {
if manager.gce.AlphaFeatureGate.Enabled(GCEDiskAlphaFeatureGate) {
diskToCreateAlpha := &computealpha.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeURI,
}
return manager.gce.serviceAlpha.Disks.Insert(manager.gce.projectID, zone, diskToCreateAlpha).Do()
}
return manager.gce.service.Disks.Insert(project, zone, disk).Do()
diskToCreateV1 := &compute.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeURI,
}
return manager.gce.service.Disks.Insert(manager.gce.projectID, zone, diskToCreateV1).Do()
}
func (manager *GCEServiceManager) AttachDisk(
diskName string,
diskKind string,
diskZone string,
readWrite string,
source string,
diskType string,
instanceName string) (gceObject, error) {
if manager.gce.AlphaFeatureGate.Enabled(GCEDiskAlphaFeatureGate) {
attachedDiskAlpha := &computealpha.AttachedDisk{
DeviceName: diskName,
Kind: diskKind,
Mode: readWrite,
Source: source,
Type: diskType,
}
return manager.gce.serviceAlpha.Instances.AttachDisk(
manager.gce.projectID, diskZone, instanceName, attachedDiskAlpha).Do()
}
attachedDiskV1 := &compute.AttachedDisk{
DeviceName: diskName,
Kind: diskKind,
Mode: readWrite,
Source: source,
Type: diskType,
}
return manager.gce.service.Instances.AttachDisk(
manager.gce.projectID, diskZone, instanceName, attachedDiskV1).Do()
}
func (manager *GCEServiceManager) DetachDisk(
instanceZone string,
instanceName string,
devicePath string) (gceObject, error) {
if manager.gce.AlphaFeatureGate.Enabled(GCEDiskAlphaFeatureGate) {
manager.gce.serviceAlpha.Instances.DetachDisk(
manager.gce.projectID, instanceZone, instanceName, devicePath).Do()
}
return manager.gce.service.Instances.DetachDisk(
manager.gce.projectID, instanceZone, instanceName, devicePath).Do()
}
func (manager *GCEServiceManager) GetDisk(
project string,
zone string,
diskName string) (*compute.Disk, error) {
diskName string) (*GCEDisk, error) {
return manager.gce.service.Disks.Get(project, zone, diskName).Do()
if manager.gce.AlphaFeatureGate.Enabled(GCEDiskAlphaFeatureGate) {
diskAlpha, err := manager.gce.serviceAlpha.Disks.Get(project, zone, diskName).Do()
if err != nil {
return nil, err
}
return &GCEDisk{
Zone: lastComponent(diskAlpha.Zone),
Name: diskAlpha.Name,
Kind: diskAlpha.Kind,
Type: diskAlpha.Type,
}, nil
}
diskStable, err := manager.gce.service.Disks.Get(project, zone, diskName).Do()
if err != nil {
return nil, err
}
return &GCEDisk{
Zone: lastComponent(diskStable.Zone),
Name: diskStable.Name,
Kind: diskStable.Kind,
Type: diskStable.Type,
}, nil
}
func (manager *GCEServiceManager) DeleteDisk(
project string,
zone string,
diskName string) (*compute.Operation, error) {
diskName string) (gceObject, error) {
if manager.gce.AlphaFeatureGate.Enabled(GCEDiskAlphaFeatureGate) {
return manager.gce.serviceAlpha.Disks.Delete(project, zone, diskName).Do()
}
return manager.gce.service.Disks.Delete(project, zone, diskName).Do()
}
func (manager *GCEServiceManager) WaitForZoneOp(op *compute.Operation, zone string, mc *metricContext) error {
func (manager *GCEServiceManager) WaitForZoneOp(op gceObject, zone string, mc *metricContext) error {
return manager.gce.waitForZoneOp(op, zone, mc)
}

8
pkg/cloudprovider/providers/gce/gce_alpha.go
View File

@ -23,7 +23,13 @@ import (
)
// All known alpha features
var knownAlphaFeatures = map[string]bool{}
var knownAlphaFeatures = map[string]bool{
GCEDiskAlphaFeatureGate: true,
}
const (
GCEDiskAlphaFeatureGate = "GCEDiskAlphaAPI"
)
type AlphaFeatureGate struct {
features map[string]bool

47
pkg/cloudprovider/providers/gce/gce_disks.go
View File

@ -28,7 +28,6 @@ import (
"k8s.io/kubernetes/pkg/volume"
"github.com/golang/glog"
compute "google.golang.org/api/compute/v1"
"google.golang.org/api/googleapi"
)
@ -40,6 +39,7 @@ const (
diskTypeDefault = DiskTypeStandard
diskTypeUriTemplate = "%s/zones/%s/diskTypes/%s"
diskTypePersistent = "PERSISTENT"
)
// Disks is interface for manipulation with GCE PDs.
@ -101,17 +101,18 @@ func (gce *GCECloud) AttachDisk(diskName string, nodeName types.NodeName, readOn
if readOnly {
readWrite = "READ_ONLY"
}
attachedDisk := gce.convertDiskToAttachedDisk(disk, readWrite)
mc := newDiskMetricContext("attach", instance.Zone)
attachOp, err := gce.service.Instances.AttachDisk(
gce.projectID, disk.Zone, instance.Name, attachedDisk).Do()
source := gce.service.BasePath + strings.Join([]string{
gce.projectID, "zones", disk.Zone, "disks", disk.Name}, "/")
attachOp, err := gce.manager.AttachDisk(
disk.Name, disk.Kind, disk.Zone, readWrite, source, diskTypePersistent, instance.Name)
if err != nil {
return mc.Observe(err)
}
return gce.waitForZoneOp(attachOp, disk.Zone, mc)
return gce.manager.WaitForZoneOp(attachOp, disk.Zone, mc)
}
func (gce *GCECloud) DetachDisk(devicePath string, nodeName types.NodeName) error {
@ -131,12 +132,12 @@ func (gce *GCECloud) DetachDisk(devicePath string, nodeName types.NodeName) erro
}
mc := newDiskMetricContext("detach", inst.Zone)
detachOp, err := gce.service.Instances.DetachDisk(gce.projectID, inst.Zone, inst.Name, devicePath).Do()
detachOp, err := gce.manager.DetachDisk(inst.Zone, inst.Name, devicePath)
if err != nil {
return mc.Observe(err)
}
return gce.waitForZoneOp(detachOp, inst.Zone, mc)
return gce.manager.WaitForZoneOp(detachOp, inst.Zone, mc)
}
func (gce *GCECloud) DiskIsAttached(diskName string, nodeName types.NodeName) (bool, error) {
@ -236,15 +237,11 @@ func (gce *GCECloud) CreateDisk(
}
diskTypeUri := projectsApiEndpoint + fmt.Sprintf(diskTypeUriTemplate, gce.projectID, zone, diskType)
diskToCreate := &compute.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeUri,
}
mc := newDiskMetricContext("create", zone)
createOp, err := gce.manager.CreateDisk(gce.projectID, zone, diskToCreate)
createOp, err := gce.manager.CreateDisk(
name, sizeGb, tagsStr, diskTypeUri, zone)
if isGCEError(err, "alreadyExists") {
glog.Warningf("GCE PD %q already exists, reusing", name)
return nil
@ -325,13 +322,7 @@ func (gce *GCECloud) findDiskByName(diskName string, zone string) (*GCEDisk, err
mc := newDiskMetricContext("get", zone)
disk, err := gce.manager.GetDisk(gce.projectID, zone, diskName)
if err == nil {
d := &GCEDisk{
Zone: lastComponent(disk.Zone),
Name: disk.Name,
Kind: disk.Kind,
Type: disk.Type,
}
return d, mc.Observe(nil)
return disk, mc.Observe(nil)
}
if !isHTTPErrorCode(err, http.StatusNotFound) {
return nil, mc.Observe(err)
@ -418,18 +409,6 @@ func (gce *GCECloud) doDeleteDisk(diskToDelete string) error {
return gce.manager.WaitForZoneOp(deleteOp, disk.Zone, mc)
}
// Converts a Disk resource to an AttachedDisk resource.
func (gce *GCECloud) convertDiskToAttachedDisk(disk *GCEDisk, readWrite string) *compute.AttachedDisk {
return &compute.AttachedDisk{
DeviceName: disk.Name,
Kind: disk.Kind,
Mode: readWrite,
Source: gce.service.BasePath + strings.Join([]string{
gce.projectID, "zones", disk.Zone, "disks", disk.Name}, "/"),
Type: "PERSISTENT",
}
}
// isGCEError returns true if given error is a googleapi.Error with given
// reason (e.g. "resourceInUseByAnotherResource")
func isGCEError(err error, reason string) bool {

278
pkg/cloudprovider/providers/gce/gce_disks_test.go
View File

@ -20,6 +20,9 @@ import (
"testing"
"fmt"
computealpha "google.golang.org/api/compute/v0.alpha"
computebeta "google.golang.org/api/compute/v0.beta"
compute "google.golang.org/api/compute/v1"
"google.golang.org/api/googleapi"
"k8s.io/kubernetes/pkg/cloudprovider"
@ -30,10 +33,15 @@ func TestCreateDisk_Basic(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
projectId := "test-project"
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1"},
projectID: projectId,
manager: fakeManager,
managedZones: []string{"zone1"},
projectID: projectId,
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
@ -61,7 +69,7 @@ func TestCreateDisk_Basic(t *testing.T) {
}
// Partial check of equality between disk description sent to GCE and parameters of method.
diskToCreate := fakeManager.diskToCreate
diskToCreate := fakeManager.diskToCreateStable
if diskToCreate.Name != diskName {
t.Errorf("Expected disk name: %s; Actual: %s", diskName, diskToCreate.Name)
}
@ -80,7 +88,15 @@ func TestCreateDisk_Basic(t *testing.T) {
func TestCreateDisk_DiskAlreadyExists(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1"},
AlphaFeatureGate: alphaFeatureGate,
}
// Inject disk AlreadyExists error.
alreadyExistsError := googleapi.ErrorItem{Reason: "alreadyExists"}
@ -156,7 +172,15 @@ func TestCreateDisk_BadDiskType(t *testing.T) {
func TestCreateDisk_MultiZone(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1", "zone2", "zone3"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1", "zone2", "zone3"},
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
diskType := DiskTypeStandard
@ -175,7 +199,15 @@ func TestCreateDisk_MultiZone(t *testing.T) {
func TestDeleteDisk_Basic(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1"},
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
diskType := DiskTypeSSD
zone := "zone1"
@ -217,7 +249,15 @@ func TestDeleteDisk_NotFound(t *testing.T) {
func TestDeleteDisk_ResourceBeingUsed(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1"},
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
diskType := DiskTypeSSD
zone := "zone1"
@ -238,7 +278,15 @@ func TestDeleteDisk_ResourceBeingUsed(t *testing.T) {
func TestDeleteDisk_SameDiskMultiZone(t *testing.T) {
/* Assert */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1", "zone2", "zone3"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1", "zone2", "zone3"},
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
diskType := DiskTypeSSD
const sizeGb int64 = 128
@ -262,7 +310,15 @@ func TestDeleteDisk_SameDiskMultiZone(t *testing.T) {
func TestDeleteDisk_DiffDiskMultiZone(t *testing.T) {
/* Arrange */
fakeManager := newFakeManager()
gce := GCECloud{manager: fakeManager, managedZones: []string{"zone1"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"zone1"},
AlphaFeatureGate: alphaFeatureGate,
}
diskName := "disk"
diskType := DiskTypeSSD
const sizeGb int64 = 128
@ -290,7 +346,15 @@ func TestGetAutoLabelsForPD_Basic(t *testing.T) {
diskType := DiskTypeSSD
zone := "us-central1-c"
const sizeGb int64 = 128
gce := GCECloud{manager: fakeManager, managedZones: []string{zone}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{zone},
AlphaFeatureGate: alphaFeatureGate,
}
gce.CreateDisk(diskName, diskType, zone, sizeGb, nil)
@ -317,7 +381,15 @@ func TestGetAutoLabelsForPD_NoZone(t *testing.T) {
diskType := DiskTypeStandard
zone := "europe-west1-d"
const sizeGb int64 = 128
gce := GCECloud{manager: fakeManager, managedZones: []string{zone}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{zone},
AlphaFeatureGate: alphaFeatureGate,
}
gce.CreateDisk(diskName, diskType, zone, sizeGb, nil)
/* Act */
@ -375,7 +447,15 @@ func TestGetAutoLabelsForPD_DupDisk(t *testing.T) {
zone := "us-west1-b"
const sizeGb int64 = 128
gce := GCECloud{manager: fakeManager, managedZones: []string{"us-west1-b", "asia-southeast1-a"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"us-west1-b", "asia-southeast1-a"},
AlphaFeatureGate: alphaFeatureGate,
}
for _, zone := range gce.managedZones {
gce.CreateDisk(diskName, diskType, zone, sizeGb, nil)
}
@ -403,7 +483,15 @@ func TestGetAutoLabelsForPD_DupDiskNoZone(t *testing.T) {
diskType := DiskTypeStandard
const sizeGb int64 = 128
gce := GCECloud{manager: fakeManager, managedZones: []string{"us-west1-b", "asia-southeast1-a"}}
alphaFeatureGate, featureGateErr := NewAlphaFeatureGate([]string{})
if featureGateErr != nil {
t.Error(featureGateErr)
}
gce := GCECloud{
manager: fakeManager,
managedZones: []string{"us-west1-b", "asia-southeast1-a"},
AlphaFeatureGate: alphaFeatureGate,
}
for _, zone := range gce.managedZones {
gce.CreateDisk(diskName, diskType, zone, sizeGb, nil)
}
@ -417,16 +505,29 @@ func TestGetAutoLabelsForPD_DupDiskNoZone(t *testing.T) {
}
}
type targetClientAPI int
const (
targetStable targetClientAPI = iota
targetBeta
targetAlpha
)
type FakeServiceManager struct {
// Common fields shared among tests
op *compute.Operation // Mocks an operation returned by GCE API calls
targetAPI targetClientAPI
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
disks map[string]string // zone: diskName
waitForZoneOpError error // Error to be returned by WaitForZoneOp
// Fields for TestCreateDisk
createDiskCalled bool
diskToCreate *compute.Disk
createDiskCalled bool
diskToCreateAlpha *computealpha.Disk
diskToCreateBeta *computebeta.Disk
diskToCreateStable *compute.Disk
// Fields for TestDeleteDisk
deleteDiskCalled bool
@ -442,16 +543,93 @@ func newFakeManager() *FakeServiceManager {
* to be used by other tested methods.
*/
func (manager *FakeServiceManager) CreateDisk(
project string,
zone string,
disk *compute.Disk) (*compute.Operation, error) {
name string,
sizeGb int64,
tagsStr string,
diskTypeURI string,
zone string) (gceObject, error) {
manager.createDiskCalled = true
op := &compute.Operation{}
manager.op = op
manager.diskToCreate = disk
manager.disks[zone] = disk.Name
return op, nil
switch t := manager.targetAPI; t {
case targetStable:
manager.opStable = &compute.Operation{}
diskToCreateV1 := &compute.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeURI,
}
manager.diskToCreateStable = diskToCreateV1
manager.disks[zone] = diskToCreateV1.Name
return manager.opStable, nil
case targetBeta:
manager.opBeta = &computebeta.Operation{}
diskToCreateBeta := &computebeta.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeURI,
}
manager.diskToCreateBeta = diskToCreateBeta
manager.disks[zone] = diskToCreateBeta.Name
return manager.opBeta, nil
case targetAlpha:
manager.opAlpha = &computealpha.Operation{}
diskToCreateAlpha := &computealpha.Disk{
Name: name,
SizeGb: sizeGb,
Description: tagsStr,
Type: diskTypeURI,
}
manager.diskToCreateAlpha = diskToCreateAlpha
manager.disks[zone] = diskToCreateAlpha.Name
return manager.opAlpha, nil
default:
return nil, fmt.Errorf("unexpected type: %T", t)
}
}
func (manager *FakeServiceManager) AttachDisk(
diskName string,
diskKind string,
diskZone string,
readWrite string,
source string,
diskType string,
instanceName string) (gceObject, error) {
switch t := manager.targetAPI; t {
case targetStable:
manager.opStable = &compute.Operation{}
return manager.opStable, nil
case targetBeta:
manager.opBeta = &computebeta.Operation{}
return manager.opBeta, nil
case targetAlpha:
manager.opAlpha = &computealpha.Operation{}
return manager.opAlpha, nil
default:
return nil, fmt.Errorf("unexpected type: %T", t)
}
}
func (manager *FakeServiceManager) DetachDisk(
instanceZone string,
instanceName string,
devicePath string) (gceObject, error) {
switch t := manager.targetAPI; t {
case targetStable:
manager.opStable = &compute.Operation{}
return manager.opStable, nil
case targetBeta:
manager.opBeta = &computebeta.Operation{}
return manager.opBeta, nil
case targetAlpha:
manager.opAlpha = &computealpha.Operation{}
return manager.opAlpha, nil
default:
return nil, fmt.Errorf("unexpected type: %T", t)
}
}
/**
@ -460,7 +638,7 @@ func (manager *FakeServiceManager) CreateDisk(
func (manager *FakeServiceManager) GetDisk(
project string,
zone string,
diskName string) (*compute.Disk, error) {
diskName string) (*GCEDisk, error) {
if manager.disks[zone] == "" {
return nil, cloudprovider.DiskNotFound
@ -472,8 +650,12 @@ func (manager *FakeServiceManager) GetDisk(
return nil, err
}
disk := &compute.Disk{Name: diskName, Zone: zone, Kind: "compute#disk"}
return disk, nil
return &GCEDisk{
Zone: lastComponent(zone),
Name: diskName,
Kind: "compute#disk",
Type: "type",
}, nil
}
/**
@ -482,21 +664,45 @@ func (manager *FakeServiceManager) GetDisk(
func (manager *FakeServiceManager) DeleteDisk(
project string,
zone string,
disk string) (*compute.Operation, error) {
disk string) (gceObject, error) {
manager.deleteDiskCalled = true
op := &compute.Operation{}
manager.op = op
manager.disks[zone] = ""
return op, nil
switch t := manager.targetAPI; t {
case targetStable:
manager.opStable = &compute.Operation{}
return manager.opStable, nil
case targetBeta:
manager.opBeta = &computebeta.Operation{}
return manager.opBeta, 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 *compute.Operation,
op gceObject,
zone string,
mc *metricContext) error {
if op == manager.op {
manager.doesOpMatch = true
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.waitForZoneOpError
}

8
test/e2e/e2e.go
View File

@ -78,6 +78,11 @@ func setupProviderConfig() error {
managedZones = []string{zone}
}
gceAlphaFeatureGate, err := gcecloud.NewAlphaFeatureGate([]string{})
if err != nil {
glog.Errorf("Encountered error for creating alpha feature gate: %v", err)
}
gceCloud, err := gcecloud.CreateGCECloud(&gcecloud.CloudConfig{
ApiEndpoint: framework.TestContext.CloudConfig.ApiEndpoint,
ProjectID: framework.TestContext.CloudConfig.ProjectID,
@ -89,7 +94,8 @@ func setupProviderConfig() error {
NodeTags: nil,
NodeInstancePrefix: "",
TokenSource: nil,
UseMetadataServer: false})
UseMetadataServer: false,
AlphaFeatureGate: gceAlphaFeatureGate})
if err != nil {
return fmt.Errorf("Error building GCE/GKE provider: %v", err)