github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed lint errors for pkg/cloudprovider/providers/gce.

Browse Source 
Fixed minor issues.
Cleaned up from merge errors.
This commit is contained in:
walter 2018-10-20 00:14:19 -07:00 committed by Walter Fender
parent 8616687c90
commit 735ad9ed63
49 changed files with 1086 additions and 1039 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hack/.golint_failures
View File

@ -88,7 +88,6 @@ pkg/apis/storage/v1beta1/util
pkg/auth/authorizer/abac pkg/auth/authorizer/abac
pkg/capabilities pkg/capabilities
pkg/cloudprovider/providers/fake pkg/cloudprovider/providers/fake
pkg/cloudprovider/providers/gce
pkg/cloudprovider/providers/gce/cloud pkg/cloudprovider/providers/gce/cloud
pkg/cloudprovider/providers/ovirt pkg/cloudprovider/providers/ovirt
pkg/cloudprovider/providers/photon pkg/cloudprovider/providers/photon

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

@ -57,6 +57,7 @@ import (
) )
const ( const (
// ProviderName is the official const representation of the Google Cloud Provider
ProviderName = "gce" ProviderName = "gce"
k8sNodeRouteTag = "k8s-node-route" k8sNodeRouteTag = "k8s-node-route"
@ -97,9 +98,9 @@ type gceObject interface {
MarshalJSON() ([]byte, error) MarshalJSON() ([]byte, error)
} }
// GCECloud is an implementation of Interface, LoadBalancer and Instances for Google Compute Engine. // Cloud is an implementation of Interface, LoadBalancer and Instances for Google Compute Engine.
type GCECloud struct { type Cloud struct {
// ClusterID contains functionality for getting (and initializing) the ingress-uid. Call GCECloud.Initialize() // ClusterID contains functionality for getting (and initializing) the ingress-uid. Call Cloud.Initialize()
// for the cloudprovider to start watching the configmap. // for the cloudprovider to start watching the configmap.
ClusterID ClusterID ClusterID ClusterID
@ -145,7 +146,7 @@ type GCECloud struct {
// lock to prevent shared resources from being prematurely deleted while the operation is // lock to prevent shared resources from being prematurely deleted while the operation is
// in progress. // in progress.
sharedResourceLock sync.Mutex sharedResourceLock sync.Mutex
// AlphaFeatureGate gates gce alpha features in GCECloud instance. // AlphaFeatureGate gates gce alpha features in Cloud instance.
// Related wrapper functions that interacts with gce alpha api should examine whether // Related wrapper functions that interacts with gce alpha api should examine whether
// the corresponding api is enabled. // the corresponding api is enabled.
// If not enabled, it should return error. // If not enabled, it should return error.
@ -158,6 +159,7 @@ type GCECloud struct {
s *cloud.Service s *cloud.Service
} }
// ConfigGlobal is the in memory representation of the gce.conf config data
// TODO: replace gcfg with json // TODO: replace gcfg with json
type ConfigGlobal struct { type ConfigGlobal struct {
TokenURL string `gcfg:"token-url"` TokenURL string `gcfg:"token-url"`
@ -177,12 +179,12 @@ type ConfigGlobal struct {
NodeInstancePrefix string `gcfg:"node-instance-prefix"` NodeInstancePrefix string `gcfg:"node-instance-prefix"`
Regional bool `gcfg:"regional"` Regional bool `gcfg:"regional"`
Multizone bool `gcfg:"multizone"` Multizone bool `gcfg:"multizone"`
// ApiEndpoint is the GCE compute API endpoint to use. If this is blank, // APIEndpoint is the GCE compute API endpoint to use. If this is blank,
// then the default endpoint is used. // then the default endpoint is used.
ApiEndpoint string `gcfg:"api-endpoint"` APIEndpoint string `gcfg:"api-endpoint"`
// ContainerApiEndpoint is the GCE container API endpoint to use. If this is blank, // ContainerAPIEndpoint is the GCE container API endpoint to use. If this is blank,
// then the default endpoint is used. // then the default endpoint is used.
ContainerApiEndpoint string `gcfg:"container-api-endpoint"` ContainerAPIEndpoint string `gcfg:"container-api-endpoint"`
// LocalZone specifies the GCE zone that gce cloud client instance is // LocalZone specifies the GCE zone that gce cloud client instance is
// located in (i.e. where the controller will be running). If this is // located in (i.e. where the controller will be running). If this is
// blank, then the local zone will be discovered via the metadata server. // blank, then the local zone will be discovered via the metadata server.
@ -197,10 +199,10 @@ type ConfigFile struct {
Global ConfigGlobal `gcfg:"global"` Global ConfigGlobal `gcfg:"global"`
} }
// CloudConfig includes all the necessary configuration for creating GCECloud // CloudConfig includes all the necessary configuration for creating Cloud
type CloudConfig struct { type CloudConfig struct {
ApiEndpoint string APIEndpoint string
ContainerApiEndpoint string ContainerAPIEndpoint string
ProjectID string ProjectID string
NetworkProjectID string NetworkProjectID string
Region string Region string
@ -236,22 +238,22 @@ type Services struct {
} }
// ComputeServices returns access to the internal compute services. // ComputeServices returns access to the internal compute services.
func (g *GCECloud) ComputeServices() *Services { func (g *Cloud) ComputeServices() *Services {
return &Services{g.service, g.serviceAlpha, g.serviceBeta} return &Services{g.service, g.serviceAlpha, g.serviceBeta}
} }
// Compute returns the generated stubs for the compute API. // Compute returns the generated stubs for the compute API.
func (g *GCECloud) Compute() cloud.Cloud { func (g *Cloud) Compute() cloud.Cloud {
return g.c return g.c
} }
// ContainerService returns the container service. // ContainerService returns the container service.
func (g *GCECloud) ContainerService() *container.Service { func (g *Cloud) ContainerService() *container.Service {
return g.containerService return g.containerService
} }
// newGCECloud creates a new instance of GCECloud. // newGCECloud creates a new instance of Cloud.
func newGCECloud(config io.Reader) (gceCloud *GCECloud, err error) { func newGCECloud(config io.Reader) (gceCloud *Cloud, err error) {
var cloudConfig *CloudConfig var cloudConfig *CloudConfig
var configFile *ConfigFile var configFile *ConfigFile
@ -286,12 +288,12 @@ func generateCloudConfig(configFile *ConfigFile) (cloudConfig *CloudConfig, err
cloudConfig.UseMetadataServer = true cloudConfig.UseMetadataServer = true
cloudConfig.AlphaFeatureGate = NewAlphaFeatureGate([]string{}) cloudConfig.AlphaFeatureGate = NewAlphaFeatureGate([]string{})
if configFile != nil { if configFile != nil {
if configFile.Global.ApiEndpoint != "" { if configFile.Global.APIEndpoint != "" {
cloudConfig.ApiEndpoint = configFile.Global.ApiEndpoint cloudConfig.APIEndpoint = configFile.Global.APIEndpoint
} }
if configFile.Global.ContainerApiEndpoint != "" { if configFile.Global.ContainerAPIEndpoint != "" {
cloudConfig.ContainerApiEndpoint = configFile.Global.ContainerApiEndpoint cloudConfig.ContainerAPIEndpoint = configFile.Global.ContainerAPIEndpoint
} }
if configFile.Global.TokenURL != "" { if configFile.Global.TokenURL != "" {
@ -377,11 +379,11 @@ func generateCloudConfig(configFile *ConfigFile) (cloudConfig *CloudConfig, err
return cloudConfig, err return cloudConfig, err
} }
// CreateGCECloud creates a GCECloud object using the specified parameters. // CreateGCECloud creates a Cloud object using the specified parameters.
// If no networkUrl is specified, loads networkName via rest call. // If no networkUrl is specified, loads networkName via rest call.
// If no tokenSource is specified, uses oauth2.DefaultTokenSource. // If no tokenSource is specified, uses oauth2.DefaultTokenSource.
// If managedZones is nil / empty all zones in the region will be managed. // If managedZones is nil / empty all zones in the region will be managed.
func CreateGCECloud(config *CloudConfig) (*GCECloud, error) { func CreateGCECloud(config *CloudConfig) (*Cloud, error) {
// Remove any pre-release version and build metadata from the semver, // Remove any pre-release version and build metadata from the semver,
// leaving only the MAJOR.MINOR.PATCH portion. See http://semver.org/. // leaving only the MAJOR.MINOR.PATCH portion. See http://semver.org/.
version := strings.TrimLeft(strings.Split(strings.Split(version.Get().GitVersion, "-")[0], "+")[0], "v") version := strings.TrimLeft(strings.Split(strings.Split(version.Get().GitVersion, "-")[0], "+")[0], "v")
@ -429,10 +431,10 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
// Generate alpha and beta api endpoints based on override v1 api endpoint. // Generate alpha and beta api endpoints based on override v1 api endpoint.
// For example, // For example,
// staging API endpoint: https://www.googleapis.com/compute/staging_v1/ // staging API endpoint: https://www.googleapis.com/compute/staging_v1/
if config.ApiEndpoint != "" { if config.APIEndpoint != "" {
service.BasePath = fmt.Sprintf("%sprojects/", config.ApiEndpoint) service.BasePath = fmt.Sprintf("%sprojects/", config.APIEndpoint)
serviceBeta.BasePath = fmt.Sprintf("%sprojects/", strings.Replace(config.ApiEndpoint, "v1", "beta", -1)) serviceBeta.BasePath = fmt.Sprintf("%sprojects/", strings.Replace(config.APIEndpoint, "v1", "beta", -1))
serviceAlpha.BasePath = fmt.Sprintf("%sprojects/", strings.Replace(config.ApiEndpoint, "v1", "alpha", -1)) serviceAlpha.BasePath = fmt.Sprintf("%sprojects/", strings.Replace(config.APIEndpoint, "v1", "alpha", -1))
} }
containerService, err := container.New(client) containerService, err := container.New(client)
@ -440,8 +442,8 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
return nil, err return nil, err
} }
containerService.UserAgent = userAgent containerService.UserAgent = userAgent
if config.ContainerApiEndpoint != "" { if config.ContainerAPIEndpoint != "" {
containerService.BasePath = config.ContainerApiEndpoint containerService.BasePath = config.ContainerAPIEndpoint
} }
tpuService, err := newTPUService(client) tpuService, err := newTPUService(client)
@ -460,7 +462,7 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
if config.NetworkURL != "" { if config.NetworkURL != "" {
networkURL = config.NetworkURL networkURL = config.NetworkURL
} else if config.NetworkName != "" { } else if config.NetworkName != "" {
networkURL = gceNetworkURL(config.ApiEndpoint, netProjID, config.NetworkName) networkURL = gceNetworkURL(config.APIEndpoint, netProjID, config.NetworkName)
} else { } else {
// Other consumers may use the cloudprovider without utilizing the wrapped GCE API functions // Other consumers may use the cloudprovider without utilizing the wrapped GCE API functions
// or functions requiring network/subnetwork URLs (e.g. Kubelet). // or functions requiring network/subnetwork URLs (e.g. Kubelet).
@ -470,7 +472,7 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
if config.SubnetworkURL != "" { if config.SubnetworkURL != "" {
subnetURL = config.SubnetworkURL subnetURL = config.SubnetworkURL
} else if config.SubnetworkName != "" { } else if config.SubnetworkName != "" {
subnetURL = gceSubnetworkURL(config.ApiEndpoint, netProjID, config.Region, config.SubnetworkName) subnetURL = gceSubnetworkURL(config.APIEndpoint, netProjID, config.Region, config.SubnetworkName)
} else { } else {
// Determine the type of network and attempt to discover the correct subnet for AUTO mode. // Determine the type of network and attempt to discover the correct subnet for AUTO mode.
// Gracefully fail because kubelet calls CreateGCECloud without any config, and minions // Gracefully fail because kubelet calls CreateGCECloud without any config, and minions
@ -510,7 +512,7 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
operationPollRateLimiter := flowcontrol.NewTokenBucketRateLimiter(5, 5) // 5 qps, 5 burst. operationPollRateLimiter := flowcontrol.NewTokenBucketRateLimiter(5, 5) // 5 qps, 5 burst.
gce := &GCECloud{ gce := &Cloud{
service: service, service: service,
serviceAlpha: serviceAlpha, serviceAlpha: serviceAlpha,
serviceBeta: serviceBeta, serviceBeta: serviceBeta,
@ -550,8 +552,8 @@ func CreateGCECloud(config *CloudConfig) (*GCECloud, error) {
// SetRateLimiter adds a custom cloud.RateLimiter implementation. // SetRateLimiter adds a custom cloud.RateLimiter implementation.
// WARNING: Calling this could have unexpected behavior if you have in-flight // WARNING: Calling this could have unexpected behavior if you have in-flight
// requests. It is best to use this immediately after creating a GCECloud. // requests. It is best to use this immediately after creating a Cloud.
func (g *GCECloud) SetRateLimiter(rl cloud.RateLimiter) { func (g *Cloud) SetRateLimiter(rl cloud.RateLimiter) {
if rl != nil { if rl != nil {
g.s.RateLimiter = rl g.s.RateLimiter = rl
} }
@ -610,89 +612,92 @@ func tryConvertToProjectNames(configProject, configNetworkProject string, servic
// Initialize takes in a clientBuilder and spawns a goroutine for watching the clusterid configmap. // Initialize takes in a clientBuilder and spawns a goroutine for watching the clusterid configmap.
// This must be called before utilizing the funcs of gce.ClusterID // This must be called before utilizing the funcs of gce.ClusterID
func (gce *GCECloud) Initialize(clientBuilder cloudprovider.ControllerClientBuilder, stop <-chan struct{}) { func (g *Cloud) Initialize(clientBuilder cloudprovider.ControllerClientBuilder, stop <-chan struct{}) {
gce.clientBuilder = clientBuilder g.clientBuilder = clientBuilder
gce.client = clientBuilder.ClientOrDie("cloud-provider") g.client = clientBuilder.ClientOrDie("cloud-provider")
if gce.OnXPN() { if g.OnXPN() {
gce.eventBroadcaster = record.NewBroadcaster() g.eventBroadcaster = record.NewBroadcaster()
gce.eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: gce.client.CoreV1().Events("")}) g.eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: g.client.CoreV1().Events("")})
gce.eventRecorder = gce.eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "gce-cloudprovider"}) g.eventRecorder = g.eventBroadcaster.NewRecorder(scheme.Scheme, v1.EventSource{Component: "g-cloudprovider"})
} }
go gce.watchClusterID(stop) go g.watchClusterID(stop)
} }
// LoadBalancer returns an implementation of LoadBalancer for Google Compute Engine. // LoadBalancer returns an implementation of LoadBalancer for Google Compute Engine.
func (gce *GCECloud) LoadBalancer() (cloudprovider.LoadBalancer, bool) { func (g *Cloud) LoadBalancer() (cloudprovider.LoadBalancer, bool) {
return gce, true return g, true
} }
// Instances returns an implementation of Instances for Google Compute Engine. // Instances returns an implementation of Instances for Google Compute Engine.
func (gce *GCECloud) Instances() (cloudprovider.Instances, bool) { func (g *Cloud) Instances() (cloudprovider.Instances, bool) {
return gce, true return g, true
} }
// Zones returns an implementation of Zones for Google Compute Engine. // Zones returns an implementation of Zones for Google Compute Engine.
func (gce *GCECloud) Zones() (cloudprovider.Zones, bool) { func (g *Cloud) Zones() (cloudprovider.Zones, bool) {
return gce, true return g, true
} }
func (gce *GCECloud) Clusters() (cloudprovider.Clusters, bool) { // Clusters returns an implementation of Clusters for Google Compute Engine.
return gce, true func (g *Cloud) Clusters() (cloudprovider.Clusters, bool) {
return g, true
} }
// Routes returns an implementation of Routes for Google Compute Engine. // Routes returns an implementation of Routes for Google Compute Engine.
func (gce *GCECloud) Routes() (cloudprovider.Routes, bool) { func (g *Cloud) Routes() (cloudprovider.Routes, bool) {
return gce, true return g, true
} }
// ProviderName returns the cloud provider ID. // ProviderName returns the cloud provider ID.
func (gce *GCECloud) ProviderName() string { func (g *Cloud) ProviderName() string {
return ProviderName return ProviderName
} }
// ProjectID returns the ProjectID corresponding to the project this cloud is in. // ProjectID returns the ProjectID corresponding to the project this cloud is in.
func (g *GCECloud) ProjectID() string { func (g *Cloud) ProjectID() string {
return g.projectID return g.projectID
} }
// NetworkProjectID returns the ProjectID corresponding to the project this cluster's network is in. // NetworkProjectID returns the ProjectID corresponding to the project this cluster's network is in.
func (g *GCECloud) NetworkProjectID() string { func (g *Cloud) NetworkProjectID() string {
return g.networkProjectID return g.networkProjectID
} }
// Region returns the region // Region returns the region
func (gce *GCECloud) Region() string { func (g *Cloud) Region() string {
return gce.region return g.region
} }
// OnXPN returns true if the cluster is running on a cross project network (XPN) // OnXPN returns true if the cluster is running on a cross project network (XPN)
func (gce *GCECloud) OnXPN() bool { func (g *Cloud) OnXPN() bool {
return gce.onXPN return g.onXPN
} }
// NetworkURL returns the network url // NetworkURL returns the network url
func (gce *GCECloud) NetworkURL() string { func (g *Cloud) NetworkURL() string {
return gce.networkURL return g.networkURL
} }
// SubnetworkURL returns the subnetwork url // SubnetworkURL returns the subnetwork url
func (gce *GCECloud) SubnetworkURL() string { func (g *Cloud) SubnetworkURL() string {
return gce.subnetworkURL return g.subnetworkURL
} }
func (gce *GCECloud) IsLegacyNetwork() bool { // IsLegacyNetwork returns true if the cluster is still running a legacy network configuration.
return gce.isLegacyNetwork func (g *Cloud) IsLegacyNetwork() bool {
return g.isLegacyNetwork
} }
func (gce *GCECloud) SetInformers(informerFactory informers.SharedInformerFactory) { // SetInformers sets up the zone handlers we need watching for node changes.
glog.Infof("Setting up informers for GCECloud") func (g *Cloud) SetInformers(informerFactory informers.SharedInformerFactory) {
glog.Infof("Setting up informers for Cloud")
nodeInformer := informerFactory.Core().V1().Nodes().Informer() nodeInformer := informerFactory.Core().V1().Nodes().Informer()
nodeInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{ nodeInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
AddFunc: func(obj interface{}) { AddFunc: func(obj interface{}) {
node := obj.(*v1.Node) node := obj.(*v1.Node)
gce.updateNodeZones(nil, node) g.updateNodeZones(nil, node)
}, },
UpdateFunc: func(prev, obj interface{}) { UpdateFunc: func(prev, obj interface{}) {
prevNode := prev.(*v1.Node) prevNode := prev.(*v1.Node)
@ -701,7 +706,7 @@ func (gce *GCECloud) SetInformers(informerFactory informers.SharedInformerFactor
prevNode.Labels[kubeletapis.LabelZoneFailureDomain] { prevNode.Labels[kubeletapis.LabelZoneFailureDomain] {
return return
} }
gce.updateNodeZones(prevNode, newNode) g.updateNodeZones(prevNode, newNode)
}, },
DeleteFunc: func(obj interface{}) { DeleteFunc: func(obj interface{}) {
node, isNode := obj.(*v1.Node) node, isNode := obj.(*v1.Node)
@ -719,37 +724,37 @@ func (gce *GCECloud) SetInformers(informerFactory informers.SharedInformerFactor
return return
} }
} }
gce.updateNodeZones(node, nil) g.updateNodeZones(node, nil)
}, },
}) })
gce.nodeInformerSynced = nodeInformer.HasSynced g.nodeInformerSynced = nodeInformer.HasSynced
} }
func (gce *GCECloud) updateNodeZones(prevNode, newNode *v1.Node) { func (g *Cloud) updateNodeZones(prevNode, newNode *v1.Node) {
gce.nodeZonesLock.Lock() g.nodeZonesLock.Lock()
defer gce.nodeZonesLock.Unlock() defer g.nodeZonesLock.Unlock()
if prevNode != nil { if prevNode != nil {
prevZone, ok := prevNode.ObjectMeta.Labels[kubeletapis.LabelZoneFailureDomain] prevZone, ok := prevNode.ObjectMeta.Labels[kubeletapis.LabelZoneFailureDomain]
if ok { if ok {
gce.nodeZones[prevZone].Delete(prevNode.ObjectMeta.Name) g.nodeZones[prevZone].Delete(prevNode.ObjectMeta.Name)
if gce.nodeZones[prevZone].Len() == 0 { if g.nodeZones[prevZone].Len() == 0 {
gce.nodeZones[prevZone] = nil g.nodeZones[prevZone] = nil
} }
} }
} }
if newNode != nil { if newNode != nil {
newZone, ok := newNode.ObjectMeta.Labels[kubeletapis.LabelZoneFailureDomain] newZone, ok := newNode.ObjectMeta.Labels[kubeletapis.LabelZoneFailureDomain]
if ok { if ok {
if gce.nodeZones[newZone] == nil { if g.nodeZones[newZone] == nil {
gce.nodeZones[newZone] = sets.NewString() g.nodeZones[newZone] = sets.NewString()
} }
gce.nodeZones[newZone].Insert(newNode.ObjectMeta.Name) g.nodeZones[newZone].Insert(newNode.ObjectMeta.Name)
} }
} }
} }
// HasClusterID returns true if the cluster has a clusterID // HasClusterID returns true if the cluster has a clusterID
func (gce *GCECloud) HasClusterID() bool { func (g *Cloud) HasClusterID() bool {
return true return true
} }
@ -760,8 +765,8 @@ func isProjectNumber(idOrNumber string) bool {
return err == nil return err == nil
} }
// GCECloud implements cloudprovider.Interface. // Cloud implements cloudprovider.Interface.
var _ cloudprovider.Interface = (*GCECloud)(nil) var _ cloudprovider.Interface = (*Cloud)(nil)
func gceNetworkURL(apiEndpoint, project, network string) string { func gceNetworkURL(apiEndpoint, project, network string) string {
if apiEndpoint == "" { if apiEndpoint == "" {
@ -894,19 +899,19 @@ func newOauthClient(tokenSource oauth2.TokenSource) (*http.Client, error) {
} }
func (manager *gceServiceManager) getProjectsAPIEndpoint() string { func (manager *gceServiceManager) getProjectsAPIEndpoint() string {
projectsApiEndpoint := gceComputeAPIEndpoint + "projects/" projectsAPIEndpoint := gceComputeAPIEndpoint + "projects/"
if manager.gce.service != nil { if manager.gce.service != nil {
projectsApiEndpoint = manager.gce.service.BasePath projectsAPIEndpoint = manager.gce.service.BasePath
} }
return projectsApiEndpoint return projectsAPIEndpoint
} }
func (manager *gceServiceManager) getProjectsAPIEndpointBeta() string { func (manager *gceServiceManager) getProjectsAPIEndpointBeta() string {
projectsApiEndpoint := gceComputeAPIEndpointBeta + "projects/" projectsAPIEndpoint := gceComputeAPIEndpointBeta + "projects/"
if manager.gce.service != nil { if manager.gce.service != nil {
projectsApiEndpoint = manager.gce.serviceBeta.BasePath projectsAPIEndpoint = manager.gce.serviceBeta.BasePath
} }
return projectsApiEndpoint return projectsAPIEndpoint
} }

54
pkg/cloudprovider/providers/gce/gce_addresses.go
View File

@ -42,106 +42,106 @@ func newAddressMetricContextWithVersion(request, region, version string) *metric
// Caller is allocated a random IP if they do not specify an ipAddress. If an // Caller is allocated a random IP if they do not specify an ipAddress. If an
// ipAddress is specified, it must belong to the current project, eg: an // ipAddress is specified, it must belong to the current project, eg: an
// ephemeral IP associated with a global forwarding rule. // ephemeral IP associated with a global forwarding rule.
func (gce *GCECloud) ReserveGlobalAddress(addr *compute.Address) error { func (g *Cloud) ReserveGlobalAddress(addr *compute.Address) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("reserve", "") mc := newAddressMetricContext("reserve", "")
return mc.Observe(gce.c.GlobalAddresses().Insert(ctx, meta.GlobalKey(addr.Name), addr)) return mc.Observe(g.c.GlobalAddresses().Insert(ctx, meta.GlobalKey(addr.Name), addr))
} }
// DeleteGlobalAddress deletes a global address by name. // DeleteGlobalAddress deletes a global address by name.
func (gce *GCECloud) DeleteGlobalAddress(name string) error { func (g *Cloud) DeleteGlobalAddress(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("delete", "") mc := newAddressMetricContext("delete", "")
return mc.Observe(gce.c.GlobalAddresses().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.GlobalAddresses().Delete(ctx, meta.GlobalKey(name)))
} }
// GetGlobalAddress returns the global address by name. // GetGlobalAddress returns the global address by name.
func (gce *GCECloud) GetGlobalAddress(name string) (*compute.Address, error) { func (g *Cloud) GetGlobalAddress(name string) (*compute.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("get", "") mc := newAddressMetricContext("get", "")
v, err := gce.c.GlobalAddresses().Get(ctx, meta.GlobalKey(name)) v, err := g.c.GlobalAddresses().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ReserveRegionAddress creates a region address // ReserveRegionAddress creates a region address
func (gce *GCECloud) ReserveRegionAddress(addr *compute.Address, region string) error { func (g *Cloud) ReserveRegionAddress(addr *compute.Address, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("reserve", region) mc := newAddressMetricContext("reserve", region)
return mc.Observe(gce.c.Addresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr)) return mc.Observe(g.c.Addresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr))
} }
// ReserveAlphaRegionAddress creates an Alpha, regional address. // ReserveAlphaRegionAddress creates an Alpha, regional address.
func (gce *GCECloud) ReserveAlphaRegionAddress(addr *computealpha.Address, region string) error { func (g *Cloud) ReserveAlphaRegionAddress(addr *computealpha.Address, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("reserve", region) mc := newAddressMetricContext("reserve", region)
return mc.Observe(gce.c.AlphaAddresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr)) return mc.Observe(g.c.AlphaAddresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr))
} }
// ReserveBetaRegionAddress creates a beta region address // ReserveBetaRegionAddress creates a beta region address
func (gce *GCECloud) ReserveBetaRegionAddress(addr *computebeta.Address, region string) error { func (g *Cloud) ReserveBetaRegionAddress(addr *computebeta.Address, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("reserve", region) mc := newAddressMetricContext("reserve", region)
return mc.Observe(gce.c.BetaAddresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr)) return mc.Observe(g.c.BetaAddresses().Insert(ctx, meta.RegionalKey(addr.Name, region), addr))
} }
// DeleteRegionAddress deletes a region address by name. // DeleteRegionAddress deletes a region address by name.
func (gce *GCECloud) DeleteRegionAddress(name, region string) error { func (g *Cloud) DeleteRegionAddress(name, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("delete", region) mc := newAddressMetricContext("delete", region)
return mc.Observe(gce.c.Addresses().Delete(ctx, meta.RegionalKey(name, region))) return mc.Observe(g.c.Addresses().Delete(ctx, meta.RegionalKey(name, region)))
} }
// GetRegionAddress returns the region address by name // GetRegionAddress returns the region address by name
func (gce *GCECloud) GetRegionAddress(name, region string) (*compute.Address, error) { func (g *Cloud) GetRegionAddress(name, region string) (*compute.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("get", region) mc := newAddressMetricContext("get", region)
v, err := gce.c.Addresses().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.Addresses().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetAlphaRegionAddress returns the Alpha, regional address by name. // GetAlphaRegionAddress returns the Alpha, regional address by name.
func (gce *GCECloud) GetAlphaRegionAddress(name, region string) (*computealpha.Address, error) { func (g *Cloud) GetAlphaRegionAddress(name, region string) (*computealpha.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("get", region) mc := newAddressMetricContext("get", region)
v, err := gce.c.AlphaAddresses().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.AlphaAddresses().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetBetaRegionAddress returns the beta region address by name // GetBetaRegionAddress returns the beta region address by name
func (gce *GCECloud) GetBetaRegionAddress(name, region string) (*computebeta.Address, error) { func (g *Cloud) GetBetaRegionAddress(name, region string) (*computebeta.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("get", region) mc := newAddressMetricContext("get", region)
v, err := gce.c.BetaAddresses().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.BetaAddresses().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetRegionAddressByIP returns the regional address matching the given IP address. // GetRegionAddressByIP returns the regional address matching the given IP address.
func (gce *GCECloud) GetRegionAddressByIP(region, ipAddress string) (*compute.Address, error) { func (g *Cloud) GetRegionAddressByIP(region, ipAddress string) (*compute.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("list", region) mc := newAddressMetricContext("list", region)
addrs, err := gce.c.Addresses().List(ctx, region, filter.Regexp("address", ipAddress)) addrs, err := g.c.Addresses().List(ctx, region, filter.Regexp("address", ipAddress))
mc.Observe(err) mc.Observe(err)
if err != nil { if err != nil {
@ -160,12 +160,12 @@ func (gce *GCECloud) GetRegionAddressByIP(region, ipAddress string) (*compute.Ad
} }
// GetBetaRegionAddressByIP returns the beta regional address matching the given IP address. // GetBetaRegionAddressByIP returns the beta regional address matching the given IP address.
func (gce *GCECloud) GetBetaRegionAddressByIP(region, ipAddress string) (*computebeta.Address, error) { func (g *Cloud) GetBetaRegionAddressByIP(region, ipAddress string) (*computebeta.Address, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newAddressMetricContext("list", region) mc := newAddressMetricContext("list", region)
addrs, err := gce.c.BetaAddresses().List(ctx, region, filter.Regexp("address", ipAddress)) addrs, err := g.c.BetaAddresses().List(ctx, region, filter.Regexp("address", ipAddress))
mc.Observe(err) mc.Observe(err)
if err != nil { if err != nil {
@ -184,11 +184,11 @@ func (gce *GCECloud) GetBetaRegionAddressByIP(region, ipAddress string) (*comput
} }
// TODO(#51665): retire this function once Network Tiers becomes Beta in GCP. // TODO(#51665): retire this function once Network Tiers becomes Beta in GCP.
func (gce *GCECloud) getNetworkTierFromAddress(name, region string) (string, error) { func (g *Cloud) getNetworkTierFromAddress(name, region string) (string, error) {
if !gce.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) { if !g.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) {
return cloud.NetworkTierDefault.ToGCEValue(), nil return cloud.NetworkTierDefault.ToGCEValue(), nil
} }
addr, err := gce.GetAlphaRegionAddress(name, region) addr, err := g.GetAlphaRegionAddress(name, region)
if err != nil { if err != nil {
return handleAlphaNetworkTierGetError(err) return handleAlphaNetworkTierGetError(err)
} }

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

@ -21,21 +21,24 @@ import (
) )
const ( const (
// alpha: v1.8 (for Services) // AlphaFeatureNetworkTiers allows Services backed by a GCP load balancer to choose
// what network tier to use. Currently supports "Standard" and "Premium" (default).
// //
// Allows Services backed by a GCP load balancer to choose what network // alpha: v1.8 (for Services)
// tier to use. Currently supports "Standard" and "Premium" (default).
AlphaFeatureNetworkTiers = "NetworkTiers" AlphaFeatureNetworkTiers = "NetworkTiers"
) )
// AlphaFeatureGate contains a mapping of alpha features to whether they are enabled
type AlphaFeatureGate struct { type AlphaFeatureGate struct {
features map[string]bool features map[string]bool
} }
// Enabled returns true if the provided alpha feature is enabled
func (af *AlphaFeatureGate) Enabled(key string) bool { func (af *AlphaFeatureGate) Enabled(key string) bool {
return af.features[key] return af.features[key]
} }
// NewAlphaFeatureGate marks the provided alpha features as enabled
func NewAlphaFeatureGate(features []string) *AlphaFeatureGate { func NewAlphaFeatureGate(features []string) *AlphaFeatureGate {
featureMap := make(map[string]bool) featureMap := make(map[string]bool)
for _, name := range features { for _, name := range features {
@ -44,9 +47,9 @@ func NewAlphaFeatureGate(features []string) *AlphaFeatureGate {
return &AlphaFeatureGate{featureMap} return &AlphaFeatureGate{featureMap}
} }
func (gce *GCECloud) alphaFeatureEnabled(feature string) error { func (g *Cloud) alphaFeatureEnabled(feature string) error {
if !gce.AlphaFeatureGate.Enabled(feature) { if !g.AlphaFeatureGate.Enabled(feature) {
return fmt.Errorf("alpha feature %q is not enabled.", feature) return fmt.Errorf("alpha feature %q is not enabled", feature)
} }
return nil return nil
} }

14
pkg/cloudprovider/providers/gce/gce_annotations.go
View File

@ -25,6 +25,7 @@ import (
"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud"
) )
// LoadBalancerType defines a specific type for holding load balancer types (eg. Internal)
type LoadBalancerType string type LoadBalancerType string
const ( const (
@ -33,23 +34,30 @@ const (
// Currently, only "internal" is supported. // Currently, only "internal" is supported.
ServiceAnnotationLoadBalancerType = "cloud.google.com/load-balancer-type" ServiceAnnotationLoadBalancerType = "cloud.google.com/load-balancer-type"
// LBTypeInternal is the constant for the official internal type.
LBTypeInternal LoadBalancerType = "Internal" LBTypeInternal LoadBalancerType = "Internal"
// Deprecating the lowercase spelling of Internal. // Deprecating the lowercase spelling of Internal.
deprecatedTypeInternalLowerCase LoadBalancerType = "internal" deprecatedTypeInternalLowerCase LoadBalancerType = "internal"
// ServiceAnnotationInternalBackendShare is annotated on a service with "true" when users // ServiceAnnotationILBBackendShare is annotated on a service with "true" when users
// want to share GCP Backend Services for a set of internal load balancers. // want to share GCP Backend Services for a set of internal load balancers.
// ALPHA feature - this may be removed in a future release. // ALPHA feature - this may be removed in a future release.
ServiceAnnotationILBBackendShare = "alpha.cloud.google.com/load-balancer-backend-share" ServiceAnnotationILBBackendShare = "alpha.cloud.google.com/load-balancer-backend-share"
// This annotation did not correctly specify "alpha", so both annotations will be checked. // This annotation did not correctly specify "alpha", so both annotations will be checked.
deprecatedServiceAnnotationILBBackendShare = "cloud.google.com/load-balancer-backend-share" deprecatedServiceAnnotationILBBackendShare = "cloud.google.com/load-balancer-backend-share"
// NetworkTierAnnotationKey is annotated on a Service object to indicate which // NetworkTierAnnotationKey is annotated on a Service object to indicate which
// network tier a GCP LB should use. The valid values are "Standard" and // network tier a GCP LB should use. The valid values are "Standard" and
// "Premium" (default). // "Premium" (default).
NetworkTierAnnotationKey = "cloud.google.com/network-tier" NetworkTierAnnotationKey = "cloud.google.com/network-tier"
// NetworkTierAnnotationStandard is an annotation to indicate the Service is on the Standard network tier
NetworkTierAnnotationStandard = cloud.NetworkTierStandard NetworkTierAnnotationStandard = cloud.NetworkTierStandard
NetworkTierAnnotationPremium = cloud.NetworkTierPremium
// NetworkTierAnnotationPremium is an annotation to indicate the Service is on the Premium network tier
NetworkTierAnnotationPremium = cloud.NetworkTierPremium
) )
// GetLoadBalancerAnnotationType returns the type of GCP load balancer which should be assembled. // GetLoadBalancerAnnotationType returns the type of GCP load balancer which should be assembled.

80
pkg/cloudprovider/providers/gce/gce_backendservice.go
View File

@ -35,201 +35,201 @@ func newBackendServiceMetricContextWithVersion(request, region, version string)
} }
// GetGlobalBackendService retrieves a backend by name. // GetGlobalBackendService retrieves a backend by name.
func (gce *GCECloud) GetGlobalBackendService(name string) (*compute.BackendService, error) { func (g *Cloud) GetGlobalBackendService(name string) (*compute.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("get", "") mc := newBackendServiceMetricContext("get", "")
v, err := gce.c.BackendServices().Get(ctx, meta.GlobalKey(name)) v, err := g.c.BackendServices().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetBetaGlobalBackendService retrieves beta backend by name. // GetBetaGlobalBackendService retrieves beta backend by name.
func (gce *GCECloud) GetBetaGlobalBackendService(name string) (*computebeta.BackendService, error) { func (g *Cloud) GetBetaGlobalBackendService(name string) (*computebeta.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("get", "", computeBetaVersion) mc := newBackendServiceMetricContextWithVersion("get", "", computeBetaVersion)
v, err := gce.c.BetaBackendServices().Get(ctx, meta.GlobalKey(name)) v, err := g.c.BetaBackendServices().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetAlphaGlobalBackendService retrieves alpha backend by name. // GetAlphaGlobalBackendService retrieves alpha backend by name.
func (gce *GCECloud) GetAlphaGlobalBackendService(name string) (*computealpha.BackendService, error) { func (g *Cloud) GetAlphaGlobalBackendService(name string) (*computealpha.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("get", "", computeAlphaVersion) mc := newBackendServiceMetricContextWithVersion("get", "", computeAlphaVersion)
v, err := gce.c.AlphaBackendServices().Get(ctx, meta.GlobalKey(name)) v, err := g.c.AlphaBackendServices().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// UpdateGlobalBackendService applies the given BackendService as an update to // UpdateGlobalBackendService applies the given BackendService as an update to
// an existing service. // an existing service.
func (gce *GCECloud) UpdateGlobalBackendService(bg *compute.BackendService) error { func (g *Cloud) UpdateGlobalBackendService(bg *compute.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("update", "") mc := newBackendServiceMetricContext("update", "")
return mc.Observe(gce.c.BackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.BackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg))
} }
// UpdateBetaGlobalBackendService applies the given beta BackendService as an // UpdateBetaGlobalBackendService applies the given beta BackendService as an
// update to an existing service. // update to an existing service.
func (gce *GCECloud) UpdateBetaGlobalBackendService(bg *computebeta.BackendService) error { func (g *Cloud) UpdateBetaGlobalBackendService(bg *computebeta.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("update", "", computeBetaVersion) mc := newBackendServiceMetricContextWithVersion("update", "", computeBetaVersion)
return mc.Observe(gce.c.BetaBackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.BetaBackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg))
} }
// UpdateAlphaGlobalBackendService applies the given alpha BackendService as an // UpdateAlphaGlobalBackendService applies the given alpha BackendService as an
// update to an existing service. // update to an existing service.
func (gce *GCECloud) UpdateAlphaGlobalBackendService(bg *computealpha.BackendService) error { func (g *Cloud) UpdateAlphaGlobalBackendService(bg *computealpha.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("update", "", computeAlphaVersion) mc := newBackendServiceMetricContextWithVersion("update", "", computeAlphaVersion)
return mc.Observe(gce.c.AlphaBackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.AlphaBackendServices().Update(ctx, meta.GlobalKey(bg.Name), bg))
} }
// DeleteGlobalBackendService deletes the given BackendService by name. // DeleteGlobalBackendService deletes the given BackendService by name.
func (gce *GCECloud) DeleteGlobalBackendService(name string) error { func (g *Cloud) DeleteGlobalBackendService(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("delete", "") mc := newBackendServiceMetricContext("delete", "")
return mc.Observe(gce.c.BackendServices().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.BackendServices().Delete(ctx, meta.GlobalKey(name)))
} }
// CreateGlobalBackendService creates the given BackendService. // CreateGlobalBackendService creates the given BackendService.
func (gce *GCECloud) CreateGlobalBackendService(bg *compute.BackendService) error { func (g *Cloud) CreateGlobalBackendService(bg *compute.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("create", "") mc := newBackendServiceMetricContext("create", "")
return mc.Observe(gce.c.BackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.BackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg))
} }
// CreateBetaGlobalBackendService creates the given beta BackendService. // CreateBetaGlobalBackendService creates the given beta BackendService.
func (gce *GCECloud) CreateBetaGlobalBackendService(bg *computebeta.BackendService) error { func (g *Cloud) CreateBetaGlobalBackendService(bg *computebeta.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("create", "", computeBetaVersion) mc := newBackendServiceMetricContextWithVersion("create", "", computeBetaVersion)
return mc.Observe(gce.c.BetaBackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.BetaBackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg))
} }
// CreateAlphaGlobalBackendService creates the given alpha BackendService. // CreateAlphaGlobalBackendService creates the given alpha BackendService.
func (gce *GCECloud) CreateAlphaGlobalBackendService(bg *computealpha.BackendService) error { func (g *Cloud) CreateAlphaGlobalBackendService(bg *computealpha.BackendService) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("create", "", computeAlphaVersion) mc := newBackendServiceMetricContextWithVersion("create", "", computeAlphaVersion)
return mc.Observe(gce.c.AlphaBackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg)) return mc.Observe(g.c.AlphaBackendServices().Insert(ctx, meta.GlobalKey(bg.Name), bg))
} }
// ListGlobalBackendServices lists all backend services in the project. // ListGlobalBackendServices lists all backend services in the project.
func (gce *GCECloud) ListGlobalBackendServices() ([]*compute.BackendService, error) { func (g *Cloud) ListGlobalBackendServices() ([]*compute.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("list", "") mc := newBackendServiceMetricContext("list", "")
v, err := gce.c.BackendServices().List(ctx, filter.None) v, err := g.c.BackendServices().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetGlobalBackendServiceHealth returns the health of the BackendService // GetGlobalBackendServiceHealth returns the health of the BackendService
// identified by the given name, in the given instanceGroup. The // identified by the given name, in the given instanceGroup. The
// instanceGroupLink is the fully qualified self link of an instance group. // instanceGroupLink is the fully qualified self link of an instance group.
func (gce *GCECloud) GetGlobalBackendServiceHealth(name string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) { func (g *Cloud) GetGlobalBackendServiceHealth(name string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("get_health", "") mc := newBackendServiceMetricContext("get_health", "")
groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink} groupRef := &compute.ResourceGroupReference{Group: instanceGroupLink}
v, err := gce.c.BackendServices().GetHealth(ctx, meta.GlobalKey(name), groupRef) v, err := g.c.BackendServices().GetHealth(ctx, meta.GlobalKey(name), groupRef)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetRegionBackendService retrieves a backend by name. // GetRegionBackendService retrieves a backend by name.
func (gce *GCECloud) GetRegionBackendService(name, region string) (*compute.BackendService, error) { func (g *Cloud) GetRegionBackendService(name, region string) (*compute.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("get", region) mc := newBackendServiceMetricContext("get", region)
v, err := gce.c.RegionBackendServices().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.RegionBackendServices().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// UpdateRegionBackendService applies the given BackendService as an update to // UpdateRegionBackendService applies the given BackendService as an update to
// an existing service. // an existing service.
func (gce *GCECloud) UpdateRegionBackendService(bg *compute.BackendService, region string) error { func (g *Cloud) UpdateRegionBackendService(bg *compute.BackendService, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("update", region) mc := newBackendServiceMetricContext("update", region)
return mc.Observe(gce.c.RegionBackendServices().Update(ctx, meta.RegionalKey(bg.Name, region), bg)) return mc.Observe(g.c.RegionBackendServices().Update(ctx, meta.RegionalKey(bg.Name, region), bg))
} }
// DeleteRegionBackendService deletes the given BackendService by name. // DeleteRegionBackendService deletes the given BackendService by name.
func (gce *GCECloud) DeleteRegionBackendService(name, region string) error { func (g *Cloud) DeleteRegionBackendService(name, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("delete", region) mc := newBackendServiceMetricContext("delete", region)
return mc.Observe(gce.c.RegionBackendServices().Delete(ctx, meta.RegionalKey(name, region))) return mc.Observe(g.c.RegionBackendServices().Delete(ctx, meta.RegionalKey(name, region)))
} }
// CreateRegionBackendService creates the given BackendService. // CreateRegionBackendService creates the given BackendService.
func (gce *GCECloud) CreateRegionBackendService(bg *compute.BackendService, region string) error { func (g *Cloud) CreateRegionBackendService(bg *compute.BackendService, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("create", region) mc := newBackendServiceMetricContext("create", region)
return mc.Observe(gce.c.RegionBackendServices().Insert(ctx, meta.RegionalKey(bg.Name, region), bg)) return mc.Observe(g.c.RegionBackendServices().Insert(ctx, meta.RegionalKey(bg.Name, region), bg))
} }
// ListRegionBackendServices lists all backend services in the project. // ListRegionBackendServices lists all backend services in the project.
func (gce *GCECloud) ListRegionBackendServices(region string) ([]*compute.BackendService, error) { func (g *Cloud) ListRegionBackendServices(region string) ([]*compute.BackendService, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("list", region) mc := newBackendServiceMetricContext("list", region)
v, err := gce.c.RegionBackendServices().List(ctx, region, filter.None) v, err := g.c.RegionBackendServices().List(ctx, region, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetRegionalBackendServiceHealth returns the health of the BackendService // GetRegionalBackendServiceHealth returns the health of the BackendService
// identified by the given name, in the given instanceGroup. The // identified by the given name, in the given instanceGroup. The
// instanceGroupLink is the fully qualified self link of an instance group. // instanceGroupLink is the fully qualified self link of an instance group.
func (gce *GCECloud) GetRegionalBackendServiceHealth(name, region string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) { func (g *Cloud) GetRegionalBackendServiceHealth(name, region string, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContext("get_health", region) mc := newBackendServiceMetricContext("get_health", region)
ref := &compute.ResourceGroupReference{Group: instanceGroupLink} ref := &compute.ResourceGroupReference{Group: instanceGroupLink}
v, err := gce.c.RegionBackendServices().GetHealth(ctx, meta.RegionalKey(name, region), ref) v, err := g.c.RegionBackendServices().GetHealth(ctx, meta.RegionalKey(name, region), ref)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// SetSecurityPolicyForBetaGlobalBackendService sets the given // SetSecurityPolicyForBetaGlobalBackendService sets the given
// SecurityPolicyReference for the BackendService identified by the given name. // SecurityPolicyReference for the BackendService identified by the given name.
func (gce *GCECloud) SetSecurityPolicyForBetaGlobalBackendService(backendServiceName string, securityPolicyReference *computebeta.SecurityPolicyReference) error { func (g *Cloud) SetSecurityPolicyForBetaGlobalBackendService(backendServiceName string, securityPolicyReference *computebeta.SecurityPolicyReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("set_security_policy", "", computeBetaVersion) mc := newBackendServiceMetricContextWithVersion("set_security_policy", "", computeBetaVersion)
return mc.Observe(gce.c.BetaBackendServices().SetSecurityPolicy(ctx, meta.GlobalKey(backendServiceName), securityPolicyReference)) return mc.Observe(g.c.BetaBackendServices().SetSecurityPolicy(ctx, meta.GlobalKey(backendServiceName), securityPolicyReference))
} }
// SetSecurityPolicyForAlphaGlobalBackendService sets the given // SetSecurityPolicyForAlphaGlobalBackendService sets the given
// SecurityPolicyReference for the BackendService identified by the given name. // SecurityPolicyReference for the BackendService identified by the given name.
func (gce *GCECloud) SetSecurityPolicyForAlphaGlobalBackendService(backendServiceName string, securityPolicyReference *computealpha.SecurityPolicyReference) error { func (g *Cloud) SetSecurityPolicyForAlphaGlobalBackendService(backendServiceName string, securityPolicyReference *computealpha.SecurityPolicyReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newBackendServiceMetricContextWithVersion("set_security_policy", "", computeAlphaVersion) mc := newBackendServiceMetricContextWithVersion("set_security_policy", "", computeAlphaVersion)
return mc.Observe(gce.c.AlphaBackendServices().SetSecurityPolicy(ctx, meta.GlobalKey(backendServiceName), securityPolicyReference)) return mc.Observe(g.c.AlphaBackendServices().SetSecurityPolicy(ctx, meta.GlobalKey(backendServiceName), securityPolicyReference))
} }

18
pkg/cloudprovider/providers/gce/gce_cert.go
View File

@ -29,43 +29,43 @@ func newCertMetricContext(request string) *metricContext {
} }
// GetSslCertificate returns the SslCertificate by name. // GetSslCertificate returns the SslCertificate by name.
func (gce *GCECloud) GetSslCertificate(name string) (*compute.SslCertificate, error) { func (g *Cloud) GetSslCertificate(name string) (*compute.SslCertificate, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newCertMetricContext("get") mc := newCertMetricContext("get")
v, err := gce.c.SslCertificates().Get(ctx, meta.GlobalKey(name)) v, err := g.c.SslCertificates().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateSslCertificate creates and returns a SslCertificate. // CreateSslCertificate creates and returns a SslCertificate.
func (gce *GCECloud) CreateSslCertificate(sslCerts *compute.SslCertificate) (*compute.SslCertificate, error) { func (g *Cloud) CreateSslCertificate(sslCerts *compute.SslCertificate) (*compute.SslCertificate, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newCertMetricContext("create") mc := newCertMetricContext("create")
err := gce.c.SslCertificates().Insert(ctx, meta.GlobalKey(sslCerts.Name), sslCerts) err := g.c.SslCertificates().Insert(ctx, meta.GlobalKey(sslCerts.Name), sslCerts)
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
return gce.GetSslCertificate(sslCerts.Name) return g.GetSslCertificate(sslCerts.Name)
} }
// DeleteSslCertificate deletes the SslCertificate by name. // DeleteSslCertificate deletes the SslCertificate by name.
func (gce *GCECloud) DeleteSslCertificate(name string) error { func (g *Cloud) DeleteSslCertificate(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newCertMetricContext("delete") mc := newCertMetricContext("delete")
return mc.Observe(gce.c.SslCertificates().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.SslCertificates().Delete(ctx, meta.GlobalKey(name)))
} }
// ListSslCertificates lists all SslCertificates in the project. // ListSslCertificates lists all SslCertificates in the project.
func (gce *GCECloud) ListSslCertificates() ([]*compute.SslCertificate, error) { func (g *Cloud) ListSslCertificates() ([]*compute.SslCertificate, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newCertMetricContext("list") mc := newCertMetricContext("list")
v, err := gce.c.SslCertificates().List(ctx, filter.None) v, err := g.c.SslCertificates().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }

54
pkg/cloudprovider/providers/gce/gce_clusterid.go
View File

@ -36,19 +36,27 @@ import (
) )
const ( const (
// Key used to persist UIDs to configmaps. // UIDConfigMapName is the Key used to persist UIDs to configmaps.
UIDConfigMapName = "ingress-uid" UIDConfigMapName = "ingress-uid"
// Namespace which contains the above config map
// UIDNamespace is the namespace which contains the above config map
UIDNamespace = metav1.NamespaceSystem UIDNamespace = metav1.NamespaceSystem
// Data keys for the specific ids
UIDCluster = "uid" // UIDCluster is the data keys for looking up the clusters UID
UIDProvider = "provider-uid" UIDCluster = "uid"
// UIDProvider is the data keys for looking up the providers UID
UIDProvider = "provider-uid"
// UIDLengthBytes is the length of a UID
UIDLengthBytes = 8 UIDLengthBytes = 8
// Frequency of the updateFunc event handler being called // Frequency of the updateFunc event handler being called
// This does not actually query the apiserver for current state - the local cache value is used. // This does not actually query the apiserver for current state - the local cache value is used.
updateFuncFrequency = 10 * time.Minute updateFuncFrequency = 10 * time.Minute
) )
// ClusterID is the struct for maintaining information about this cluster's ID
type ClusterID struct { type ClusterID struct {
idLock sync.RWMutex idLock sync.RWMutex
client clientset.Interface client clientset.Interface
@ -59,10 +67,10 @@ type ClusterID struct {
} }
// Continually watches for changes to the cluster id config map // Continually watches for changes to the cluster id config map
func (gce *GCECloud) watchClusterID(stop <-chan struct{}) { func (g *Cloud) watchClusterID(stop <-chan struct{}) {
gce.ClusterID = ClusterID{ g.ClusterID = ClusterID{
cfgMapKey: fmt.Sprintf("%v/%v", UIDNamespace, UIDConfigMapName), cfgMapKey: fmt.Sprintf("%v/%v", UIDNamespace, UIDConfigMapName),
client: gce.client, client: g.client,
} }
mapEventHandler := cache.ResourceEventHandlerFuncs{ mapEventHandler := cache.ResourceEventHandlerFuncs{
@ -78,7 +86,7 @@ func (gce *GCECloud) watchClusterID(stop <-chan struct{}) {
} }
glog.V(4).Infof("Observed new configmap for clusteriD: %v, %v; setting local values", m.Name, m.Data) glog.V(4).Infof("Observed new configmap for clusteriD: %v, %v; setting local values", m.Name, m.Data)
gce.ClusterID.update(m) g.ClusterID.update(m)
}, },
UpdateFunc: func(old, cur interface{}) { UpdateFunc: func(old, cur interface{}) {
m, ok := cur.(*v1.ConfigMap) m, ok := cur.(*v1.ConfigMap)
@ -97,13 +105,13 @@ func (gce *GCECloud) watchClusterID(stop <-chan struct{}) {
} }
glog.V(4).Infof("Observed updated configmap for clusteriD %v, %v; setting local values", m.Name, m.Data) glog.V(4).Infof("Observed updated configmap for clusteriD %v, %v; setting local values", m.Name, m.Data)
gce.ClusterID.update(m) g.ClusterID.update(m)
}, },
} }
listerWatcher := cache.NewListWatchFromClient(gce.ClusterID.client.CoreV1().RESTClient(), "configmaps", UIDNamespace, fields.Everything()) listerWatcher := cache.NewListWatchFromClient(g.ClusterID.client.CoreV1().RESTClient(), "configmaps", UIDNamespace, fields.Everything())
var controller cache.Controller var controller cache.Controller
gce.ClusterID.store, controller = cache.NewInformer(newSingleObjectListerWatcher(listerWatcher, UIDConfigMapName), &v1.ConfigMap{}, updateFuncFrequency, mapEventHandler) g.ClusterID.store, controller = cache.NewInformer(newSingleObjectListerWatcher(listerWatcher, UIDConfigMapName), &v1.ConfigMap{}, updateFuncFrequency, mapEventHandler)
controller.Run(stop) controller.Run(stop)
} }
@ -131,9 +139,9 @@ func (ci *ClusterID) GetID() (string, error) {
return *ci.clusterID, nil return *ci.clusterID, nil
} }
// GetFederationId returns the id which could represent the entire Federation // GetFederationID returns the id which could represent the entire Federation
// or just the cluster if not federated. // or just the cluster if not federated.
func (ci *ClusterID) GetFederationId() (string, bool, error) { func (ci *ClusterID) GetFederationID() (string, bool, error) {
if err := ci.getOrInitialize(); err != nil { if err := ci.getOrInitialize(); err != nil {
return "", false, err return "", false, err
} }
@ -141,7 +149,7 @@ func (ci *ClusterID) GetFederationId() (string, bool, error) {
ci.idLock.RLock() ci.idLock.RLock()
defer ci.idLock.RUnlock() defer ci.idLock.RUnlock()
if ci.clusterID == nil { if ci.clusterID == nil {
return "", false, errors.New("Could not retrieve cluster id") return "", false, errors.New("could not retrieve cluster id")
} }
// If provider ID is not set, return false // If provider ID is not set, return false
@ -157,7 +165,7 @@ func (ci *ClusterID) GetFederationId() (string, bool, error) {
// before the watch has begun. // before the watch has begun.
func (ci *ClusterID) getOrInitialize() error { func (ci *ClusterID) getOrInitialize() error {
if ci.store == nil { if ci.store == nil {
return errors.New("GCECloud.ClusterID is not ready. Call Initialize() before using.") return errors.New("Cloud.ClusterID is not ready. Call Initialize() before using")
} }
if ci.clusterID != nil { if ci.clusterID != nil {
@ -172,12 +180,12 @@ func (ci *ClusterID) getOrInitialize() error {
} }
// The configmap does not exist - let's try creating one. // The configmap does not exist - let's try creating one.
newId, err := makeUID() newID, err := makeUID()
if err != nil { if err != nil {
return err return err
} }
glog.V(4).Infof("Creating clusteriD: %v", newId) glog.V(4).Infof("Creating clusteriD: %v", newID)
cfg := &v1.ConfigMap{ cfg := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{ ObjectMeta: metav1.ObjectMeta{
Name: UIDConfigMapName, Name: UIDConfigMapName,
@ -185,8 +193,8 @@ func (ci *ClusterID) getOrInitialize() error {
}, },
} }
cfg.Data = map[string]string{ cfg.Data = map[string]string{
UIDCluster: newId, UIDCluster: newID,
UIDProvider: newId, UIDProvider: newID,
} }
if _, err := ci.client.CoreV1().ConfigMaps(UIDNamespace).Create(cfg); err != nil { if _, err := ci.client.CoreV1().ConfigMaps(UIDNamespace).Create(cfg); err != nil {
@ -194,7 +202,7 @@ func (ci *ClusterID) getOrInitialize() error {
return err return err
} }
glog.V(2).Infof("Created a config map containing clusteriD: %v", newId) glog.V(2).Infof("Created a config map containing clusteriD: %v", newID)
ci.update(cfg) ci.update(cfg)
return nil return nil
} }
@ -224,8 +232,8 @@ func (ci *ClusterID) update(m *v1.ConfigMap) {
if clusterID, exists := m.Data[UIDCluster]; exists { if clusterID, exists := m.Data[UIDCluster]; exists {
ci.clusterID = &clusterID ci.clusterID = &clusterID
} }
if provId, exists := m.Data[UIDProvider]; exists { if provID, exists := m.Data[UIDProvider]; exists {
ci.providerID = &provId ci.providerID = &provID
} }
} }

38
pkg/cloudprovider/providers/gce/gce_clusters.go
View File

@ -18,22 +18,22 @@ package gce
import ( import (
"context" "context"
"errors"
"fmt" "fmt"
"github.com/golang/glog" "github.com/golang/glog"
container "google.golang.org/api/container/v1" "google.golang.org/api/container/v1"
) )
func newClustersMetricContext(request, zone string) *metricContext { func newClustersMetricContext(request, zone string) *metricContext {
return newGenericMetricContext("clusters", request, unusedMetricLabel, zone, computeV1Version) return newGenericMetricContext("clusters", request, unusedMetricLabel, zone, computeV1Version)
} }
func (gce *GCECloud) ListClusters(ctx context.Context) ([]string, error) { // ListClusters will return a list of cluster names for the associated project
func (g *Cloud) ListClusters(ctx context.Context) ([]string, error) {
allClusters := []string{} allClusters := []string{}
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
clusters, err := gce.listClustersInZone(zone) clusters, err := g.listClustersInZone(zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -44,36 +44,38 @@ func (gce *GCECloud) ListClusters(ctx context.Context) ([]string, error) {
return allClusters, nil return allClusters, nil
} }
func (gce *GCECloud) GetManagedClusters(ctx context.Context) ([]*container.Cluster, error) { // GetManagedClusters will return the cluster objects associated to this project
func (g *Cloud) GetManagedClusters(ctx context.Context) ([]*container.Cluster, error) {
managedClusters := []*container.Cluster{} managedClusters := []*container.Cluster{}
if gce.regional { if g.regional {
var err error var err error
managedClusters, err = gce.getClustersInLocation(gce.region) managedClusters, err = g.getClustersInLocation(g.region)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} else if len(gce.managedZones) >= 1 { } else if len(g.managedZones) >= 1 {
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
clusters, err := gce.getClustersInLocation(zone) clusters, err := g.getClustersInLocation(zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
managedClusters = append(managedClusters, clusters...) managedClusters = append(managedClusters, clusters...)
} }
} else { } else {
return nil, errors.New(fmt.Sprintf("no zones associated with this cluster(%s)", gce.ProjectID())) return nil, fmt.Errorf("no zones associated with this cluster(%s)", g.ProjectID())
} }
return managedClusters, nil return managedClusters, nil
} }
func (gce *GCECloud) Master(ctx context.Context, clusterName string) (string, error) { // Master returned the dns address of the master
func (g *Cloud) Master(ctx context.Context, clusterName string) (string, error) {
return "k8s-" + clusterName + "-master.internal", nil return "k8s-" + clusterName + "-master.internal", nil
} }
func (gce *GCECloud) listClustersInZone(zone string) ([]string, error) { func (g *Cloud) listClustersInZone(zone string) ([]string, error) {
clusters, err := gce.getClustersInLocation(zone) clusters, err := g.getClustersInLocation(zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -85,12 +87,12 @@ func (gce *GCECloud) listClustersInZone(zone string) ([]string, error) {
return result, nil return result, nil
} }
func (gce *GCECloud) getClustersInLocation(zoneOrRegion string) ([]*container.Cluster, error) { func (g *Cloud) getClustersInLocation(zoneOrRegion string) ([]*container.Cluster, error) {
// TODO: Issue/68913 migrate metric to list_location instead of list_zone. // TODO: Issue/68913 migrate metric to list_location instead of list_zone.
mc := newClustersMetricContext("list_zone", zoneOrRegion) mc := newClustersMetricContext("list_zone", zoneOrRegion)
// TODO: use PageToken to list all not just the first 500 // TODO: use PageToken to list all not just the first 500
location := getLocationName(gce.projectID, zoneOrRegion) location := getLocationName(g.projectID, zoneOrRegion)
list, err := gce.containerService.Projects.Locations.Clusters.List(location).Do() list, err := g.containerService.Projects.Locations.Clusters.List(location).Do()
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }

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

@ -43,10 +43,14 @@ import (
"k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/features"
) )
// DiskType defines a specific type for holding disk types (eg. pd-ssd)
type DiskType string type DiskType string
const ( const (
DiskTypeSSD = "pd-ssd" // DiskTypeSSD the type for persistent SSD storage
DiskTypeSSD = "pd-ssd"
// DiskTypeStandard the type for standard persistent storage
DiskTypeStandard = "pd-standard" DiskTypeStandard = "pd-standard"
diskTypeDefault = DiskTypeStandard diskTypeDefault = DiskTypeStandard
@ -85,7 +89,7 @@ type diskServiceManager interface {
// Attach a persistent disk on GCE with the given disk spec to the specified instance. // Attach a persistent disk on GCE with the given disk spec to the specified instance.
AttachDiskOnCloudProvider( AttachDiskOnCloudProvider(
disk *GCEDisk, disk *Disk,
readWrite string, readWrite string,
instanceZone string, instanceZone string,
instanceName string) error instanceName string) error
@ -96,18 +100,18 @@ type diskServiceManager interface {
instanceName string, instanceName string,
devicePath string) error devicePath string) error
ResizeDiskOnCloudProvider(disk *GCEDisk, sizeGb int64, zone string) error ResizeDiskOnCloudProvider(disk *Disk, sizeGb int64, zone string) error
RegionalResizeDiskOnCloudProvider(disk *GCEDisk, sizeGb int64) error RegionalResizeDiskOnCloudProvider(disk *Disk, sizeGb int64) error
// Gets the persistent disk from GCE with the given diskName. // Gets the persistent disk from GCE with the given diskName.
GetDiskFromCloudProvider(zone string, diskName string) (*GCEDisk, error) GetDiskFromCloudProvider(zone string, diskName string) (*Disk, error)
// Gets the regional persistent disk from GCE with the given diskName. // Gets the regional persistent disk from GCE with the given diskName.
GetRegionalDiskFromCloudProvider(diskName string) (*GCEDisk, error) GetRegionalDiskFromCloudProvider(diskName string) (*Disk, error)
} }
type gceServiceManager struct { type gceServiceManager struct {
gce *GCECloud gce *Cloud
} }
var _ diskServiceManager = &gceServiceManager{} var _ diskServiceManager = &gceServiceManager{}
@ -172,7 +176,7 @@ func (manager *gceServiceManager) CreateRegionalDiskOnCloudProvider(
} }
func (manager *gceServiceManager) AttachDiskOnCloudProvider( func (manager *gceServiceManager) AttachDiskOnCloudProvider(
disk *GCEDisk, disk *Disk,
readWrite string, readWrite string,
instanceZone string, instanceZone string,
instanceName string) error { instanceName string) error {
@ -205,13 +209,13 @@ func (manager *gceServiceManager) DetachDiskOnCloudProvider(
func (manager *gceServiceManager) GetDiskFromCloudProvider( func (manager *gceServiceManager) GetDiskFromCloudProvider(
zone string, zone string,
diskName string) (*GCEDisk, error) { diskName string) (*Disk, error) {
if zone == "" { if zone == "" {
return nil, fmt.Errorf("Can not fetch disk %q. Zone is empty.", diskName) return nil, fmt.Errorf("can not fetch disk %q, zone is empty", diskName)
} }
if diskName == "" { if diskName == "" {
return nil, fmt.Errorf("Can not fetch disk. Zone is specified (%q). But disk name is empty.", zone) return nil, fmt.Errorf("can not fetch disk, zone is specified (%q), but disk name is empty", zone)
} }
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
@ -231,7 +235,7 @@ func (manager *gceServiceManager) GetDiskFromCloudProvider(
return nil, fmt.Errorf("failed to extract region from zone for %q/%q err=%v", zone, diskName, err) return nil, fmt.Errorf("failed to extract region from zone for %q/%q err=%v", zone, diskName, err)
} }
return &GCEDisk{ return &Disk{
ZoneInfo: zoneInfo, ZoneInfo: zoneInfo,
Region: region, Region: region,
Name: diskStable.Name, Name: diskStable.Name,
@ -242,7 +246,7 @@ func (manager *gceServiceManager) GetDiskFromCloudProvider(
} }
func (manager *gceServiceManager) GetRegionalDiskFromCloudProvider( func (manager *gceServiceManager) GetRegionalDiskFromCloudProvider(
diskName string) (*GCEDisk, error) { diskName string) (*Disk, error) {
if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
return nil, fmt.Errorf("the regional PD feature is only available with the %s Kubernetes feature gate enabled", features.GCERegionalPersistentDisk) return nil, fmt.Errorf("the regional PD feature is only available with the %s Kubernetes feature gate enabled", features.GCERegionalPersistentDisk)
@ -260,7 +264,7 @@ func (manager *gceServiceManager) GetRegionalDiskFromCloudProvider(
zones.Insert(lastComponent(zoneURI)) zones.Insert(lastComponent(zoneURI))
} }
return &GCEDisk{ return &Disk{
ZoneInfo: multiZone{zones}, ZoneInfo: multiZone{zones},
Region: lastComponent(diskBeta.Region), Region: lastComponent(diskBeta.Region),
Name: diskBeta.Name, Name: diskBeta.Name,
@ -290,7 +294,7 @@ func (manager *gceServiceManager) DeleteRegionalDiskOnCloudProvider(
return manager.gce.c.BetaRegionDisks().Delete(ctx, meta.RegionalKey(diskName, manager.gce.region)) return manager.gce.c.BetaRegionDisks().Delete(ctx, meta.RegionalKey(diskName, manager.gce.region))
} }
func (manager *gceServiceManager) getDiskSourceURI(disk *GCEDisk) (string, error) { func (manager *gceServiceManager) getDiskSourceURI(disk *Disk) (string, error) {
getProjectsAPIEndpoint := manager.getProjectsAPIEndpoint() getProjectsAPIEndpoint := manager.getProjectsAPIEndpoint()
switch zoneInfo := disk.ZoneInfo.(type) { switch zoneInfo := disk.ZoneInfo.(type) {
@ -409,7 +413,7 @@ func (manager *gceServiceManager) getRegionFromZone(zoneInfo zoneType) (string,
return region, nil return region, nil
} }
func (manager *gceServiceManager) ResizeDiskOnCloudProvider(disk *GCEDisk, sizeGb int64, zone string) error { func (manager *gceServiceManager) ResizeDiskOnCloudProvider(disk *Disk, sizeGb int64, zone string) error {
resizeServiceRequest := &compute.DisksResizeRequest{ resizeServiceRequest := &compute.DisksResizeRequest{
SizeGb: sizeGb, SizeGb: sizeGb,
} }
@ -419,7 +423,7 @@ func (manager *gceServiceManager) ResizeDiskOnCloudProvider(disk *GCEDisk, sizeG
return manager.gce.c.Disks().Resize(ctx, meta.ZonalKey(disk.Name, zone), resizeServiceRequest) return manager.gce.c.Disks().Resize(ctx, meta.ZonalKey(disk.Name, zone), resizeServiceRequest)
} }
func (manager *gceServiceManager) RegionalResizeDiskOnCloudProvider(disk *GCEDisk, sizeGb int64) error { func (manager *gceServiceManager) RegionalResizeDiskOnCloudProvider(disk *Disk, sizeGb int64) error {
if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
return fmt.Errorf("the regional PD feature is only available with the %s Kubernetes feature gate enabled", features.GCERegionalPersistentDisk) return fmt.Errorf("the regional PD feature is only available with the %s Kubernetes feature gate enabled", features.GCERegionalPersistentDisk)
} }
@ -472,13 +476,14 @@ type Disks interface {
GetAutoLabelsForPD(name string, zone string) (map[string]string, error) GetAutoLabelsForPD(name string, zone string) (map[string]string, error)
} }
// GCECloud implements Disks. // Cloud implements Disks.
var _ Disks = (*GCECloud)(nil) var _ Disks = (*Cloud)(nil)
// GCECloud implements PVLabeler. // Cloud implements PVLabeler.
var _ cloudprovider.PVLabeler = (*GCECloud)(nil) var _ cloudprovider.PVLabeler = (*Cloud)(nil)
type GCEDisk struct { // Disk holds all relevant data about an instance of GCE storage
type Disk struct {
ZoneInfo zoneType ZoneInfo zoneType
Region string Region string
Name string Name string
@ -510,7 +515,8 @@ func newDiskMetricContextRegional(request, region string) *metricContext {
return newGenericMetricContext("disk", request, region, unusedMetricLabel, computeV1Version) return newGenericMetricContext("disk", request, region, unusedMetricLabel, computeV1Version)
} }
func (gce *GCECloud) GetLabelsForVolume(ctx context.Context, pv *v1.PersistentVolume) (map[string]string, error) { // GetLabelsForVolume retrieved the label info for the provided volume
func (g *Cloud) GetLabelsForVolume(ctx context.Context, pv *v1.PersistentVolume) (map[string]string, error) {
// Ignore any volumes that are being provisioned // Ignore any volumes that are being provisioned
if pv.Spec.GCEPersistentDisk.PDName == volume.ProvisionedVolumeName { if pv.Spec.GCEPersistentDisk.PDName == volume.ProvisionedVolumeName {
return nil, nil return nil, nil
@ -519,7 +525,7 @@ func (gce *GCECloud) GetLabelsForVolume(ctx context.Context, pv *v1.PersistentVo
// If the zone is already labeled, honor the hint // If the zone is already labeled, honor the hint
zone := pv.Labels[kubeletapis.LabelZoneFailureDomain] zone := pv.Labels[kubeletapis.LabelZoneFailureDomain]
labels, err := gce.GetAutoLabelsForPD(pv.Spec.GCEPersistentDisk.PDName, zone) labels, err := g.GetAutoLabelsForPD(pv.Spec.GCEPersistentDisk.PDName, zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -527,28 +533,30 @@ func (gce *GCECloud) GetLabelsForVolume(ctx context.Context, pv *v1.PersistentVo
return labels, nil return labels, nil
} }
func (gce *GCECloud) AttachDisk(diskName string, nodeName types.NodeName, readOnly bool, regional bool) error { // AttachDisk attaches given disk to the node with the specified NodeName.
// Current instance is used when instanceID is empty string.
func (g *Cloud) AttachDisk(diskName string, nodeName types.NodeName, readOnly bool, regional bool) error {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
return fmt.Errorf("error getting instance %q", instanceName) return fmt.Errorf("error getting instance %q", instanceName)
} }
// Try fetching as regional PD // Try fetching as regional PD
var disk *GCEDisk var disk *Disk
var mc *metricContext var mc *metricContext
if regional && utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if regional && utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
disk, err = gce.getRegionalDiskByName(diskName) disk, err = g.getRegionalDiskByName(diskName)
if err != nil { if err != nil {
return err return err
} }
mc = newDiskMetricContextRegional("attach", gce.region) mc = newDiskMetricContextRegional("attach", g.region)
} else { } else {
disk, err = gce.getDiskByName(diskName, instance.Zone) disk, err = g.getDiskByName(diskName, instance.Zone)
if err != nil { if err != nil {
return err return err
} }
mc = newDiskMetricContextZonal("attach", gce.region, instance.Zone) mc = newDiskMetricContextZonal("attach", g.region, instance.Zone)
} }
readWrite := "READ_WRITE" readWrite := "READ_WRITE"
@ -556,12 +564,14 @@ func (gce *GCECloud) AttachDisk(diskName string, nodeName types.NodeName, readOn
readWrite = "READ_ONLY" readWrite = "READ_ONLY"
} }
return mc.Observe(gce.manager.AttachDiskOnCloudProvider(disk, readWrite, instance.Zone, instance.Name)) return mc.Observe(g.manager.AttachDiskOnCloudProvider(disk, readWrite, instance.Zone, instance.Name))
} }
func (gce *GCECloud) DetachDisk(devicePath string, nodeName types.NodeName) error { // DetachDisk detaches given disk to the node with the specified NodeName.
// Current instance is used when nodeName is empty string.
func (g *Cloud) DetachDisk(devicePath string, nodeName types.NodeName) error {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
inst, err := gce.getInstanceByName(instanceName) inst, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
if err == cloudprovider.InstanceNotFound { if err == cloudprovider.InstanceNotFound {
// If instance no longer exists, safe to assume volume is not attached. // If instance no longer exists, safe to assume volume is not attached.
@ -575,13 +585,14 @@ func (gce *GCECloud) DetachDisk(devicePath string, nodeName types.NodeName) erro
return fmt.Errorf("error getting instance %q", instanceName) return fmt.Errorf("error getting instance %q", instanceName)
} }
mc := newDiskMetricContextZonal("detach", gce.region, inst.Zone) mc := newDiskMetricContextZonal("detach", g.region, inst.Zone)
return mc.Observe(gce.manager.DetachDiskOnCloudProvider(inst.Zone, inst.Name, devicePath)) return mc.Observe(g.manager.DetachDiskOnCloudProvider(inst.Zone, inst.Name, devicePath))
} }
func (gce *GCECloud) DiskIsAttached(diskName string, nodeName types.NodeName) (bool, error) { // DiskIsAttached checks if a disk is attached to the node with the specified NodeName.
func (g *Cloud) DiskIsAttached(diskName string, nodeName types.NodeName) (bool, error) {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
if err == cloudprovider.InstanceNotFound { if err == cloudprovider.InstanceNotFound {
// If instance no longer exists, safe to assume volume is not attached. // If instance no longer exists, safe to assume volume is not attached.
@ -605,13 +616,15 @@ func (gce *GCECloud) DiskIsAttached(diskName string, nodeName types.NodeName) (b
return false, nil return false, nil
} }
func (gce *GCECloud) DisksAreAttached(diskNames []string, nodeName types.NodeName) (map[string]bool, error) { // DisksAreAttached is a batch function to check if a list of disks are attached
// to the node with the specified NodeName.
func (g *Cloud) DisksAreAttached(diskNames []string, nodeName types.NodeName) (map[string]bool, error) {
attached := make(map[string]bool) attached := make(map[string]bool)
for _, diskName := range diskNames { for _, diskName := range diskNames {
attached[diskName] = false attached[diskName] = false
} }
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
if err == cloudprovider.InstanceNotFound { if err == cloudprovider.InstanceNotFound {
// If instance no longer exists, safe to assume volume is not attached. // If instance no longer exists, safe to assume volume is not attached.
@ -640,11 +653,11 @@ func (gce *GCECloud) DisksAreAttached(diskNames []string, nodeName types.NodeNam
// CreateDisk creates a new Persistent Disk, with the specified name & // CreateDisk creates a new Persistent Disk, with the specified name &
// size, in the specified zone. It stores specified tags encoded in // size, in the specified zone. It stores specified tags encoded in
// JSON in Description field. // JSON in Description field.
func (gce *GCECloud) CreateDisk( func (g *Cloud) CreateDisk(
name string, diskType string, zone string, sizeGb int64, tags map[string]string) error { name string, diskType string, zone string, sizeGb int64, tags map[string]string) error {
// Do not allow creation of PDs in zones that are do not have nodes. Such PDs // Do not allow creation of PDs in zones that are do not have nodes. Such PDs
// are not currently usable. // are not currently usable.
curZones, err := gce.GetAllCurrentZones() curZones, err := g.GetAllCurrentZones()
if err != nil { if err != nil {
return err return err
} }
@ -652,7 +665,7 @@ func (gce *GCECloud) CreateDisk(
return fmt.Errorf("kubernetes does not have a node in zone %q", zone) return fmt.Errorf("kubernetes does not have a node in zone %q", zone)
} }
tagsStr, err := gce.encodeDiskTags(tags) tagsStr, err := g.encodeDiskTags(tags)
if err != nil { if err != nil {
return err return err
} }
@ -662,9 +675,9 @@ func (gce *GCECloud) CreateDisk(
return err return err
} }
mc := newDiskMetricContextZonal("create", gce.region, zone) mc := newDiskMetricContextZonal("create", g.region, zone)
err = gce.manager.CreateDiskOnCloudProvider( err = g.manager.CreateDiskOnCloudProvider(
name, sizeGb, tagsStr, diskType, zone) name, sizeGb, tagsStr, diskType, zone)
mc.Observe(err) mc.Observe(err)
@ -678,14 +691,14 @@ func (gce *GCECloud) CreateDisk(
// CreateRegionalDisk creates a new Regional Persistent Disk, with the specified // CreateRegionalDisk creates a new Regional Persistent Disk, with the specified
// name & size, replicated to the specified zones. It stores specified tags // name & size, replicated to the specified zones. It stores specified tags
// encoded in JSON in Description field. // encoded in JSON in Description field.
func (gce *GCECloud) CreateRegionalDisk( func (g *Cloud) CreateRegionalDisk(
name string, diskType string, replicaZones sets.String, sizeGb int64, tags map[string]string) error { name string, diskType string, replicaZones sets.String, sizeGb int64, tags map[string]string) error {
// Do not allow creation of PDs in zones that are do not have nodes. Such PDs // Do not allow creation of PDs in zones that are do not have nodes. Such PDs
// are not currently usable. This functionality should be reverted to checking // are not currently usable. This functionality should be reverted to checking
// against managed zones if we want users to be able to create RegionalDisks // against managed zones if we want users to be able to create RegionalDisks
// in zones where there are no nodes // in zones where there are no nodes
curZones, err := gce.GetAllCurrentZones() curZones, err := g.GetAllCurrentZones()
if err != nil { if err != nil {
return err return err
} }
@ -693,7 +706,7 @@ func (gce *GCECloud) CreateRegionalDisk(
return fmt.Errorf("kubernetes does not have nodes in specified zones: %q. Zones that contain nodes: %q", replicaZones.Difference(curZones), curZones) return fmt.Errorf("kubernetes does not have nodes in specified zones: %q. Zones that contain nodes: %q", replicaZones.Difference(curZones), curZones)
} }
tagsStr, err := gce.encodeDiskTags(tags) tagsStr, err := g.encodeDiskTags(tags)
if err != nil { if err != nil {
return err return err
} }
@ -703,9 +716,9 @@ func (gce *GCECloud) CreateRegionalDisk(
return err return err
} }
mc := newDiskMetricContextRegional("create", gce.region) mc := newDiskMetricContextRegional("create", g.region)
err = gce.manager.CreateRegionalDiskOnCloudProvider( err = g.manager.CreateRegionalDiskOnCloudProvider(
name, sizeGb, tagsStr, diskType, replicaZones) name, sizeGb, tagsStr, diskType, replicaZones)
mc.Observe(err) mc.Observe(err)
@ -727,8 +740,9 @@ func getDiskType(diskType string) (string, error) {
} }
} }
func (gce *GCECloud) DeleteDisk(diskToDelete string) error { // DeleteDisk deletes rgw referenced persistent disk.
err := gce.doDeleteDisk(diskToDelete) func (g *Cloud) DeleteDisk(diskToDelete string) error {
err := g.doDeleteDisk(diskToDelete)
if isGCEError(err, "resourceInUseByAnotherResource") { if isGCEError(err, "resourceInUseByAnotherResource") {
return volume.NewDeletedVolumeInUseError(err.Error()) return volume.NewDeletedVolumeInUseError(err.Error())
} }
@ -740,8 +754,8 @@ func (gce *GCECloud) DeleteDisk(diskToDelete string) error {
} }
// ResizeDisk expands given disk and returns new disk size // ResizeDisk expands given disk and returns new disk size
func (gce *GCECloud) ResizeDisk(diskToResize string, oldSize resource.Quantity, newSize resource.Quantity) (resource.Quantity, error) { func (g *Cloud) ResizeDisk(diskToResize string, oldSize resource.Quantity, newSize resource.Quantity) (resource.Quantity, error) {
disk, err := gce.GetDiskByNameUnknownZone(diskToResize) disk, err := g.GetDiskByNameUnknownZone(diskToResize)
if err != nil { if err != nil {
return oldSize, err return oldSize, err
} }
@ -760,26 +774,24 @@ func (gce *GCECloud) ResizeDisk(diskToResize string, oldSize resource.Quantity,
switch zoneInfo := disk.ZoneInfo.(type) { switch zoneInfo := disk.ZoneInfo.(type) {
case singleZone: case singleZone:
mc = newDiskMetricContextZonal("resize", disk.Region, zoneInfo.zone) mc = newDiskMetricContextZonal("resize", disk.Region, zoneInfo.zone)
err := gce.manager.ResizeDiskOnCloudProvider(disk, requestGIB, zoneInfo.zone) err := g.manager.ResizeDiskOnCloudProvider(disk, requestGIB, zoneInfo.zone)
if err != nil { if err != nil {
return oldSize, mc.Observe(err) return oldSize, mc.Observe(err)
} else {
return newSizeQuant, mc.Observe(err)
} }
return newSizeQuant, mc.Observe(err)
case multiZone: case multiZone:
if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
return oldSize, fmt.Errorf("disk.ZoneInfo has unexpected type %T", zoneInfo) return oldSize, fmt.Errorf("disk.ZoneInfo has unexpected type %T", zoneInfo)
} }
mc = newDiskMetricContextRegional("resize", disk.Region) mc = newDiskMetricContextRegional("resize", disk.Region)
err := gce.manager.RegionalResizeDiskOnCloudProvider(disk, requestGIB) err := g.manager.RegionalResizeDiskOnCloudProvider(disk, requestGIB)
if err != nil { if err != nil {
return oldSize, mc.Observe(err) return oldSize, mc.Observe(err)
} else {
return newSizeQuant, mc.Observe(err)
} }
return newSizeQuant, mc.Observe(err)
case nil: case nil:
return oldSize, fmt.Errorf("PD has nil ZoneInfo: %v", disk) return oldSize, fmt.Errorf("PD has nil ZoneInfo: %v", disk)
default: default:
@ -787,13 +799,13 @@ func (gce *GCECloud) ResizeDisk(diskToResize string, oldSize resource.Quantity,
} }
} }
// Builds the labels that should be automatically added to a PersistentVolume backed by a GCE PD // GetAutoLabelsForPD builds the labels that should be automatically added to a PersistentVolume backed by a GCE PD
// Specifically, this builds FailureDomain (zone) and Region labels. // Specifically, this builds FailureDomain (zone) and Region labels.
// The PersistentVolumeLabel admission controller calls this and adds the labels when a PV is created. // The PersistentVolumeLabel admission controller calls this and adds the labels when a PV is created.
// If zone is specified, the volume will only be found in the specified zone, // If zone is specified, the volume will only be found in the specified zone,
// otherwise all managed zones will be searched. // otherwise all managed zones will be searched.
func (gce *GCECloud) GetAutoLabelsForPD(name string, zone string) (map[string]string, error) { func (g *Cloud) GetAutoLabelsForPD(name string, zone string) (map[string]string, error) {
var disk *GCEDisk var disk *Disk
var err error var err error
if zone == "" { if zone == "" {
// For regional PDs this is fine, but for zonal PDs we would like as far // For regional PDs this is fine, but for zonal PDs we would like as far
@ -804,7 +816,7 @@ func (gce *GCECloud) GetAutoLabelsForPD(name string, zone string) (map[string]st
// However, wherever possible the zone should be passed (and it is // However, wherever possible the zone should be passed (and it is
// passed for most cases that we can control, e.g. dynamic volume // passed for most cases that we can control, e.g. dynamic volume
// provisioning). // provisioning).
disk, err = gce.GetDiskByNameUnknownZone(name) disk, err = g.GetDiskByNameUnknownZone(name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -820,19 +832,19 @@ func (gce *GCECloud) GetAutoLabelsForPD(name string, zone string) (map[string]st
if len(zoneSet) > 1 { if len(zoneSet) > 1 {
// Regional PD // Regional PD
disk, err = gce.getRegionalDiskByName(name) disk, err = g.getRegionalDiskByName(name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} else { } else {
// Zonal PD // Zonal PD
disk, err = gce.getDiskByName(name, zone) disk, err = g.getDiskByName(name, zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
} }
} else { } else {
disk, err = gce.getDiskByName(name, zone) disk, err = g.getDiskByName(name, zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -867,11 +879,11 @@ func (gce *GCECloud) GetAutoLabelsForPD(name string, zone string) (map[string]st
return labels, nil return labels, nil
} }
// Returns a GCEDisk for the disk, if it is found in the specified zone. // Returns a Disk for the disk, if it is found in the specified zone.
// If not found, returns (nil, nil) // If not found, returns (nil, nil)
func (gce *GCECloud) findDiskByName(diskName string, zone string) (*GCEDisk, error) { func (g *Cloud) findDiskByName(diskName string, zone string) (*Disk, error) {
mc := newDiskMetricContextZonal("get", gce.region, zone) mc := newDiskMetricContextZonal("get", g.region, zone)
disk, err := gce.manager.GetDiskFromCloudProvider(zone, diskName) disk, err := g.manager.GetDiskFromCloudProvider(zone, diskName)
if err == nil { if err == nil {
return disk, mc.Observe(nil) return disk, mc.Observe(nil)
} }
@ -882,19 +894,19 @@ func (gce *GCECloud) findDiskByName(diskName string, zone string) (*GCEDisk, err
} }
// Like findDiskByName, but returns an error if the disk is not found // Like findDiskByName, but returns an error if the disk is not found
func (gce *GCECloud) getDiskByName(diskName string, zone string) (*GCEDisk, error) { func (g *Cloud) getDiskByName(diskName string, zone string) (*Disk, error) {
disk, err := gce.findDiskByName(diskName, zone) disk, err := g.findDiskByName(diskName, zone)
if disk == nil && err == nil { if disk == nil && err == nil {
return nil, fmt.Errorf("GCE persistent disk not found: diskName=%q zone=%q", diskName, zone) return nil, fmt.Errorf("GCE persistent disk not found: diskName=%q zone=%q", diskName, zone)
} }
return disk, err return disk, err
} }
// Returns a GCEDisk for the regional disk, if it is found. // Returns a Disk for the regional disk, if it is found.
// If not found, returns (nil, nil) // If not found, returns (nil, nil)
func (gce *GCECloud) findRegionalDiskByName(diskName string) (*GCEDisk, error) { func (g *Cloud) findRegionalDiskByName(diskName string) (*Disk, error) {
mc := newDiskMetricContextRegional("get", gce.region) mc := newDiskMetricContextRegional("get", g.region)
disk, err := gce.manager.GetRegionalDiskFromCloudProvider(diskName) disk, err := g.manager.GetRegionalDiskFromCloudProvider(diskName)
if err == nil { if err == nil {
return disk, mc.Observe(nil) return disk, mc.Observe(nil)
} }
@ -905,20 +917,20 @@ func (gce *GCECloud) findRegionalDiskByName(diskName string) (*GCEDisk, error) {
} }
// Like findRegionalDiskByName, but returns an error if the disk is not found // Like findRegionalDiskByName, but returns an error if the disk is not found
func (gce *GCECloud) getRegionalDiskByName(diskName string) (*GCEDisk, error) { func (g *Cloud) getRegionalDiskByName(diskName string) (*Disk, error) {
disk, err := gce.findRegionalDiskByName(diskName) disk, err := g.findRegionalDiskByName(diskName)
if disk == nil && err == nil { if disk == nil && err == nil {
return nil, fmt.Errorf("GCE regional persistent disk not found: diskName=%q", diskName) return nil, fmt.Errorf("GCE regional persistent disk not found: diskName=%q", diskName)
} }
return disk, err return disk, err
} }
// Scans all managed zones to return the GCE PD // GetDiskByNameUnknownZone scans all managed zones to return the GCE PD
// Prefer getDiskByName, if the zone can be established // Prefer getDiskByName, if the zone can be established
// Return cloudprovider.DiskNotFound if the given disk cannot be found in any zone // Return cloudprovider.DiskNotFound if the given disk cannot be found in any zone
func (gce *GCECloud) GetDiskByNameUnknownZone(diskName string) (*GCEDisk, error) { func (g *Cloud) GetDiskByNameUnknownZone(diskName string) (*Disk, error) {
if utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
regionalDisk, err := gce.getRegionalDiskByName(diskName) regionalDisk, err := g.getRegionalDiskByName(diskName)
if err == nil { if err == nil {
return regionalDisk, err return regionalDisk, err
} }
@ -934,9 +946,9 @@ func (gce *GCECloud) GetDiskByNameUnknownZone(diskName string) (*GCEDisk, error)
// admission control, but that might be a little weird (values changing // admission control, but that might be a little weird (values changing
// on create) // on create)
var found *GCEDisk var found *Disk
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
disk, err := gce.findDiskByName(diskName, zone) disk, err := g.findDiskByName(diskName, zone)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -964,14 +976,14 @@ func (gce *GCECloud) GetDiskByNameUnknownZone(diskName string) (*GCEDisk, error)
return found, nil return found, nil
} }
glog.Warningf("GCE persistent disk %q not found in managed zones (%s)", glog.Warningf("GCE persistent disk %q not found in managed zones (%s)",
diskName, strings.Join(gce.managedZones, ",")) diskName, strings.Join(g.managedZones, ","))
return nil, cloudprovider.DiskNotFound return nil, cloudprovider.DiskNotFound
} }
// encodeDiskTags encodes requested volume tags into JSON string, as GCE does // encodeDiskTags encodes requested volume tags into JSON string, as GCE does
// not support tags on GCE PDs and we use Description field as fallback. // not support tags on GCE PDs and we use Description field as fallback.
func (gce *GCECloud) encodeDiskTags(tags map[string]string) (string, error) { func (g *Cloud) encodeDiskTags(tags map[string]string) (string, error) {
if len(tags) == 0 { if len(tags) == 0 {
// No tags -> empty JSON // No tags -> empty JSON
return "", nil return "", nil
@ -984,8 +996,8 @@ func (gce *GCECloud) encodeDiskTags(tags map[string]string) (string, error) {
return string(enc), nil return string(enc), nil
} }
func (gce *GCECloud) doDeleteDisk(diskToDelete string) error { func (g *Cloud) doDeleteDisk(diskToDelete string) error {
disk, err := gce.GetDiskByNameUnknownZone(diskToDelete) disk, err := g.GetDiskByNameUnknownZone(diskToDelete)
if err != nil { if err != nil {
return err return err
} }
@ -995,14 +1007,14 @@ func (gce *GCECloud) doDeleteDisk(diskToDelete string) error {
switch zoneInfo := disk.ZoneInfo.(type) { switch zoneInfo := disk.ZoneInfo.(type) {
case singleZone: case singleZone:
mc = newDiskMetricContextZonal("delete", disk.Region, zoneInfo.zone) mc = newDiskMetricContextZonal("delete", disk.Region, zoneInfo.zone)
return mc.Observe(gce.manager.DeleteDiskOnCloudProvider(zoneInfo.zone, disk.Name)) return mc.Observe(g.manager.DeleteDiskOnCloudProvider(zoneInfo.zone, disk.Name))
case multiZone: case multiZone:
if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) { if !utilfeature.DefaultFeatureGate.Enabled(features.GCERegionalPersistentDisk) {
return fmt.Errorf("disk.ZoneInfo has unexpected type %T", zoneInfo) return fmt.Errorf("disk.ZoneInfo has unexpected type %T", zoneInfo)
} }
mc = newDiskMetricContextRegional("delete", disk.Region) mc = newDiskMetricContextRegional("delete", disk.Region)
return mc.Observe(gce.manager.DeleteRegionalDiskOnCloudProvider(disk.Name)) return mc.Observe(g.manager.DeleteRegionalDiskOnCloudProvider(disk.Name))
case nil: case nil:
return fmt.Errorf("PD has nil ZoneInfo: %v", disk) return fmt.Errorf("PD has nil ZoneInfo: %v", disk)
default: default:

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

@ -35,15 +35,15 @@ import (
func TestCreateDisk_Basic(t *testing.T) { func TestCreateDisk_Basic(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: []string{"zone1"}, managedZones: []string{"zone1"},
projectID: gceProjectId, projectID: gceProjectID,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
nodeInformerSynced: func() bool { return true }, nodeInformerSynced: func() bool { return true },
@ -57,7 +57,7 @@ func TestCreateDisk_Basic(t *testing.T) {
tags["test-tag"] = "test-value" tags["test-tag"] = "test-value"
expectedDiskTypeURI := gceComputeAPIEndpoint + "projects/" + fmt.Sprintf( expectedDiskTypeURI := gceComputeAPIEndpoint + "projects/" + fmt.Sprintf(
diskTypeURITemplateSingleZone, gceProjectId, zone, diskType) diskTypeURITemplateSingleZone, gceProjectID, zone, diskType)
expectedDescription := "{\"test-tag\":\"test-value\"}" expectedDescription := "{\"test-tag\":\"test-value\"}"
/* Act */ /* Act */
@ -90,15 +90,15 @@ func TestCreateDisk_Basic(t *testing.T) {
func TestCreateRegionalDisk_Basic(t *testing.T) { func TestCreateRegionalDisk_Basic(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1", "zone3", "zone2"} zonesWithNodes := []string{"zone1", "zone3", "zone2"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
projectID: gceProjectId, projectID: gceProjectID,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
nodeInformerSynced: func() bool { return true }, nodeInformerSynced: func() bool { return true },
} }
@ -111,7 +111,7 @@ func TestCreateRegionalDisk_Basic(t *testing.T) {
tags["test-tag"] = "test-value" tags["test-tag"] = "test-value"
expectedDiskTypeURI := gceComputeAPIEndpointBeta + "projects/" + fmt.Sprintf( expectedDiskTypeURI := gceComputeAPIEndpointBeta + "projects/" + fmt.Sprintf(
diskTypeURITemplateRegional, gceProjectId, gceRegion, diskType) diskTypeURITemplateRegional, gceProjectID, gceRegion, diskType)
expectedDescription := "{\"test-tag\":\"test-value\"}" expectedDescription := "{\"test-tag\":\"test-value\"}"
/* Act */ /* Act */
@ -144,12 +144,12 @@ func TestCreateRegionalDisk_Basic(t *testing.T) {
func TestCreateDisk_DiskAlreadyExists(t *testing.T) { func TestCreateDisk_DiskAlreadyExists(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -175,11 +175,11 @@ func TestCreateDisk_DiskAlreadyExists(t *testing.T) {
func TestCreateDisk_WrongZone(t *testing.T) { func TestCreateDisk_WrongZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
@ -200,11 +200,11 @@ func TestCreateDisk_WrongZone(t *testing.T) {
func TestCreateDisk_NoManagedZone(t *testing.T) { func TestCreateDisk_NoManagedZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{} zonesWithNodes := []string{}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
@ -225,11 +225,11 @@ func TestCreateDisk_NoManagedZone(t *testing.T) {
func TestCreateDisk_BadDiskType(t *testing.T) { func TestCreateDisk_BadDiskType(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
gce := GCECloud{manager: fakeManager, gce := Cloud{manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
nodeInformerSynced: func() bool { return true }} nodeInformerSynced: func() bool { return true }}
@ -250,12 +250,12 @@ func TestCreateDisk_BadDiskType(t *testing.T) {
func TestCreateDisk_MultiZone(t *testing.T) { func TestCreateDisk_MultiZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1", "zone2", "zone3"} zonesWithNodes := []string{"zone1", "zone2", "zone3"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -279,12 +279,12 @@ func TestCreateDisk_MultiZone(t *testing.T) {
func TestDeleteDisk_Basic(t *testing.T) { func TestDeleteDisk_Basic(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -313,12 +313,12 @@ func TestDeleteDisk_Basic(t *testing.T) {
func TestDeleteDisk_NotFound(t *testing.T) { func TestDeleteDisk_NotFound(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -338,12 +338,12 @@ func TestDeleteDisk_NotFound(t *testing.T) {
func TestDeleteDisk_ResourceBeingUsed(t *testing.T) { func TestDeleteDisk_ResourceBeingUsed(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -369,12 +369,12 @@ func TestDeleteDisk_ResourceBeingUsed(t *testing.T) {
func TestDeleteDisk_SameDiskMultiZone(t *testing.T) { func TestDeleteDisk_SameDiskMultiZone(t *testing.T) {
/* Assert */ /* Assert */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1", "zone2", "zone3"} zonesWithNodes := []string{"zone1", "zone2", "zone3"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -403,12 +403,12 @@ func TestDeleteDisk_SameDiskMultiZone(t *testing.T) {
func TestDeleteDisk_DiffDiskMultiZone(t *testing.T) { func TestDeleteDisk_DiffDiskMultiZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"zone1"} zonesWithNodes := []string{"zone1"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -437,16 +437,16 @@ func TestDeleteDisk_DiffDiskMultiZone(t *testing.T) {
func TestGetAutoLabelsForPD_Basic(t *testing.T) { func TestGetAutoLabelsForPD_Basic(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "us-central1" gceRegion := "us-central1"
zone := "us-central1-c" zone := "us-central1-c"
zonesWithNodes := []string{zone} zonesWithNodes := []string{zone}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
diskType := DiskTypeSSD diskType := DiskTypeSSD
const sizeGb int64 = 128 const sizeGb int64 = 128
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -474,16 +474,16 @@ func TestGetAutoLabelsForPD_Basic(t *testing.T) {
func TestGetAutoLabelsForPD_NoZone(t *testing.T) { func TestGetAutoLabelsForPD_NoZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "europe-west1" gceRegion := "europe-west1"
zone := "europe-west1-d" zone := "europe-west1-d"
zonesWithNodes := []string{zone} zonesWithNodes := []string{zone}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
diskType := DiskTypeStandard diskType := DiskTypeStandard
const sizeGb int64 = 128 const sizeGb int64 = 128
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -510,13 +510,13 @@ func TestGetAutoLabelsForPD_NoZone(t *testing.T) {
func TestGetAutoLabelsForPD_DiskNotFound(t *testing.T) { func TestGetAutoLabelsForPD_DiskNotFound(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zone := "asia-northeast1-a" zone := "asia-northeast1-a"
zonesWithNodes := []string{zone} zonesWithNodes := []string{zone}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
gce := GCECloud{manager: fakeManager, gce := Cloud{manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
nodeZones: createNodeZones(zonesWithNodes), nodeZones: createNodeZones(zonesWithNodes),
nodeInformerSynced: func() bool { return true }} nodeInformerSynced: func() bool { return true }}
@ -532,13 +532,13 @@ func TestGetAutoLabelsForPD_DiskNotFound(t *testing.T) {
func TestGetAutoLabelsForPD_DiskNotFoundAndNoZone(t *testing.T) { func TestGetAutoLabelsForPD_DiskNotFoundAndNoZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{} zonesWithNodes := []string{}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -557,17 +557,17 @@ func TestGetAutoLabelsForPD_DiskNotFoundAndNoZone(t *testing.T) {
func TestGetAutoLabelsForPD_DupDisk(t *testing.T) { func TestGetAutoLabelsForPD_DupDisk(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "us-west1" gceRegion := "us-west1"
zonesWithNodes := []string{"us-west1-b", "asia-southeast1-a"} zonesWithNodes := []string{"us-west1-b", "asia-southeast1-a"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
diskType := DiskTypeStandard diskType := DiskTypeStandard
zone := "us-west1-b" zone := "us-west1-b"
const sizeGb int64 = 128 const sizeGb int64 = 128
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -596,16 +596,16 @@ func TestGetAutoLabelsForPD_DupDisk(t *testing.T) {
func TestGetAutoLabelsForPD_DupDiskNoZone(t *testing.T) { func TestGetAutoLabelsForPD_DupDiskNoZone(t *testing.T) {
/* Arrange */ /* Arrange */
gceProjectId := "test-project" gceProjectID := "test-project"
gceRegion := "fake-region" gceRegion := "fake-region"
zonesWithNodes := []string{"us-west1-b", "asia-southeast1-a"} zonesWithNodes := []string{"us-west1-b", "asia-southeast1-a"}
fakeManager := newFakeManager(gceProjectId, gceRegion) fakeManager := newFakeManager(gceProjectID, gceRegion)
diskName := "disk" diskName := "disk"
diskType := DiskTypeStandard diskType := DiskTypeStandard
const sizeGb int64 = 128 const sizeGb int64 = 128
alphaFeatureGate := NewAlphaFeatureGate([]string{}) alphaFeatureGate := NewAlphaFeatureGate([]string{})
gce := GCECloud{ gce := Cloud{
manager: fakeManager, manager: fakeManager,
managedZones: zonesWithNodes, managedZones: zonesWithNodes,
AlphaFeatureGate: alphaFeatureGate, AlphaFeatureGate: alphaFeatureGate,
@ -738,16 +738,16 @@ func (manager *FakeServiceManager) CreateRegionalDiskOnCloudProvider(
manager.regionalDisks[diskToCreateV1.Name] = zones manager.regionalDisks[diskToCreateV1.Name] = zones
return nil return nil
case targetBeta: case targetBeta:
return fmt.Errorf("RegionalDisk CreateDisk op not supported in beta.") return fmt.Errorf("regionalDisk CreateDisk op not supported in beta")
case targetAlpha: case targetAlpha:
return fmt.Errorf("RegionalDisk CreateDisk op not supported in alpha.") return fmt.Errorf("regionalDisk CreateDisk op not supported in alpha")
default: default:
return fmt.Errorf("unexpected type: %T", t) return fmt.Errorf("unexpected type: %T", t)
} }
} }
func (manager *FakeServiceManager) AttachDiskOnCloudProvider( func (manager *FakeServiceManager) AttachDiskOnCloudProvider(
disk *GCEDisk, disk *Disk,
readWrite string, readWrite string,
instanceZone string, instanceZone string,
instanceName string) error { instanceName string) error {
@ -784,7 +784,7 @@ func (manager *FakeServiceManager) DetachDiskOnCloudProvider(
* Gets disk info stored in the FakeServiceManager. * Gets disk info stored in the FakeServiceManager.
*/ */
func (manager *FakeServiceManager) GetDiskFromCloudProvider( func (manager *FakeServiceManager) GetDiskFromCloudProvider(
zone string, diskName string) (*GCEDisk, error) { zone string, diskName string) (*Disk, error) {
if manager.zonalDisks[zone] == "" { if manager.zonalDisks[zone] == "" {
return nil, cloudprovider.DiskNotFound return nil, cloudprovider.DiskNotFound
@ -796,7 +796,7 @@ func (manager *FakeServiceManager) GetDiskFromCloudProvider(
return nil, err return nil, err
} }
return &GCEDisk{ return &Disk{
Region: manager.gceRegion, Region: manager.gceRegion,
ZoneInfo: singleZone{lastComponent(zone)}, ZoneInfo: singleZone{lastComponent(zone)},
Name: diskName, Name: diskName,
@ -809,7 +809,7 @@ func (manager *FakeServiceManager) GetDiskFromCloudProvider(
* Gets disk info stored in the FakeServiceManager. * Gets disk info stored in the FakeServiceManager.
*/ */
func (manager *FakeServiceManager) GetRegionalDiskFromCloudProvider( func (manager *FakeServiceManager) GetRegionalDiskFromCloudProvider(
diskName string) (*GCEDisk, error) { diskName string) (*Disk, error) {
if _, ok := manager.regionalDisks[diskName]; !ok { if _, ok := manager.regionalDisks[diskName]; !ok {
return nil, cloudprovider.DiskNotFound return nil, cloudprovider.DiskNotFound
@ -821,7 +821,7 @@ func (manager *FakeServiceManager) GetRegionalDiskFromCloudProvider(
return nil, err return nil, err
} }
return &GCEDisk{ return &Disk{
Region: manager.gceRegion, Region: manager.gceRegion,
ZoneInfo: multiZone{manager.regionalDisks[diskName]}, ZoneInfo: multiZone{manager.regionalDisks[diskName]},
Name: diskName, Name: diskName,
@ -831,14 +831,14 @@ func (manager *FakeServiceManager) GetRegionalDiskFromCloudProvider(
} }
func (manager *FakeServiceManager) ResizeDiskOnCloudProvider( func (manager *FakeServiceManager) ResizeDiskOnCloudProvider(
disk *GCEDisk, disk *Disk,
size int64, size int64,
zone string) error { zone string) error {
panic("Not implmented") panic("Not implmented")
} }
func (manager *FakeServiceManager) RegionalResizeDiskOnCloudProvider( func (manager *FakeServiceManager) RegionalResizeDiskOnCloudProvider(
disk *GCEDisk, disk *Disk,
size int64) error { size int64) error {
panic("Not implemented") panic("Not implemented")
} }

12
pkg/cloudprovider/providers/gce/gce_fake.go
View File

@ -25,6 +25,7 @@ import (
"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud"
) )
// TestClusterValues holds the config values for the fake/test gce cloud object.
type TestClusterValues struct { type TestClusterValues struct {
ProjectID string ProjectID string
Region string Region string
@ -34,6 +35,8 @@ type TestClusterValues struct {
ClusterName string ClusterName string
} }
// DefaultTestClusterValues Creates a reasonable set of default cluster values
// for generating a new test fake GCE cloud instance.
func DefaultTestClusterValues() TestClusterValues { func DefaultTestClusterValues() TestClusterValues {
return TestClusterValues{ return TestClusterValues{
ProjectID: "test-project", ProjectID: "test-project",
@ -45,10 +48,6 @@ func DefaultTestClusterValues() TestClusterValues {
} }
} }
func FakeGCECloud(vals TestClusterValues) *GCECloud {
return simpleFakeGCECloud(vals)
}
type fakeRoundTripper struct{} type fakeRoundTripper struct{}
func (*fakeRoundTripper) RoundTrip(*http.Request) (*http.Response, error) { func (*fakeRoundTripper) RoundTrip(*http.Request) (*http.Response, error) {
@ -66,10 +65,11 @@ func fakeClusterID(clusterID string) ClusterID {
} }
} }
func simpleFakeGCECloud(vals TestClusterValues) *GCECloud { // NewFakeGCECloud constructs a fake GCE Cloud from the cluster values.
func NewFakeGCECloud(vals TestClusterValues) *Cloud {
client := &http.Client{Transport: &fakeRoundTripper{}} client := &http.Client{Transport: &fakeRoundTripper{}}
service, _ := compute.New(client) service, _ := compute.New(client)
gce := &GCECloud{ gce := &Cloud{
region: vals.Region, region: vals.Region,
service: service, service: service,
managedZones: []string{vals.ZoneName}, managedZones: []string{vals.ZoneName},

16
pkg/cloudprovider/providers/gce/gce_firewall.go
View File

@ -28,38 +28,38 @@ func newFirewallMetricContext(request string) *metricContext {
} }
// GetFirewall returns the Firewall by name. // GetFirewall returns the Firewall by name.
func (gce *GCECloud) GetFirewall(name string) (*compute.Firewall, error) { func (g *Cloud) GetFirewall(name string) (*compute.Firewall, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newFirewallMetricContext("get") mc := newFirewallMetricContext("get")
v, err := gce.c.Firewalls().Get(ctx, meta.GlobalKey(name)) v, err := g.c.Firewalls().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateFirewall creates the passed firewall // CreateFirewall creates the passed firewall
func (gce *GCECloud) CreateFirewall(f *compute.Firewall) error { func (g *Cloud) CreateFirewall(f *compute.Firewall) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newFirewallMetricContext("create") mc := newFirewallMetricContext("create")
return mc.Observe(gce.c.Firewalls().Insert(ctx, meta.GlobalKey(f.Name), f)) return mc.Observe(g.c.Firewalls().Insert(ctx, meta.GlobalKey(f.Name), f))
} }
// DeleteFirewall deletes the given firewall rule. // DeleteFirewall deletes the given firewall rule.
func (gce *GCECloud) DeleteFirewall(name string) error { func (g *Cloud) DeleteFirewall(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newFirewallMetricContext("delete") mc := newFirewallMetricContext("delete")
return mc.Observe(gce.c.Firewalls().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.Firewalls().Delete(ctx, meta.GlobalKey(name)))
} }
// UpdateFirewall applies the given firewall as an update to an existing service. // UpdateFirewall applies the given firewall as an update to an existing service.
func (gce *GCECloud) UpdateFirewall(f *compute.Firewall) error { func (g *Cloud) UpdateFirewall(f *compute.Firewall) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newFirewallMetricContext("update") mc := newFirewallMetricContext("update")
return mc.Observe(gce.c.Firewalls().Update(ctx, meta.GlobalKey(f.Name), f)) return mc.Observe(g.c.Firewalls().Update(ctx, meta.GlobalKey(f.Name), f))
} }

54
pkg/cloudprovider/providers/gce/gce_forwardingrule.go
View File

@ -32,129 +32,129 @@ func newForwardingRuleMetricContextWithVersion(request, region, version string)
} }
// CreateGlobalForwardingRule creates the passed GlobalForwardingRule // CreateGlobalForwardingRule creates the passed GlobalForwardingRule
func (gce *GCECloud) CreateGlobalForwardingRule(rule *compute.ForwardingRule) error { func (g *Cloud) CreateGlobalForwardingRule(rule *compute.ForwardingRule) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("create", "") mc := newForwardingRuleMetricContext("create", "")
return mc.Observe(gce.c.GlobalForwardingRules().Insert(ctx, meta.GlobalKey(rule.Name), rule)) return mc.Observe(g.c.GlobalForwardingRules().Insert(ctx, meta.GlobalKey(rule.Name), rule))
} }
// SetProxyForGlobalForwardingRule links the given TargetHttp(s)Proxy with the given GlobalForwardingRule. // SetProxyForGlobalForwardingRule links the given TargetHttp(s)Proxy with the given GlobalForwardingRule.
// targetProxyLink is the SelfLink of a TargetHttp(s)Proxy. // targetProxyLink is the SelfLink of a TargetHttp(s)Proxy.
func (gce *GCECloud) SetProxyForGlobalForwardingRule(forwardingRuleName, targetProxyLink string) error { func (g *Cloud) SetProxyForGlobalForwardingRule(forwardingRuleName, targetProxyLink string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("set_proxy", "") mc := newForwardingRuleMetricContext("set_proxy", "")
target := &compute.TargetReference{Target: targetProxyLink} target := &compute.TargetReference{Target: targetProxyLink}
return mc.Observe(gce.c.GlobalForwardingRules().SetTarget(ctx, meta.GlobalKey(forwardingRuleName), target)) return mc.Observe(g.c.GlobalForwardingRules().SetTarget(ctx, meta.GlobalKey(forwardingRuleName), target))
} }
// DeleteGlobalForwardingRule deletes the GlobalForwardingRule by name. // DeleteGlobalForwardingRule deletes the GlobalForwardingRule by name.
func (gce *GCECloud) DeleteGlobalForwardingRule(name string) error { func (g *Cloud) DeleteGlobalForwardingRule(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("delete", "") mc := newForwardingRuleMetricContext("delete", "")
return mc.Observe(gce.c.GlobalForwardingRules().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.GlobalForwardingRules().Delete(ctx, meta.GlobalKey(name)))
} }
// GetGlobalForwardingRule returns the GlobalForwardingRule by name. // GetGlobalForwardingRule returns the GlobalForwardingRule by name.
func (gce *GCECloud) GetGlobalForwardingRule(name string) (*compute.ForwardingRule, error) { func (g *Cloud) GetGlobalForwardingRule(name string) (*compute.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("get", "") mc := newForwardingRuleMetricContext("get", "")
v, err := gce.c.GlobalForwardingRules().Get(ctx, meta.GlobalKey(name)) v, err := g.c.GlobalForwardingRules().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ListGlobalForwardingRules lists all GlobalForwardingRules in the project. // ListGlobalForwardingRules lists all GlobalForwardingRules in the project.
func (gce *GCECloud) ListGlobalForwardingRules() ([]*compute.ForwardingRule, error) { func (g *Cloud) ListGlobalForwardingRules() ([]*compute.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("list", "") mc := newForwardingRuleMetricContext("list", "")
v, err := gce.c.GlobalForwardingRules().List(ctx, filter.None) v, err := g.c.GlobalForwardingRules().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetRegionForwardingRule returns the RegionalForwardingRule by name & region. // GetRegionForwardingRule returns the RegionalForwardingRule by name & region.
func (gce *GCECloud) GetRegionForwardingRule(name, region string) (*compute.ForwardingRule, error) { func (g *Cloud) GetRegionForwardingRule(name, region string) (*compute.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("get", region) mc := newForwardingRuleMetricContext("get", region)
v, err := gce.c.ForwardingRules().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.ForwardingRules().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetAlphaRegionForwardingRule returns the Alpha forwarding rule by name & region. // GetAlphaRegionForwardingRule returns the Alpha forwarding rule by name & region.
func (gce *GCECloud) GetAlphaRegionForwardingRule(name, region string) (*computealpha.ForwardingRule, error) { func (g *Cloud) GetAlphaRegionForwardingRule(name, region string) (*computealpha.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContextWithVersion("get", region, computeAlphaVersion) mc := newForwardingRuleMetricContextWithVersion("get", region, computeAlphaVersion)
v, err := gce.c.AlphaForwardingRules().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.AlphaForwardingRules().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ListRegionForwardingRules lists all RegionalForwardingRules in the project & region. // ListRegionForwardingRules lists all RegionalForwardingRules in the project & region.
func (gce *GCECloud) ListRegionForwardingRules(region string) ([]*compute.ForwardingRule, error) { func (g *Cloud) ListRegionForwardingRules(region string) ([]*compute.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("list", region) mc := newForwardingRuleMetricContext("list", region)
v, err := gce.c.ForwardingRules().List(ctx, region, filter.None) v, err := g.c.ForwardingRules().List(ctx, region, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ListAlphaRegionForwardingRules lists all RegionalForwardingRules in the project & region. // ListAlphaRegionForwardingRules lists all RegionalForwardingRules in the project & region.
func (gce *GCECloud) ListAlphaRegionForwardingRules(region string) ([]*computealpha.ForwardingRule, error) { func (g *Cloud) ListAlphaRegionForwardingRules(region string) ([]*computealpha.ForwardingRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContextWithVersion("list", region, computeAlphaVersion) mc := newForwardingRuleMetricContextWithVersion("list", region, computeAlphaVersion)
v, err := gce.c.AlphaForwardingRules().List(ctx, region, filter.None) v, err := g.c.AlphaForwardingRules().List(ctx, region, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateRegionForwardingRule creates and returns a // CreateRegionForwardingRule creates and returns a
// RegionalForwardingRule that points to the given BackendService // RegionalForwardingRule that points to the given BackendService
func (gce *GCECloud) CreateRegionForwardingRule(rule *compute.ForwardingRule, region string) error { func (g *Cloud) CreateRegionForwardingRule(rule *compute.ForwardingRule, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("create", region) mc := newForwardingRuleMetricContext("create", region)
return mc.Observe(gce.c.ForwardingRules().Insert(ctx, meta.RegionalKey(rule.Name, region), rule)) return mc.Observe(g.c.ForwardingRules().Insert(ctx, meta.RegionalKey(rule.Name, region), rule))
} }
// CreateAlphaRegionForwardingRule creates and returns an Alpha // CreateAlphaRegionForwardingRule creates and returns an Alpha
// forwarding fule in the given region. // forwarding fule in the given region.
func (gce *GCECloud) CreateAlphaRegionForwardingRule(rule *computealpha.ForwardingRule, region string) error { func (g *Cloud) CreateAlphaRegionForwardingRule(rule *computealpha.ForwardingRule, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContextWithVersion("create", region, computeAlphaVersion) mc := newForwardingRuleMetricContextWithVersion("create", region, computeAlphaVersion)
return mc.Observe(gce.c.AlphaForwardingRules().Insert(ctx, meta.RegionalKey(rule.Name, region), rule)) return mc.Observe(g.c.AlphaForwardingRules().Insert(ctx, meta.RegionalKey(rule.Name, region), rule))
} }
// DeleteRegionForwardingRule deletes the RegionalForwardingRule by name & region. // DeleteRegionForwardingRule deletes the RegionalForwardingRule by name & region.
func (gce *GCECloud) DeleteRegionForwardingRule(name, region string) error { func (g *Cloud) DeleteRegionForwardingRule(name, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newForwardingRuleMetricContext("delete", region) mc := newForwardingRuleMetricContext("delete", region)
return mc.Observe(gce.c.ForwardingRules().Delete(ctx, meta.RegionalKey(name, region))) return mc.Observe(g.c.ForwardingRules().Delete(ctx, meta.RegionalKey(name, region)))
} }
// TODO(#51665): retire this function once Network Tiers becomes Beta in GCP. // TODO(#51665): retire this function once Network Tiers becomes Beta in GCP.
func (gce *GCECloud) getNetworkTierFromForwardingRule(name, region string) (string, error) { func (g *Cloud) getNetworkTierFromForwardingRule(name, region string) (string, error) {
if !gce.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) { if !g.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) {
return cloud.NetworkTierDefault.ToGCEValue(), nil return cloud.NetworkTierDefault.ToGCEValue(), nil
} }
fwdRule, err := gce.GetAlphaRegionForwardingRule(name, region) fwdRule, err := g.GetAlphaRegionForwardingRule(name, region)
if err != nil { if err != nil {
return handleAlphaNetworkTierGetError(err) return handleAlphaNetworkTierGetError(err)
} }

104
pkg/cloudprovider/providers/gce/gce_healthchecks.go
View File

@ -56,204 +56,204 @@ func newHealthcheckMetricContextWithVersion(request, version string) *metricCont
return newGenericMetricContext("healthcheck", request, unusedMetricLabel, unusedMetricLabel, version) return newGenericMetricContext("healthcheck", request, unusedMetricLabel, unusedMetricLabel, version)
} }
// GetHttpHealthCheck returns the given HttpHealthCheck by name. // GetHTTPHealthCheck returns the given HttpHealthCheck by name.
func (gce *GCECloud) GetHttpHealthCheck(name string) (*compute.HttpHealthCheck, error) { func (g *Cloud) GetHTTPHealthCheck(name string) (*compute.HttpHealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("get_legacy") mc := newHealthcheckMetricContext("get_legacy")
v, err := gce.c.HttpHealthChecks().Get(ctx, meta.GlobalKey(name)) v, err := g.c.HttpHealthChecks().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// UpdateHttpHealthCheck applies the given HttpHealthCheck as an update. // UpdateHTTPHealthCheck applies the given HttpHealthCheck as an update.
func (gce *GCECloud) UpdateHttpHealthCheck(hc *compute.HttpHealthCheck) error { func (g *Cloud) UpdateHTTPHealthCheck(hc *compute.HttpHealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("update_legacy") mc := newHealthcheckMetricContext("update_legacy")
return mc.Observe(gce.c.HttpHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HttpHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc))
} }
// DeleteHttpHealthCheck deletes the given HttpHealthCheck by name. // DeleteHTTPHealthCheck deletes the given HttpHealthCheck by name.
func (gce *GCECloud) DeleteHttpHealthCheck(name string) error { func (g *Cloud) DeleteHTTPHealthCheck(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("delete_legacy") mc := newHealthcheckMetricContext("delete_legacy")
return mc.Observe(gce.c.HttpHealthChecks().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.HttpHealthChecks().Delete(ctx, meta.GlobalKey(name)))
} }
// CreateHttpHealthCheck creates the given HttpHealthCheck. // CreateHTTPHealthCheck creates the given HttpHealthCheck.
func (gce *GCECloud) CreateHttpHealthCheck(hc *compute.HttpHealthCheck) error { func (g *Cloud) CreateHTTPHealthCheck(hc *compute.HttpHealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("create_legacy") mc := newHealthcheckMetricContext("create_legacy")
return mc.Observe(gce.c.HttpHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HttpHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc))
} }
// ListHttpHealthChecks lists all HttpHealthChecks in the project. // ListHTTPHealthChecks lists all HttpHealthChecks in the project.
func (gce *GCECloud) ListHttpHealthChecks() ([]*compute.HttpHealthCheck, error) { func (g *Cloud) ListHTTPHealthChecks() ([]*compute.HttpHealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("list_legacy") mc := newHealthcheckMetricContext("list_legacy")
v, err := gce.c.HttpHealthChecks().List(ctx, filter.None) v, err := g.c.HttpHealthChecks().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// Legacy HTTPS Health Checks // Legacy HTTPS Health Checks
// GetHttpsHealthCheck returns the given HttpsHealthCheck by name. // GetHTTPSHealthCheck returns the given HttpsHealthCheck by name.
func (gce *GCECloud) GetHttpsHealthCheck(name string) (*compute.HttpsHealthCheck, error) { func (g *Cloud) GetHTTPSHealthCheck(name string) (*compute.HttpsHealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("get_legacy") mc := newHealthcheckMetricContext("get_legacy")
v, err := gce.c.HttpsHealthChecks().Get(ctx, meta.GlobalKey(name)) v, err := g.c.HttpsHealthChecks().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// UpdateHttpsHealthCheck applies the given HttpsHealthCheck as an update. // UpdateHTTPSHealthCheck applies the given HttpsHealthCheck as an update.
func (gce *GCECloud) UpdateHttpsHealthCheck(hc *compute.HttpsHealthCheck) error { func (g *Cloud) UpdateHTTPSHealthCheck(hc *compute.HttpsHealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("update_legacy") mc := newHealthcheckMetricContext("update_legacy")
return mc.Observe(gce.c.HttpsHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HttpsHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc))
} }
// DeleteHttpsHealthCheck deletes the given HttpsHealthCheck by name. // DeleteHTTPSHealthCheck deletes the given HttpsHealthCheck by name.
func (gce *GCECloud) DeleteHttpsHealthCheck(name string) error { func (g *Cloud) DeleteHTTPSHealthCheck(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("delete_legacy") mc := newHealthcheckMetricContext("delete_legacy")
return mc.Observe(gce.c.HttpsHealthChecks().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.HttpsHealthChecks().Delete(ctx, meta.GlobalKey(name)))
} }
// CreateHttpsHealthCheck creates the given HttpsHealthCheck. // CreateHTTPSHealthCheck creates the given HttpsHealthCheck.
func (gce *GCECloud) CreateHttpsHealthCheck(hc *compute.HttpsHealthCheck) error { func (g *Cloud) CreateHTTPSHealthCheck(hc *compute.HttpsHealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("create_legacy") mc := newHealthcheckMetricContext("create_legacy")
return mc.Observe(gce.c.HttpsHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HttpsHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc))
} }
// ListHttpsHealthChecks lists all HttpsHealthChecks in the project. // ListHTTPSHealthChecks lists all HttpsHealthChecks in the project.
func (gce *GCECloud) ListHttpsHealthChecks() ([]*compute.HttpsHealthCheck, error) { func (g *Cloud) ListHTTPSHealthChecks() ([]*compute.HttpsHealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("list_legacy") mc := newHealthcheckMetricContext("list_legacy")
v, err := gce.c.HttpsHealthChecks().List(ctx, filter.None) v, err := g.c.HttpsHealthChecks().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// Generic HealthCheck // Generic HealthCheck
// GetHealthCheck returns the given HealthCheck by name. // GetHealthCheck returns the given HealthCheck by name.
func (gce *GCECloud) GetHealthCheck(name string) (*compute.HealthCheck, error) { func (g *Cloud) GetHealthCheck(name string) (*compute.HealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("get") mc := newHealthcheckMetricContext("get")
v, err := gce.c.HealthChecks().Get(ctx, meta.GlobalKey(name)) v, err := g.c.HealthChecks().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetAlphaHealthCheck returns the given alpha HealthCheck by name. // GetAlphaHealthCheck returns the given alpha HealthCheck by name.
func (gce *GCECloud) GetAlphaHealthCheck(name string) (*computealpha.HealthCheck, error) { func (g *Cloud) GetAlphaHealthCheck(name string) (*computealpha.HealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("get", computeAlphaVersion) mc := newHealthcheckMetricContextWithVersion("get", computeAlphaVersion)
v, err := gce.c.AlphaHealthChecks().Get(ctx, meta.GlobalKey(name)) v, err := g.c.AlphaHealthChecks().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// GetBetaHealthCheck returns the given beta HealthCheck by name. // GetBetaHealthCheck returns the given beta HealthCheck by name.
func (gce *GCECloud) GetBetaHealthCheck(name string) (*computebeta.HealthCheck, error) { func (g *Cloud) GetBetaHealthCheck(name string) (*computebeta.HealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("get", computeBetaVersion) mc := newHealthcheckMetricContextWithVersion("get", computeBetaVersion)
v, err := gce.c.BetaHealthChecks().Get(ctx, meta.GlobalKey(name)) v, err := g.c.BetaHealthChecks().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// UpdateHealthCheck applies the given HealthCheck as an update. // UpdateHealthCheck applies the given HealthCheck as an update.
func (gce *GCECloud) UpdateHealthCheck(hc *compute.HealthCheck) error { func (g *Cloud) UpdateHealthCheck(hc *compute.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("update") mc := newHealthcheckMetricContext("update")
return mc.Observe(gce.c.HealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc))
} }
// UpdateAlphaHealthCheck applies the given alpha HealthCheck as an update. // UpdateAlphaHealthCheck applies the given alpha HealthCheck as an update.
func (gce *GCECloud) UpdateAlphaHealthCheck(hc *computealpha.HealthCheck) error { func (g *Cloud) UpdateAlphaHealthCheck(hc *computealpha.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("update", computeAlphaVersion) mc := newHealthcheckMetricContextWithVersion("update", computeAlphaVersion)
return mc.Observe(gce.c.AlphaHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.AlphaHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc))
} }
// UpdateBetaHealthCheck applies the given beta HealthCheck as an update. // UpdateBetaHealthCheck applies the given beta HealthCheck as an update.
func (gce *GCECloud) UpdateBetaHealthCheck(hc *computebeta.HealthCheck) error { func (g *Cloud) UpdateBetaHealthCheck(hc *computebeta.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("update", computeBetaVersion) mc := newHealthcheckMetricContextWithVersion("update", computeBetaVersion)
return mc.Observe(gce.c.BetaHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.BetaHealthChecks().Update(ctx, meta.GlobalKey(hc.Name), hc))
} }
// DeleteHealthCheck deletes the given HealthCheck by name. // DeleteHealthCheck deletes the given HealthCheck by name.
func (gce *GCECloud) DeleteHealthCheck(name string) error { func (g *Cloud) DeleteHealthCheck(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("delete") mc := newHealthcheckMetricContext("delete")
return mc.Observe(gce.c.HealthChecks().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.HealthChecks().Delete(ctx, meta.GlobalKey(name)))
} }
// CreateHealthCheck creates the given HealthCheck. // CreateHealthCheck creates the given HealthCheck.
func (gce *GCECloud) CreateHealthCheck(hc *compute.HealthCheck) error { func (g *Cloud) CreateHealthCheck(hc *compute.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("create") mc := newHealthcheckMetricContext("create")
return mc.Observe(gce.c.HealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.HealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc))
} }
// CreateAlphaHealthCheck creates the given alpha HealthCheck. // CreateAlphaHealthCheck creates the given alpha HealthCheck.
func (gce *GCECloud) CreateAlphaHealthCheck(hc *computealpha.HealthCheck) error { func (g *Cloud) CreateAlphaHealthCheck(hc *computealpha.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("create", computeAlphaVersion) mc := newHealthcheckMetricContextWithVersion("create", computeAlphaVersion)
return mc.Observe(gce.c.AlphaHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.AlphaHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc))
} }
// CreateBetaHealthCheck creates the given beta HealthCheck. // CreateBetaHealthCheck creates the given beta HealthCheck.
func (gce *GCECloud) CreateBetaHealthCheck(hc *computebeta.HealthCheck) error { func (g *Cloud) CreateBetaHealthCheck(hc *computebeta.HealthCheck) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContextWithVersion("create", computeBetaVersion) mc := newHealthcheckMetricContextWithVersion("create", computeBetaVersion)
return mc.Observe(gce.c.BetaHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc)) return mc.Observe(g.c.BetaHealthChecks().Insert(ctx, meta.GlobalKey(hc.Name), hc))
} }
// ListHealthChecks lists all HealthCheck in the project. // ListHealthChecks lists all HealthCheck in the project.
func (gce *GCECloud) ListHealthChecks() ([]*compute.HealthCheck, error) { func (g *Cloud) ListHealthChecks() ([]*compute.HealthCheck, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newHealthcheckMetricContext("list") mc := newHealthcheckMetricContext("list")
v, err := gce.c.HealthChecks().List(ctx, filter.None) v, err := g.c.HealthChecks().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }

32
pkg/cloudprovider/providers/gce/gce_instancegroup.go
View File

@ -30,49 +30,49 @@ func newInstanceGroupMetricContext(request string, zone string) *metricContext {
// CreateInstanceGroup creates an instance group with the given // CreateInstanceGroup creates an instance group with the given
// instances. It is the callers responsibility to add named ports. // instances. It is the callers responsibility to add named ports.
func (gce *GCECloud) CreateInstanceGroup(ig *compute.InstanceGroup, zone string) error { func (g *Cloud) CreateInstanceGroup(ig *compute.InstanceGroup, zone string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("create", zone) mc := newInstanceGroupMetricContext("create", zone)
return mc.Observe(gce.c.InstanceGroups().Insert(ctx, meta.ZonalKey(ig.Name, zone), ig)) return mc.Observe(g.c.InstanceGroups().Insert(ctx, meta.ZonalKey(ig.Name, zone), ig))
} }
// DeleteInstanceGroup deletes an instance group. // DeleteInstanceGroup deletes an instance group.
func (gce *GCECloud) DeleteInstanceGroup(name string, zone string) error { func (g *Cloud) DeleteInstanceGroup(name string, zone string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("delete", zone) mc := newInstanceGroupMetricContext("delete", zone)
return mc.Observe(gce.c.InstanceGroups().Delete(ctx, meta.ZonalKey(name, zone))) return mc.Observe(g.c.InstanceGroups().Delete(ctx, meta.ZonalKey(name, zone)))
} }
// ListInstanceGroups lists all InstanceGroups in the project and // ListInstanceGroups lists all InstanceGroups in the project and
// zone. // zone.
func (gce *GCECloud) ListInstanceGroups(zone string) ([]*compute.InstanceGroup, error) { func (g *Cloud) ListInstanceGroups(zone string) ([]*compute.InstanceGroup, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("list", zone) mc := newInstanceGroupMetricContext("list", zone)
v, err := gce.c.InstanceGroups().List(ctx, zone, filter.None) v, err := g.c.InstanceGroups().List(ctx, zone, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ListInstancesInInstanceGroup lists all the instances in a given // ListInstancesInInstanceGroup lists all the instances in a given
// instance group and state. // instance group and state.
func (gce *GCECloud) ListInstancesInInstanceGroup(name string, zone string, state string) ([]*compute.InstanceWithNamedPorts, error) { func (g *Cloud) ListInstancesInInstanceGroup(name string, zone string, state string) ([]*compute.InstanceWithNamedPorts, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("list_instances", zone) mc := newInstanceGroupMetricContext("list_instances", zone)
req := &compute.InstanceGroupsListInstancesRequest{InstanceState: state} req := &compute.InstanceGroupsListInstancesRequest{InstanceState: state}
v, err := gce.c.InstanceGroups().ListInstances(ctx, meta.ZonalKey(name, zone), req, filter.None) v, err := g.c.InstanceGroups().ListInstances(ctx, meta.ZonalKey(name, zone), req, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// AddInstancesToInstanceGroup adds the given instances to the given // AddInstancesToInstanceGroup adds the given instances to the given
// instance group. // instance group.
func (gce *GCECloud) AddInstancesToInstanceGroup(name string, zone string, instanceRefs []*compute.InstanceReference) error { func (g *Cloud) AddInstancesToInstanceGroup(name string, zone string, instanceRefs []*compute.InstanceReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -84,12 +84,12 @@ func (gce *GCECloud) AddInstancesToInstanceGroup(name string, zone string, insta
req := &compute.InstanceGroupsAddInstancesRequest{ req := &compute.InstanceGroupsAddInstancesRequest{
Instances: instanceRefs, Instances: instanceRefs,
} }
return mc.Observe(gce.c.InstanceGroups().AddInstances(ctx, meta.ZonalKey(name, zone), req)) return mc.Observe(g.c.InstanceGroups().AddInstances(ctx, meta.ZonalKey(name, zone), req))
} }
// RemoveInstancesFromInstanceGroup removes the given instances from // RemoveInstancesFromInstanceGroup removes the given instances from
// the instance group. // the instance group.
func (gce *GCECloud) RemoveInstancesFromInstanceGroup(name string, zone string, instanceRefs []*compute.InstanceReference) error { func (g *Cloud) RemoveInstancesFromInstanceGroup(name string, zone string, instanceRefs []*compute.InstanceReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -101,25 +101,25 @@ func (gce *GCECloud) RemoveInstancesFromInstanceGroup(name string, zone string,
req := &compute.InstanceGroupsRemoveInstancesRequest{ req := &compute.InstanceGroupsRemoveInstancesRequest{
Instances: instanceRefs, Instances: instanceRefs,
} }
return mc.Observe(gce.c.InstanceGroups().RemoveInstances(ctx, meta.ZonalKey(name, zone), req)) return mc.Observe(g.c.InstanceGroups().RemoveInstances(ctx, meta.ZonalKey(name, zone), req))
} }
// SetNamedPortsOfInstanceGroup sets the list of named ports on a given instance group // SetNamedPortsOfInstanceGroup sets the list of named ports on a given instance group
func (gce *GCECloud) SetNamedPortsOfInstanceGroup(igName, zone string, namedPorts []*compute.NamedPort) error { func (g *Cloud) SetNamedPortsOfInstanceGroup(igName, zone string, namedPorts []*compute.NamedPort) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("set_namedports", zone) mc := newInstanceGroupMetricContext("set_namedports", zone)
req := &compute.InstanceGroupsSetNamedPortsRequest{NamedPorts: namedPorts} req := &compute.InstanceGroupsSetNamedPortsRequest{NamedPorts: namedPorts}
return mc.Observe(gce.c.InstanceGroups().SetNamedPorts(ctx, meta.ZonalKey(igName, zone), req)) return mc.Observe(g.c.InstanceGroups().SetNamedPorts(ctx, meta.ZonalKey(igName, zone), req))
} }
// GetInstanceGroup returns an instance group by name. // GetInstanceGroup returns an instance group by name.
func (gce *GCECloud) GetInstanceGroup(name string, zone string) (*compute.InstanceGroup, error) { func (g *Cloud) GetInstanceGroup(name string, zone string) (*compute.InstanceGroup, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstanceGroupMetricContext("get", zone) mc := newInstanceGroupMetricContext("get", zone)
v, err := gce.c.InstanceGroups().Get(ctx, meta.ZonalKey(name, zone)) v, err := g.c.InstanceGroups().Get(ctx, meta.ZonalKey(name, zone))
return v, mc.Observe(err) return v, mc.Observe(err)
} }

175
pkg/cloudprovider/providers/gce/gce_instances.go
View File

@ -67,22 +67,22 @@ func getZone(n *v1.Node) string {
return zone return zone
} }
func makeHostURL(projectsApiEndpoint, projectID, zone, host string) string { func makeHostURL(projectsAPIEndpoint, projectID, zone, host string) string {
host = canonicalizeInstanceName(host) host = canonicalizeInstanceName(host)
return projectsApiEndpoint + strings.Join([]string{projectID, "zones", zone, "instances", host}, "/") return projectsAPIEndpoint + strings.Join([]string{projectID, "zones", zone, "instances", host}, "/")
} }
// ToInstanceReferences returns instance references by links // ToInstanceReferences returns instance references by links
func (gce *GCECloud) ToInstanceReferences(zone string, instanceNames []string) (refs []*compute.InstanceReference) { func (g *Cloud) ToInstanceReferences(zone string, instanceNames []string) (refs []*compute.InstanceReference) {
for _, ins := range instanceNames { for _, ins := range instanceNames {
instanceLink := makeHostURL(gce.service.BasePath, gce.projectID, zone, ins) instanceLink := makeHostURL(g.service.BasePath, g.projectID, zone, ins)
refs = append(refs, &compute.InstanceReference{Instance: instanceLink}) refs = append(refs, &compute.InstanceReference{Instance: instanceLink})
} }
return refs return refs
} }
// NodeAddresses is an implementation of Instances.NodeAddresses. // NodeAddresses is an implementation of Instances.NodeAddresses.
func (gce *GCECloud) NodeAddresses(_ context.Context, _ types.NodeName) ([]v1.NodeAddress, error) { func (g *Cloud) NodeAddresses(_ context.Context, _ types.NodeName) ([]v1.NodeAddress, error) {
internalIP, err := metadata.Get("instance/network-interfaces/0/ip") internalIP, err := metadata.Get("instance/network-interfaces/0/ip")
if err != nil { if err != nil {
return nil, fmt.Errorf("couldn't get internal IP: %v", err) return nil, fmt.Errorf("couldn't get internal IP: %v", err)
@ -109,7 +109,7 @@ func (gce *GCECloud) NodeAddresses(_ context.Context, _ types.NodeName) ([]v1.No
// NodeAddressesByProviderID will not be called from the node that is requesting this ID. // NodeAddressesByProviderID will not be called from the node that is requesting this ID.
// i.e. metadata service and other local methods cannot be used here // i.e. metadata service and other local methods cannot be used here
func (gce *GCECloud) NodeAddressesByProviderID(ctx context.Context, providerID string) ([]v1.NodeAddress, error) { func (g *Cloud) NodeAddressesByProviderID(ctx context.Context, providerID string) ([]v1.NodeAddress, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -118,7 +118,7 @@ func (gce *GCECloud) NodeAddressesByProviderID(ctx context.Context, providerID s
return []v1.NodeAddress{}, err return []v1.NodeAddress{}, err
} }
instance, err := gce.c.Instances().Get(ctx, meta.ZonalKey(canonicalizeInstanceName(name), zone)) instance, err := g.c.Instances().Get(ctx, meta.ZonalKey(canonicalizeInstanceName(name), zone))
if err != nil { if err != nil {
return []v1.NodeAddress{}, fmt.Errorf("error while querying for providerID %q: %v", providerID, err) return []v1.NodeAddress{}, fmt.Errorf("error while querying for providerID %q: %v", providerID, err)
} }
@ -138,13 +138,13 @@ func (gce *GCECloud) NodeAddressesByProviderID(ctx context.Context, providerID s
// instanceByProviderID returns the cloudprovider instance of the node // instanceByProviderID returns the cloudprovider instance of the node
// with the specified unique providerID // with the specified unique providerID
func (gce *GCECloud) instanceByProviderID(providerID string) (*gceInstance, error) { func (g *Cloud) instanceByProviderID(providerID string) (*gceInstance, error) {
project, zone, name, err := splitProviderID(providerID) project, zone, name, err := splitProviderID(providerID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
instance, err := gce.getInstanceFromProjectInZoneByName(project, zone, name) instance, err := g.getInstanceFromProjectInZoneByName(project, zone, name)
if err != nil { if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) { if isHTTPErrorCode(err, http.StatusNotFound) {
return nil, cloudprovider.InstanceNotFound return nil, cloudprovider.InstanceNotFound
@ -156,7 +156,7 @@ func (gce *GCECloud) instanceByProviderID(providerID string) (*gceInstance, erro
} }
// InstanceShutdownByProviderID returns true if the instance is in safe state to detach volumes // InstanceShutdownByProviderID returns true if the instance is in safe state to detach volumes
func (gce *GCECloud) InstanceShutdownByProviderID(ctx context.Context, providerID string) (bool, error) { func (g *Cloud) InstanceShutdownByProviderID(ctx context.Context, providerID string) (bool, error) {
return false, cloudprovider.NotImplemented return false, cloudprovider.NotImplemented
} }
@ -164,8 +164,8 @@ func (gce *GCECloud) InstanceShutdownByProviderID(ctx context.Context, providerI
// with the specified unique providerID This method will not be called from the // with the specified unique providerID This method will not be called from the
// node that is requesting this ID. i.e. metadata service and other local // node that is requesting this ID. i.e. metadata service and other local
// methods cannot be used here // methods cannot be used here
func (gce *GCECloud) InstanceTypeByProviderID(ctx context.Context, providerID string) (string, error) { func (g *Cloud) InstanceTypeByProviderID(ctx context.Context, providerID string) (string, error) {
instance, err := gce.instanceByProviderID(providerID) instance, err := g.instanceByProviderID(providerID)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -175,8 +175,8 @@ func (gce *GCECloud) InstanceTypeByProviderID(ctx context.Context, providerID st
// InstanceExistsByProviderID returns true if the instance with the given provider id still exists and is running. // InstanceExistsByProviderID returns true if the instance with the given provider id still exists and is running.
// If false is returned with no error, the instance will be immediately deleted by the cloud controller manager. // If false is returned with no error, the instance will be immediately deleted by the cloud controller manager.
func (gce *GCECloud) InstanceExistsByProviderID(ctx context.Context, providerID string) (bool, error) { func (g *Cloud) InstanceExistsByProviderID(ctx context.Context, providerID string) (bool, error) {
_, err := gce.instanceByProviderID(providerID) _, err := g.instanceByProviderID(providerID)
if err != nil { if err != nil {
if err == cloudprovider.InstanceNotFound { if err == cloudprovider.InstanceNotFound {
return false, nil return false, nil
@ -188,49 +188,51 @@ func (gce *GCECloud) InstanceExistsByProviderID(ctx context.Context, providerID
} }
// InstanceID returns the cloud provider ID of the node with the specified NodeName. // InstanceID returns the cloud provider ID of the node with the specified NodeName.
func (gce *GCECloud) InstanceID(ctx context.Context, nodeName types.NodeName) (string, error) { func (g *Cloud) InstanceID(ctx context.Context, nodeName types.NodeName) (string, error) {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
if gce.useMetadataServer { if g.useMetadataServer {
// Use metadata, if possible, to fetch ID. See issue #12000 // Use metadata, if possible, to fetch ID. See issue #12000
if gce.isCurrentInstance(instanceName) { if g.isCurrentInstance(instanceName) {
projectID, zone, err := getProjectAndZone() projectID, zone, err := getProjectAndZone()
if err == nil { if err == nil {
return projectID + "/" + zone + "/" + canonicalizeInstanceName(instanceName), nil return projectID + "/" + zone + "/" + canonicalizeInstanceName(instanceName), nil
} }
} }
} }
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
return "", err return "", err
} }
return gce.projectID + "/" + instance.Zone + "/" + instance.Name, nil return g.projectID + "/" + instance.Zone + "/" + instance.Name, nil
} }
// InstanceType returns the type of the specified node with the specified NodeName. // InstanceType returns the type of the specified node with the specified NodeName.
func (gce *GCECloud) InstanceType(ctx context.Context, nodeName types.NodeName) (string, error) { func (g *Cloud) InstanceType(ctx context.Context, nodeName types.NodeName) (string, error) {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
if gce.useMetadataServer { if g.useMetadataServer {
// Use metadata, if possible, to fetch ID. See issue #12000 // Use metadata, if possible, to fetch ID. See issue #12000
if gce.isCurrentInstance(instanceName) { if g.isCurrentInstance(instanceName) {
mType, err := getCurrentMachineTypeViaMetadata() mType, err := getCurrentMachineTypeViaMetadata()
if err == nil { if err == nil {
return mType, nil return mType, nil
} }
} }
} }
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
return "", err return "", err
} }
return instance.Type, nil return instance.Type, nil
} }
func (gce *GCECloud) AddSSHKeyToAllInstances(ctx context.Context, user string, keyData []byte) error { // AddSSHKeyToAllInstances adds an SSH public key as a legal identity for all instances
// expected format for the key is standard ssh-keygen format: <protocol> <blob>
func (g *Cloud) AddSSHKeyToAllInstances(ctx context.Context, user string, keyData []byte) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
return wait.Poll(2*time.Second, 30*time.Second, func() (bool, error) { return wait.Poll(2*time.Second, 30*time.Second, func() (bool, error) {
project, err := gce.c.Projects().Get(ctx, gce.projectID) project, err := g.c.Projects().Get(ctx, g.projectID)
if err != nil { if err != nil {
glog.Errorf("Could not get project: %v", err) glog.Errorf("Could not get project: %v", err)
return false, nil return false, nil
@ -261,7 +263,7 @@ func (gce *GCECloud) AddSSHKeyToAllInstances(ctx context.Context, user string, k
} }
mc := newInstancesMetricContext("add_ssh_key", "") mc := newInstancesMetricContext("add_ssh_key", "")
err = gce.c.Projects().SetCommonInstanceMetadata(ctx, gce.projectID, project.CommonInstanceMetadata) err = g.c.Projects().SetCommonInstanceMetadata(ctx, g.projectID, project.CommonInstanceMetadata)
mc.Observe(err) mc.Observe(err)
if err != nil { if err != nil {
@ -274,18 +276,18 @@ func (gce *GCECloud) AddSSHKeyToAllInstances(ctx context.Context, user string, k
} }
// GetAllCurrentZones returns all the zones in which k8s nodes are currently running // GetAllCurrentZones returns all the zones in which k8s nodes are currently running
func (gce *GCECloud) GetAllCurrentZones() (sets.String, error) { func (g *Cloud) GetAllCurrentZones() (sets.String, error) {
if gce.nodeInformerSynced == nil { if g.nodeInformerSynced == nil {
glog.Warningf("GCECloud object does not have informers set, should only happen in E2E binary.") glog.Warningf("Cloud object does not have informers set, should only happen in E2E binary.")
return gce.GetAllZonesFromCloudProvider() return g.GetAllZonesFromCloudProvider()
} }
gce.nodeZonesLock.Lock() g.nodeZonesLock.Lock()
defer gce.nodeZonesLock.Unlock() defer g.nodeZonesLock.Unlock()
if !gce.nodeInformerSynced() { if !g.nodeInformerSynced() {
return nil, fmt.Errorf("node informer is not synced when trying to GetAllCurrentZones") return nil, fmt.Errorf("node informer is not synced when trying to GetAllCurrentZones")
} }
zones := sets.NewString() zones := sets.NewString()
for zone, nodes := range gce.nodeZones { for zone, nodes := range g.nodeZones {
if len(nodes) > 0 { if len(nodes) > 0 {
zones.Insert(zone) zones.Insert(zone)
} }
@ -300,13 +302,13 @@ func (gce *GCECloud) GetAllCurrentZones() (sets.String, error) {
// a non-k8s compute in us-central1-a. This func will return a,b, and c. // a non-k8s compute in us-central1-a. This func will return a,b, and c.
// //
// TODO: this should be removed from the cloud provider. // TODO: this should be removed from the cloud provider.
func (gce *GCECloud) GetAllZonesFromCloudProvider() (sets.String, error) { func (g *Cloud) GetAllZonesFromCloudProvider() (sets.String, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
zones := sets.NewString() zones := sets.NewString()
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
instances, err := gce.c.Instances().List(ctx, zone, filter.None) instances, err := g.c.Instances().List(ctx, zone, filter.None)
if err != nil { if err != nil {
return sets.NewString(), err return sets.NewString(), err
} }
@ -318,22 +320,22 @@ func (gce *GCECloud) GetAllZonesFromCloudProvider() (sets.String, error) {
} }
// InsertInstance creates a new instance on GCP // InsertInstance creates a new instance on GCP
func (gce *GCECloud) InsertInstance(project string, zone string, i *compute.Instance) error { func (g *Cloud) InsertInstance(project string, zone string, i *compute.Instance) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newInstancesMetricContext("create", zone) mc := newInstancesMetricContext("create", zone)
return mc.Observe(gce.c.Instances().Insert(ctx, meta.ZonalKey(i.Name, zone), i)) return mc.Observe(g.c.Instances().Insert(ctx, meta.ZonalKey(i.Name, zone), i))
} }
// ListInstanceNames returns a string of instance names separated by spaces. // ListInstanceNames returns a string of instance names separated by spaces.
// This method should only be used for e2e testing. // This method should only be used for e2e testing.
// TODO: remove this method. // TODO: remove this method.
func (gce *GCECloud) ListInstanceNames(project, zone string) (string, error) { func (g *Cloud) ListInstanceNames(project, zone string) (string, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
l, err := gce.c.Instances().List(ctx, zone, filter.None) l, err := g.c.Instances().List(ctx, zone, filter.None)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -345,33 +347,34 @@ func (gce *GCECloud) ListInstanceNames(project, zone string) (string, error) {
} }
// DeleteInstance deletes an instance specified by project, zone, and name // DeleteInstance deletes an instance specified by project, zone, and name
func (gce *GCECloud) DeleteInstance(project, zone, name string) error { func (g *Cloud) DeleteInstance(project, zone, name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
return gce.c.Instances().Delete(ctx, meta.ZonalKey(name, zone)) return g.c.Instances().Delete(ctx, meta.ZonalKey(name, zone))
} }
// Implementation of Instances.CurrentNodeName // CurrentNodeName returns the name of the node we are currently running on
func (gce *GCECloud) CurrentNodeName(ctx context.Context, hostname string) (types.NodeName, error) { // On most clouds (e.g. GCE) this is the hostname, so we provide the hostname
func (g *Cloud) CurrentNodeName(ctx context.Context, hostname string) (types.NodeName, error) {
return types.NodeName(hostname), nil return types.NodeName(hostname), nil
} }
// AliasRanges returns a list of CIDR ranges that are assigned to the // AliasRanges returns a list of CIDR ranges that are assigned to the
// `node` for allocation to pods. Returns a list of the form // `node` for allocation to pods. Returns a list of the form
// "<ip>/<netmask>". // "<ip>/<netmask>".
func (gce *GCECloud) AliasRanges(nodeName types.NodeName) (cidrs []string, err error) { func (g *Cloud) AliasRanges(nodeName types.NodeName) (cidrs []string, err error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
var instance *gceInstance var instance *gceInstance
instance, err = gce.getInstanceByName(mapNodeNameToInstanceName(nodeName)) instance, err = g.getInstanceByName(mapNodeNameToInstanceName(nodeName))
if err != nil { if err != nil {
return return
} }
var res *computebeta.Instance var res *computebeta.Instance
res, err = gce.c.BetaInstances().Get(ctx, meta.ZonalKey(instance.Name, lastComponent(instance.Zone))) res, err = g.c.BetaInstances().Get(ctx, meta.ZonalKey(instance.Name, lastComponent(instance.Zone)))
if err != nil { if err != nil {
return return
} }
@ -386,15 +389,15 @@ func (gce *GCECloud) AliasRanges(nodeName types.NodeName) (cidrs []string, err e
// AddAliasToInstance adds an alias to the given instance from the named // AddAliasToInstance adds an alias to the given instance from the named
// secondary range. // secondary range.
func (gce *GCECloud) AddAliasToInstance(nodeName types.NodeName, alias *net.IPNet) error { func (g *Cloud) AddAliasToInstance(nodeName types.NodeName, alias *net.IPNet) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
v1instance, err := gce.getInstanceByName(mapNodeNameToInstanceName(nodeName)) v1instance, err := g.getInstanceByName(mapNodeNameToInstanceName(nodeName))
if err != nil { if err != nil {
return err return err
} }
instance, err := gce.c.BetaInstances().Get(ctx, meta.ZonalKey(v1instance.Name, lastComponent(v1instance.Zone))) instance, err := g.c.BetaInstances().Get(ctx, meta.ZonalKey(v1instance.Name, lastComponent(v1instance.Zone)))
if err != nil { if err != nil {
return err return err
} }
@ -413,38 +416,38 @@ func (gce *GCECloud) AddAliasToInstance(nodeName types.NodeName, alias *net.IPNe
iface.Fingerprint = instance.NetworkInterfaces[0].Fingerprint iface.Fingerprint = instance.NetworkInterfaces[0].Fingerprint
iface.AliasIpRanges = append(iface.AliasIpRanges, &computebeta.AliasIpRange{ iface.AliasIpRanges = append(iface.AliasIpRanges, &computebeta.AliasIpRange{
IpCidrRange: alias.String(), IpCidrRange: alias.String(),
SubnetworkRangeName: gce.secondaryRangeName, SubnetworkRangeName: g.secondaryRangeName,
}) })
mc := newInstancesMetricContext("add_alias", v1instance.Zone) mc := newInstancesMetricContext("add_alias", v1instance.Zone)
err = gce.c.BetaInstances().UpdateNetworkInterface(ctx, meta.ZonalKey(instance.Name, lastComponent(instance.Zone)), iface.Name, iface) err = g.c.BetaInstances().UpdateNetworkInterface(ctx, meta.ZonalKey(instance.Name, lastComponent(instance.Zone)), iface.Name, iface)
return mc.Observe(err) return mc.Observe(err)
} }
// Gets the named instances, returning cloudprovider.InstanceNotFound if any // Gets the named instances, returning cloudprovider.InstanceNotFound if any
// instance is not found // instance is not found
func (gce *GCECloud) getInstancesByNames(names []string) ([]*gceInstance, error) { func (g *Cloud) getInstancesByNames(names []string) ([]*gceInstance, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
found := map[string]*gceInstance{} found := map[string]*gceInstance{}
remaining := len(names) remaining := len(names)
nodeInstancePrefix := gce.nodeInstancePrefix nodeInstancePrefix := g.nodeInstancePrefix
for _, name := range names { for _, name := range names {
name = canonicalizeInstanceName(name) name = canonicalizeInstanceName(name)
if !strings.HasPrefix(name, gce.nodeInstancePrefix) { if !strings.HasPrefix(name, g.nodeInstancePrefix) {
glog.Warningf("Instance %q does not conform to prefix %q, removing filter", name, gce.nodeInstancePrefix) glog.Warningf("Instance %q does not conform to prefix %q, removing filter", name, g.nodeInstancePrefix)
nodeInstancePrefix = "" nodeInstancePrefix = ""
} }
found[name] = nil found[name] = nil
} }
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
if remaining == 0 { if remaining == 0 {
break break
} }
instances, err := gce.c.Instances().List(ctx, zone, filter.Regexp("name", nodeInstancePrefix+".*")) instances, err := g.c.Instances().List(ctx, zone, filter.Regexp("name", nodeInstancePrefix+".*"))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -490,10 +493,10 @@ func (gce *GCECloud) getInstancesByNames(names []string) ([]*gceInstance, error)
} }
// Gets the named instance, returning cloudprovider.InstanceNotFound if the instance is not found // Gets the named instance, returning cloudprovider.InstanceNotFound if the instance is not found
func (gce *GCECloud) getInstanceByName(name string) (*gceInstance, error) { func (g *Cloud) getInstanceByName(name string) (*gceInstance, error) {
// Avoid changing behaviour when not managing multiple zones // Avoid changing behaviour when not managing multiple zones
for _, zone := range gce.managedZones { for _, zone := range g.managedZones {
instance, err := gce.getInstanceFromProjectInZoneByName(gce.projectID, zone, name) instance, err := g.getInstanceFromProjectInZoneByName(g.projectID, zone, name)
if err != nil { if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) { if isHTTPErrorCode(err, http.StatusNotFound) {
continue continue
@ -507,13 +510,13 @@ func (gce *GCECloud) getInstanceByName(name string) (*gceInstance, error) {
return nil, cloudprovider.InstanceNotFound return nil, cloudprovider.InstanceNotFound
} }
func (gce *GCECloud) getInstanceFromProjectInZoneByName(project, zone, name string) (*gceInstance, error) { func (g *Cloud) getInstanceFromProjectInZoneByName(project, zone, name string) (*gceInstance, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
name = canonicalizeInstanceName(name) name = canonicalizeInstanceName(name)
mc := newInstancesMetricContext("get", zone) mc := newInstancesMetricContext("get", zone)
res, err := gce.c.Instances().Get(ctx, meta.ZonalKey(name, zone)) res, err := g.c.Instances().Get(ctx, meta.ZonalKey(name, zone))
mc.Observe(err) mc.Observe(err)
if err != nil { if err != nil {
return nil, err return nil, err
@ -554,7 +557,7 @@ func getCurrentMachineTypeViaMetadata() (string, error) {
// isCurrentInstance uses metadata server to check if specified // isCurrentInstance uses metadata server to check if specified
// instanceID matches current machine's instanceID // instanceID matches current machine's instanceID
func (gce *GCECloud) isCurrentInstance(instanceID string) bool { func (g *Cloud) isCurrentInstance(instanceID string) bool {
currentInstanceID, err := getInstanceIDViaMetadata() currentInstanceID, err := getInstanceIDViaMetadata()
if err != nil { if err != nil {
// Log and swallow error // Log and swallow error
@ -571,16 +574,16 @@ func (gce *GCECloud) isCurrentInstance(instanceID string) bool {
// Invoking this method to get host tags is risky since it depends on the // Invoking this method to get host tags is risky since it depends on the
// format of the host names in the cluster. Only use it as a fallback if // format of the host names in the cluster. Only use it as a fallback if
// gce.nodeTags is unspecified // gce.nodeTags is unspecified
func (gce *GCECloud) computeHostTags(hosts []*gceInstance) ([]string, error) { func (g *Cloud) computeHostTags(hosts []*gceInstance) ([]string, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
// TODO: We could store the tags in gceInstance, so we could have already fetched it // TODO: We could store the tags in gceInstance, so we could have already fetched it
hostNamesByZone := make(map[string]map[string]bool) // map of zones -> map of names -> bool (for easy lookup) hostNamesByZone := make(map[string]map[string]bool) // map of zones -> map of names -> bool (for easy lookup)
nodeInstancePrefix := gce.nodeInstancePrefix nodeInstancePrefix := g.nodeInstancePrefix
for _, host := range hosts { for _, host := range hosts {
if !strings.HasPrefix(host.Name, gce.nodeInstancePrefix) { if !strings.HasPrefix(host.Name, g.nodeInstancePrefix) {
glog.Warningf("instance %v does not conform to prefix '%s', ignoring filter", host, gce.nodeInstancePrefix) glog.Warningf("instance %v does not conform to prefix '%s', ignoring filter", host, g.nodeInstancePrefix)
nodeInstancePrefix = "" nodeInstancePrefix = ""
} }
@ -599,7 +602,7 @@ func (gce *GCECloud) computeHostTags(hosts []*gceInstance) ([]string, error) {
filt = filter.Regexp("name", nodeInstancePrefix+".*") filt = filter.Regexp("name", nodeInstancePrefix+".*")
} }
for zone, hostNames := range hostNamesByZone { for zone, hostNames := range hostNamesByZone {
instances, err := gce.c.Instances().List(ctx, zone, filt) instances, err := g.c.Instances().List(ctx, zone, filt)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -607,14 +610,14 @@ func (gce *GCECloud) computeHostTags(hosts []*gceInstance) ([]string, error) {
if !hostNames[instance.Name] { if !hostNames[instance.Name] {
continue continue
} }
longest_tag := "" longestTag := ""
for _, tag := range instance.Tags.Items { for _, tag := range instance.Tags.Items {
if strings.HasPrefix(instance.Name, tag) && len(tag) > len(longest_tag) { if strings.HasPrefix(instance.Name, tag) && len(tag) > len(longestTag) {
longest_tag = tag longestTag = tag
} }
} }
if len(longest_tag) > 0 { if len(longestTag) > 0 {
tags.Insert(longest_tag) tags.Insert(longestTag)
} else { } else {
return nil, fmt.Errorf("could not find any tag that is a prefix of instance name for instance %s", instance.Name) return nil, fmt.Errorf("could not find any tag that is a prefix of instance name for instance %s", instance.Name)
} }
@ -629,35 +632,35 @@ func (gce *GCECloud) computeHostTags(hosts []*gceInstance) ([]string, error) {
// GetNodeTags will first try returning the list of tags specified in GCE cloud Configuration. // GetNodeTags will first try returning the list of tags specified in GCE cloud Configuration.
// If they weren't provided, it'll compute the host tags with the given hostnames. If the list // If they weren't provided, it'll compute the host tags with the given hostnames. If the list
// of hostnames has not changed, a cached set of nodetags are returned. // of hostnames has not changed, a cached set of nodetags are returned.
func (gce *GCECloud) GetNodeTags(nodeNames []string) ([]string, error) { func (g *Cloud) GetNodeTags(nodeNames []string) ([]string, error) {
// If nodeTags were specified through configuration, use them // If nodeTags were specified through configuration, use them
if len(gce.nodeTags) > 0 { if len(g.nodeTags) > 0 {
return gce.nodeTags, nil return g.nodeTags, nil
} }
gce.computeNodeTagLock.Lock() g.computeNodeTagLock.Lock()
defer gce.computeNodeTagLock.Unlock() defer g.computeNodeTagLock.Unlock()
// Early return if hosts have not changed // Early return if hosts have not changed
hosts := sets.NewString(nodeNames...) hosts := sets.NewString(nodeNames...)
if hosts.Equal(gce.lastKnownNodeNames) { if hosts.Equal(g.lastKnownNodeNames) {
return gce.lastComputedNodeTags, nil return g.lastComputedNodeTags, nil
} }
// Get GCE instance data by hostname // Get GCE instance data by hostname
instances, err := gce.getInstancesByNames(nodeNames) instances, err := g.getInstancesByNames(nodeNames)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Determine list of host tags // Determine list of host tags
tags, err := gce.computeHostTags(instances) tags, err := g.computeHostTags(instances)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Save the list of tags // Save the list of tags
gce.lastKnownNodeNames = hosts g.lastKnownNodeNames = hosts
gce.lastComputedNodeTags = tags g.lastComputedNodeTags = tags
return tags, nil return tags, nil
} }

60
pkg/cloudprovider/providers/gce/gce_loadbalancer.go
View File

@ -87,9 +87,9 @@ func LoadBalancerSrcRanges() []string {
} }
// GetLoadBalancer is an implementation of LoadBalancer.GetLoadBalancer // GetLoadBalancer is an implementation of LoadBalancer.GetLoadBalancer
func (gce *GCECloud) GetLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service) (*v1.LoadBalancerStatus, bool, error) { func (g *Cloud) GetLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service) (*v1.LoadBalancerStatus, bool, error) {
loadBalancerName := gce.GetLoadBalancerName(ctx, clusterName, svc) loadBalancerName := g.GetLoadBalancerName(ctx, clusterName, svc)
fwd, err := gce.GetRegionForwardingRule(loadBalancerName, gce.region) fwd, err := g.GetRegionForwardingRule(loadBalancerName, g.region)
if err == nil { if err == nil {
status := &v1.LoadBalancerStatus{} status := &v1.LoadBalancerStatus{}
status.Ingress = []v1.LoadBalancerIngress{{IP: fwd.IPAddress}} status.Ingress = []v1.LoadBalancerIngress{{IP: fwd.IPAddress}}
@ -100,23 +100,23 @@ func (gce *GCECloud) GetLoadBalancer(ctx context.Context, clusterName string, sv
} }
// GetLoadBalancerName is an implementation of LoadBalancer.GetLoadBalancerName. // GetLoadBalancerName is an implementation of LoadBalancer.GetLoadBalancerName.
func (gce *GCECloud) GetLoadBalancerName(ctx context.Context, clusterName string, svc *v1.Service) string { func (g *Cloud) GetLoadBalancerName(ctx context.Context, clusterName string, svc *v1.Service) string {
// TODO: replace DefaultLoadBalancerName to generate more meaningful loadbalancer names. // TODO: replace DefaultLoadBalancerName to generate more meaningful loadbalancer names.
return cloudprovider.DefaultLoadBalancerName(svc) return cloudprovider.DefaultLoadBalancerName(svc)
} }
// EnsureLoadBalancer is an implementation of LoadBalancer.EnsureLoadBalancer. // EnsureLoadBalancer is an implementation of LoadBalancer.EnsureLoadBalancer.
func (gce *GCECloud) EnsureLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) { func (g *Cloud) EnsureLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) {
loadBalancerName := gce.GetLoadBalancerName(ctx, clusterName, svc) loadBalancerName := g.GetLoadBalancerName(ctx, clusterName, svc)
desiredScheme := getSvcScheme(svc) desiredScheme := getSvcScheme(svc)
clusterID, err := gce.ClusterID.GetID() clusterID, err := g.ClusterID.GetID()
if err != nil { if err != nil {
return nil, err return nil, err
} }
glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): ensure %v loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, desiredScheme) glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): ensure %v loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, desiredScheme)
existingFwdRule, err := gce.GetRegionForwardingRule(loadBalancerName, gce.region) existingFwdRule, err := g.GetRegionForwardingRule(loadBalancerName, g.region)
if err != nil && !isNotFound(err) { if err != nil && !isNotFound(err) {
return nil, err return nil, err
} }
@ -126,14 +126,14 @@ func (gce *GCECloud) EnsureLoadBalancer(ctx context.Context, clusterName string,
// If the loadbalancer type changes between INTERNAL and EXTERNAL, the old load balancer should be deleted. // If the loadbalancer type changes between INTERNAL and EXTERNAL, the old load balancer should be deleted.
if existingScheme != desiredScheme { if existingScheme != desiredScheme {
glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): deleting existing %v loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, existingScheme) glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): deleting existing %v loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, existingScheme)
switch existingScheme { switch existingScheme {
case cloud.SchemeInternal: case cloud.SchemeInternal:
err = gce.ensureInternalLoadBalancerDeleted(clusterName, clusterID, svc) err = g.ensureInternalLoadBalancerDeleted(clusterName, clusterID, svc)
default: default:
err = gce.ensureExternalLoadBalancerDeleted(clusterName, clusterID, svc) err = g.ensureExternalLoadBalancerDeleted(clusterName, clusterID, svc)
} }
glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): done deleting existing %v loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, existingScheme, err) glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): done deleting existing %v loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, existingScheme, err)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -146,53 +146,53 @@ func (gce *GCECloud) EnsureLoadBalancer(ctx context.Context, clusterName string,
var status *v1.LoadBalancerStatus var status *v1.LoadBalancerStatus
switch desiredScheme { switch desiredScheme {
case cloud.SchemeInternal: case cloud.SchemeInternal:
status, err = gce.ensureInternalLoadBalancer(clusterName, clusterID, svc, existingFwdRule, nodes) status, err = g.ensureInternalLoadBalancer(clusterName, clusterID, svc, existingFwdRule, nodes)
default: default:
status, err = gce.ensureExternalLoadBalancer(clusterName, clusterID, svc, existingFwdRule, nodes) status, err = g.ensureExternalLoadBalancer(clusterName, clusterID, svc, existingFwdRule, nodes)
} }
glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): done ensuring loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, err) glog.V(4).Infof("EnsureLoadBalancer(%v, %v, %v, %v, %v): done ensuring loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, err)
return status, err return status, err
} }
// UpdateLoadBalancer is an implementation of LoadBalancer.UpdateLoadBalancer. // UpdateLoadBalancer is an implementation of LoadBalancer.UpdateLoadBalancer.
func (gce *GCECloud) UpdateLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service, nodes []*v1.Node) error { func (g *Cloud) UpdateLoadBalancer(ctx context.Context, clusterName string, svc *v1.Service, nodes []*v1.Node) error {
loadBalancerName := gce.GetLoadBalancerName(ctx, clusterName, svc) loadBalancerName := g.GetLoadBalancerName(ctx, clusterName, svc)
scheme := getSvcScheme(svc) scheme := getSvcScheme(svc)
clusterID, err := gce.ClusterID.GetID() clusterID, err := g.ClusterID.GetID()
if err != nil { if err != nil {
return err return err
} }
glog.V(4).Infof("UpdateLoadBalancer(%v, %v, %v, %v, %v): updating with %d nodes", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, len(nodes)) glog.V(4).Infof("UpdateLoadBalancer(%v, %v, %v, %v, %v): updating with %d nodes", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, len(nodes))
switch scheme { switch scheme {
case cloud.SchemeInternal: case cloud.SchemeInternal:
err = gce.updateInternalLoadBalancer(clusterName, clusterID, svc, nodes) err = g.updateInternalLoadBalancer(clusterName, clusterID, svc, nodes)
default: default:
err = gce.updateExternalLoadBalancer(clusterName, svc, nodes) err = g.updateExternalLoadBalancer(clusterName, svc, nodes)
} }
glog.V(4).Infof("UpdateLoadBalancer(%v, %v, %v, %v, %v): done updating. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, err) glog.V(4).Infof("UpdateLoadBalancer(%v, %v, %v, %v, %v): done updating. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, err)
return err return err
} }
// EnsureLoadBalancerDeleted is an implementation of LoadBalancer.EnsureLoadBalancerDeleted. // EnsureLoadBalancerDeleted is an implementation of LoadBalancer.EnsureLoadBalancerDeleted.
func (gce *GCECloud) EnsureLoadBalancerDeleted(ctx context.Context, clusterName string, svc *v1.Service) error { func (g *Cloud) EnsureLoadBalancerDeleted(ctx context.Context, clusterName string, svc *v1.Service) error {
loadBalancerName := gce.GetLoadBalancerName(ctx, clusterName, svc) loadBalancerName := g.GetLoadBalancerName(ctx, clusterName, svc)
scheme := getSvcScheme(svc) scheme := getSvcScheme(svc)
clusterID, err := gce.ClusterID.GetID() clusterID, err := g.ClusterID.GetID()
if err != nil { if err != nil {
return err return err
} }
glog.V(4).Infof("EnsureLoadBalancerDeleted(%v, %v, %v, %v, %v): deleting loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region) glog.V(4).Infof("EnsureLoadBalancerDeleted(%v, %v, %v, %v, %v): deleting loadbalancer", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region)
switch scheme { switch scheme {
case cloud.SchemeInternal: case cloud.SchemeInternal:
err = gce.ensureInternalLoadBalancerDeleted(clusterName, clusterID, svc) err = g.ensureInternalLoadBalancerDeleted(clusterName, clusterID, svc)
default: default:
err = gce.ensureExternalLoadBalancerDeleted(clusterName, clusterID, svc) err = g.ensureExternalLoadBalancerDeleted(clusterName, clusterID, svc)
} }
glog.V(4).Infof("EnsureLoadBalancerDeleted(%v, %v, %v, %v, %v): done deleting loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, gce.region, err) glog.V(4).Infof("EnsureLoadBalancerDeleted(%v, %v, %v, %v, %v): done deleting loadbalancer. err: %v", clusterName, svc.Namespace, svc.Name, loadBalancerName, g.region, err)
return err return err
} }

223
pkg/cloudprovider/providers/gce/gce_loadbalancer_external.go
View File

@ -44,19 +44,19 @@ import (
// Due to an interesting series of design decisions, this handles both creating // Due to an interesting series of design decisions, this handles both creating
// new load balancers and updating existing load balancers, recognizing when // new load balancers and updating existing load balancers, recognizing when
// each is needed. // each is needed.
func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID string, apiService *v1.Service, existingFwdRule *compute.ForwardingRule, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) { func (g *Cloud) ensureExternalLoadBalancer(clusterName string, clusterID string, apiService *v1.Service, existingFwdRule *compute.ForwardingRule, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) {
if len(nodes) == 0 { if len(nodes) == 0 {
return nil, fmt.Errorf("Cannot EnsureLoadBalancer() with no hosts") return nil, fmt.Errorf("Cannot EnsureLoadBalancer() with no hosts")
} }
hostNames := nodeNames(nodes) hostNames := nodeNames(nodes)
supportsNodesHealthCheck := supportsNodesHealthCheck(nodes) supportsNodesHealthCheck := supportsNodesHealthCheck(nodes)
hosts, err := gce.getInstancesByNames(hostNames) hosts, err := g.getInstancesByNames(hostNames)
if err != nil { if err != nil {
return nil, err return nil, err
} }
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, apiService) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, apiService)
requestedIP := apiService.Spec.LoadBalancerIP requestedIP := apiService.Spec.LoadBalancerIP
ports := apiService.Spec.Ports ports := apiService.Spec.Ports
portStr := []string{} portStr := []string{}
@ -66,22 +66,22 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
serviceName := types.NamespacedName{Namespace: apiService.Namespace, Name: apiService.Name} serviceName := types.NamespacedName{Namespace: apiService.Namespace, Name: apiService.Name}
lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName) lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName)
glog.V(2).Infof("ensureExternalLoadBalancer(%s, %v, %v, %v, %v, %v)", lbRefStr, gce.region, requestedIP, portStr, hostNames, apiService.Annotations) glog.V(2).Infof("ensureExternalLoadBalancer(%s, %v, %v, %v, %v, %v)", lbRefStr, g.region, requestedIP, portStr, hostNames, apiService.Annotations)
// Check the current and the desired network tiers. If they do not match, // Check the current and the desired network tiers. If they do not match,
// tear down the existing resources with the wrong tier. // tear down the existing resources with the wrong tier.
netTier, err := gce.getServiceNetworkTier(apiService) netTier, err := g.getServiceNetworkTier(apiService)
if err != nil { if err != nil {
glog.Errorf("ensureExternalLoadBalancer(%s): Failed to get the desired network tier: %v.", lbRefStr, err) glog.Errorf("ensureExternalLoadBalancer(%s): Failed to get the desired network tier: %v.", lbRefStr, err)
return nil, err return nil, err
} }
glog.V(4).Infof("ensureExternalLoadBalancer(%s): Desired network tier %q.", lbRefStr, netTier) glog.V(4).Infof("ensureExternalLoadBalancer(%s): Desired network tier %q.", lbRefStr, netTier)
if gce.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) { if g.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) {
gce.deleteWrongNetworkTieredResources(loadBalancerName, lbRefStr, netTier) g.deleteWrongNetworkTieredResources(loadBalancerName, lbRefStr, netTier)
} }
// Check if the forwarding rule exists, and if so, what its IP is. // Check if the forwarding rule exists, and if so, what its IP is.
fwdRuleExists, fwdRuleNeedsUpdate, fwdRuleIP, err := gce.forwardingRuleNeedsUpdate(loadBalancerName, gce.region, requestedIP, ports) fwdRuleExists, fwdRuleNeedsUpdate, fwdRuleIP, err := g.forwardingRuleNeedsUpdate(loadBalancerName, g.region, requestedIP, ports)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -120,22 +120,22 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
return return
} }
if isSafeToReleaseIP { if isSafeToReleaseIP {
if err := gce.DeleteRegionAddress(loadBalancerName, gce.region); err != nil && !isNotFound(err) { if err := g.DeleteRegionAddress(loadBalancerName, g.region); err != nil && !isNotFound(err) {
glog.Errorf("ensureExternalLoadBalancer(%s): Failed to release static IP %s in region %v: %v.", lbRefStr, ipAddressToUse, gce.region, err) glog.Errorf("ensureExternalLoadBalancer(%s): Failed to release static IP %s in region %v: %v.", lbRefStr, ipAddressToUse, g.region, err)
} else if isNotFound(err) { } else if isNotFound(err) {
glog.V(2).Infof("ensureExternalLoadBalancer(%s): IP address %s is not reserved.", lbRefStr, ipAddressToUse) glog.V(2).Infof("ensureExternalLoadBalancer(%s): IP address %s is not reserved.", lbRefStr, ipAddressToUse)
} else { } else {
glog.Infof("ensureExternalLoadBalancer(%s): Released static IP %s.", lbRefStr, ipAddressToUse) glog.Infof("ensureExternalLoadBalancer(%s): Released static IP %s.", lbRefStr, ipAddressToUse)
} }
} else { } else {
glog.Warningf("ensureExternalLoadBalancer(%s): Orphaning static IP %s in region %v: %v.", lbRefStr, ipAddressToUse, gce.region, err) glog.Warningf("ensureExternalLoadBalancer(%s): Orphaning static IP %s in region %v: %v.", lbRefStr, ipAddressToUse, g.region, err)
} }
}() }()
if requestedIP != "" { if requestedIP != "" {
// If user requests a specific IP address, verify first. No mutation to // If user requests a specific IP address, verify first. No mutation to
// the GCE resources will be performed in the verification process. // the GCE resources will be performed in the verification process.
isUserOwnedIP, err = verifyUserRequestedIP(gce, gce.region, requestedIP, fwdRuleIP, lbRefStr, netTier) isUserOwnedIP, err = verifyUserRequestedIP(g, g.region, requestedIP, fwdRuleIP, lbRefStr, netTier)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -145,7 +145,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
if !isUserOwnedIP { if !isUserOwnedIP {
// If we are not using the user-owned IP, either promote the // If we are not using the user-owned IP, either promote the
// emphemeral IP used by the fwd rule, or create a new static IP. // emphemeral IP used by the fwd rule, or create a new static IP.
ipAddr, existed, err := ensureStaticIP(gce, loadBalancerName, serviceName.String(), gce.region, fwdRuleIP, netTier) ipAddr, existed, err := ensureStaticIP(g, loadBalancerName, serviceName.String(), g.region, fwdRuleIP, netTier)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to ensure a static IP for load balancer (%s): %v", lbRefStr, err) return nil, fmt.Errorf("failed to ensure a static IP for load balancer (%s): %v", lbRefStr, err)
} }
@ -167,7 +167,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
return nil, err return nil, err
} }
firewallExists, firewallNeedsUpdate, err := gce.firewallNeedsUpdate(loadBalancerName, serviceName.String(), gce.region, ipAddressToUse, ports, sourceRanges) firewallExists, firewallNeedsUpdate, err := g.firewallNeedsUpdate(loadBalancerName, serviceName.String(), g.region, ipAddressToUse, ports, sourceRanges)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -178,20 +178,20 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
// without needing to be deleted and recreated. // without needing to be deleted and recreated.
if firewallExists { if firewallExists {
glog.Infof("ensureExternalLoadBalancer(%s): Updating firewall.", lbRefStr) glog.Infof("ensureExternalLoadBalancer(%s): Updating firewall.", lbRefStr)
if err := gce.updateFirewall(apiService, MakeFirewallName(loadBalancerName), gce.region, desc, sourceRanges, ports, hosts); err != nil { if err := g.updateFirewall(apiService, MakeFirewallName(loadBalancerName), g.region, desc, sourceRanges, ports, hosts); err != nil {
return nil, err return nil, err
} }
glog.Infof("ensureExternalLoadBalancer(%s): Updated firewall.", lbRefStr) glog.Infof("ensureExternalLoadBalancer(%s): Updated firewall.", lbRefStr)
} else { } else {
glog.Infof("ensureExternalLoadBalancer(%s): Creating firewall.", lbRefStr) glog.Infof("ensureExternalLoadBalancer(%s): Creating firewall.", lbRefStr)
if err := gce.createFirewall(apiService, MakeFirewallName(loadBalancerName), gce.region, desc, sourceRanges, ports, hosts); err != nil { if err := g.createFirewall(apiService, MakeFirewallName(loadBalancerName), g.region, desc, sourceRanges, ports, hosts); err != nil {
return nil, err return nil, err
} }
glog.Infof("ensureExternalLoadBalancer(%s): Created firewall.", lbRefStr) glog.Infof("ensureExternalLoadBalancer(%s): Created firewall.", lbRefStr)
} }
} }
tpExists, tpNeedsRecreation, err := gce.targetPoolNeedsRecreation(loadBalancerName, gce.region, apiService.Spec.SessionAffinity) tpExists, tpNeedsRecreation, err := g.targetPoolNeedsRecreation(loadBalancerName, g.region, apiService.Spec.SessionAffinity)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -202,7 +202,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
// Check which health check needs to create and which health check needs to delete. // Check which health check needs to create and which health check needs to delete.
// Health check management is coupled with target pool operation to prevent leaking. // Health check management is coupled with target pool operation to prevent leaking.
var hcToCreate, hcToDelete *compute.HttpHealthCheck var hcToCreate, hcToDelete *compute.HttpHealthCheck
hcLocalTrafficExisting, err := gce.GetHttpHealthCheck(loadBalancerName) hcLocalTrafficExisting, err := g.GetHTTPHealthCheck(loadBalancerName)
if err != nil && !isHTTPErrorCode(err, http.StatusNotFound) { if err != nil && !isHTTPErrorCode(err, http.StatusNotFound) {
return nil, fmt.Errorf("error checking HTTP health check for load balancer (%s): %v", lbRefStr, err) return nil, fmt.Errorf("error checking HTTP health check for load balancer (%s): %v", lbRefStr, err)
} }
@ -214,11 +214,11 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
// target pool to use local traffic health check. // target pool to use local traffic health check.
glog.V(2).Infof("ensureExternalLoadBalancer(%s): Updating from nodes health checks to local traffic health checks.", lbRefStr) glog.V(2).Infof("ensureExternalLoadBalancer(%s): Updating from nodes health checks to local traffic health checks.", lbRefStr)
if supportsNodesHealthCheck { if supportsNodesHealthCheck {
hcToDelete = makeHttpHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort()) hcToDelete = makeHTTPHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort())
} }
tpNeedsRecreation = true tpNeedsRecreation = true
} }
hcToCreate = makeHttpHealthCheck(loadBalancerName, path, healthCheckNodePort) hcToCreate = makeHTTPHealthCheck(loadBalancerName, path, healthCheckNodePort)
} else { } else {
glog.V(4).Infof("ensureExternalLoadBalancer(%s): Service needs nodes health checks.", lbRefStr) glog.V(4).Infof("ensureExternalLoadBalancer(%s): Service needs nodes health checks.", lbRefStr)
if hcLocalTrafficExisting != nil { if hcLocalTrafficExisting != nil {
@ -230,7 +230,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
tpNeedsRecreation = true tpNeedsRecreation = true
} }
if supportsNodesHealthCheck { if supportsNodesHealthCheck {
hcToCreate = makeHttpHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort()) hcToCreate = makeHTTPHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort())
} }
} }
// Now we get to some slightly more interesting logic. // Now we get to some slightly more interesting logic.
@ -245,19 +245,19 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
// and something should fail before we recreate it, don't release the // and something should fail before we recreate it, don't release the
// IP. That way we can come back to it later. // IP. That way we can come back to it later.
isSafeToReleaseIP = false isSafeToReleaseIP = false
if err := gce.DeleteRegionForwardingRule(loadBalancerName, gce.region); err != nil && !isNotFound(err) { if err := g.DeleteRegionForwardingRule(loadBalancerName, g.region); err != nil && !isNotFound(err) {
return nil, fmt.Errorf("failed to delete existing forwarding rule for load balancer (%s) update: %v", lbRefStr, err) return nil, fmt.Errorf("failed to delete existing forwarding rule for load balancer (%s) update: %v", lbRefStr, err)
} }
glog.Infof("ensureExternalLoadBalancer(%s): Deleted forwarding rule.", lbRefStr) glog.Infof("ensureExternalLoadBalancer(%s): Deleted forwarding rule.", lbRefStr)
} }
if err := gce.ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation, apiService, loadBalancerName, clusterID, ipAddressToUse, hosts, hcToCreate, hcToDelete); err != nil { if err := g.ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation, apiService, loadBalancerName, clusterID, ipAddressToUse, hosts, hcToCreate, hcToDelete); err != nil {
return nil, err return nil, err
} }
if tpNeedsRecreation || fwdRuleNeedsUpdate { if tpNeedsRecreation || fwdRuleNeedsUpdate {
glog.Infof("ensureExternalLoadBalancer(%s): Creating forwarding rule, IP %s (tier: %s).", lbRefStr, ipAddressToUse, netTier) glog.Infof("ensureExternalLoadBalancer(%s): Creating forwarding rule, IP %s (tier: %s).", lbRefStr, ipAddressToUse, netTier)
if err := createForwardingRule(gce, loadBalancerName, serviceName.String(), gce.region, ipAddressToUse, gce.targetPoolURL(loadBalancerName), ports, netTier); err != nil { if err := createForwardingRule(g, loadBalancerName, serviceName.String(), g.region, ipAddressToUse, g.targetPoolURL(loadBalancerName), ports, netTier); err != nil {
return nil, fmt.Errorf("failed to create forwarding rule for load balancer (%s): %v", lbRefStr, err) return nil, fmt.Errorf("failed to create forwarding rule for load balancer (%s): %v", lbRefStr, err)
} }
// End critical section. It is safe to release the static IP (which // End critical section. It is safe to release the static IP (which
@ -275,25 +275,25 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName string, clusterID st
} }
// updateExternalLoadBalancer is the external implementation of LoadBalancer.UpdateLoadBalancer. // updateExternalLoadBalancer is the external implementation of LoadBalancer.UpdateLoadBalancer.
func (gce *GCECloud) updateExternalLoadBalancer(clusterName string, service *v1.Service, nodes []*v1.Node) error { func (g *Cloud) updateExternalLoadBalancer(clusterName string, service *v1.Service, nodes []*v1.Node) error {
hosts, err := gce.getInstancesByNames(nodeNames(nodes)) hosts, err := g.getInstancesByNames(nodeNames(nodes))
if err != nil { if err != nil {
return err return err
} }
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, service) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, service)
return gce.updateTargetPool(loadBalancerName, hosts) return g.updateTargetPool(loadBalancerName, hosts)
} }
// ensureExternalLoadBalancerDeleted is the external implementation of LoadBalancer.EnsureLoadBalancerDeleted // ensureExternalLoadBalancerDeleted is the external implementation of LoadBalancer.EnsureLoadBalancerDeleted
func (gce *GCECloud) ensureExternalLoadBalancerDeleted(clusterName, clusterID string, service *v1.Service) error { func (g *Cloud) ensureExternalLoadBalancerDeleted(clusterName, clusterID string, service *v1.Service) error {
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, service) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, service)
serviceName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} serviceName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name}
lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName) lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName)
var hcNames []string var hcNames []string
if path, _ := apiservice.GetServiceHealthCheckPathPort(service); path != "" { if path, _ := apiservice.GetServiceHealthCheckPathPort(service); path != "" {
hcToDelete, err := gce.GetHttpHealthCheck(loadBalancerName) hcToDelete, err := g.GetHTTPHealthCheck(loadBalancerName)
if err != nil && !isHTTPErrorCode(err, http.StatusNotFound) { if err != nil && !isHTTPErrorCode(err, http.StatusNotFound) {
glog.Infof("ensureExternalLoadBalancerDeleted(%s): Failed to retrieve health check:%v.", lbRefStr, err) glog.Infof("ensureExternalLoadBalancerDeleted(%s): Failed to retrieve health check:%v.", lbRefStr, err)
return err return err
@ -315,10 +315,10 @@ func (gce *GCECloud) ensureExternalLoadBalancerDeleted(clusterName, clusterID st
func() error { func() error {
glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting firewall rule.", lbRefStr) glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting firewall rule.", lbRefStr)
fwName := MakeFirewallName(loadBalancerName) fwName := MakeFirewallName(loadBalancerName)
err := ignoreNotFound(gce.DeleteFirewall(fwName)) err := ignoreNotFound(g.DeleteFirewall(fwName))
if isForbidden(err) && gce.OnXPN() { if isForbidden(err) && g.OnXPN() {
glog.V(4).Infof("ensureExternalLoadBalancerDeleted(%s): Do not have permission to delete firewall rule %v (on XPN). Raising event.", lbRefStr, fwName) glog.V(4).Infof("ensureExternalLoadBalancerDeleted(%s): Do not have permission to delete firewall rule %v (on XPN). Raising event.", lbRefStr, fwName)
gce.raiseFirewallChangeNeededEvent(service, FirewallToGCloudDeleteCmd(fwName, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(service, FirewallToGCloudDeleteCmd(fwName, g.NetworkProjectID()))
return nil return nil
} }
return err return err
@ -328,17 +328,17 @@ func (gce *GCECloud) ensureExternalLoadBalancerDeleted(clusterName, clusterID st
// creation/update attempt, so make sure we clean it up here just in case. // creation/update attempt, so make sure we clean it up here just in case.
func() error { func() error {
glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting IP address.", lbRefStr) glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting IP address.", lbRefStr)
return ignoreNotFound(gce.DeleteRegionAddress(loadBalancerName, gce.region)) return ignoreNotFound(g.DeleteRegionAddress(loadBalancerName, g.region))
}, },
func() error { func() error {
glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting forwarding rule.", lbRefStr) glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting forwarding rule.", lbRefStr)
// The forwarding rule must be deleted before either the target pool can, // The forwarding rule must be deleted before either the target pool can,
// unfortunately, so we have to do these two serially. // unfortunately, so we have to do these two serially.
if err := ignoreNotFound(gce.DeleteRegionForwardingRule(loadBalancerName, gce.region)); err != nil { if err := ignoreNotFound(g.DeleteRegionForwardingRule(loadBalancerName, g.region)); err != nil {
return err return err
} }
glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting target pool.", lbRefStr) glog.Infof("ensureExternalLoadBalancerDeleted(%s): Deleting target pool.", lbRefStr)
if err := gce.DeleteExternalTargetPoolAndChecks(service, loadBalancerName, gce.region, clusterID, hcNames...); err != nil { if err := g.DeleteExternalTargetPoolAndChecks(service, loadBalancerName, g.region, clusterID, hcNames...); err != nil {
return err return err
} }
return nil return nil
@ -350,11 +350,12 @@ func (gce *GCECloud) ensureExternalLoadBalancerDeleted(clusterName, clusterID st
return nil return nil
} }
func (gce *GCECloud) DeleteExternalTargetPoolAndChecks(service *v1.Service, name, region, clusterID string, hcNames ...string) error { // DeleteExternalTargetPoolAndChecks Deletes an external load balancer pool and verifies the operation
func (g *Cloud) DeleteExternalTargetPoolAndChecks(service *v1.Service, name, region, clusterID string, hcNames ...string) error {
serviceName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} serviceName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name}
lbRefStr := fmt.Sprintf("%v(%v)", name, serviceName) lbRefStr := fmt.Sprintf("%v(%v)", name, serviceName)
if err := gce.DeleteTargetPool(name, region); err != nil && isHTTPErrorCode(err, http.StatusNotFound) { if err := g.DeleteTargetPool(name, region); err != nil && isHTTPErrorCode(err, http.StatusNotFound) {
glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Target pool already deleted. Continuing to delete other resources.", lbRefStr) glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Target pool already deleted. Continuing to delete other resources.", lbRefStr)
} else if err != nil { } else if err != nil {
glog.Warningf("DeleteExternalTargetPoolAndChecks(%v): Failed to delete target pool, got error %s.", lbRefStr, err.Error()) glog.Warningf("DeleteExternalTargetPoolAndChecks(%v): Failed to delete target pool, got error %s.", lbRefStr, err.Error())
@ -369,11 +370,11 @@ func (gce *GCECloud) DeleteExternalTargetPoolAndChecks(service *v1.Service, name
if isNodesHealthCheck { if isNodesHealthCheck {
// Lock to prevent deleting necessary nodes health check before it gets attached // Lock to prevent deleting necessary nodes health check before it gets attached
// to target pool. // to target pool.
gce.sharedResourceLock.Lock() g.sharedResourceLock.Lock()
defer gce.sharedResourceLock.Unlock() defer g.sharedResourceLock.Unlock()
} }
glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Deleting health check %v.", lbRefStr, hcName) glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Deleting health check %v.", lbRefStr, hcName)
if err := gce.DeleteHttpHealthCheck(hcName); err != nil { if err := g.DeleteHTTPHealthCheck(hcName); err != nil {
// Delete nodes health checks will fail if any other target pool is using it. // Delete nodes health checks will fail if any other target pool is using it.
if isInUsedByError(err) { if isInUsedByError(err) {
glog.V(4).Infof("DeleteExternalTargetPoolAndChecks(%v): Health check %v is in used: %v.", lbRefStr, hcName, err) glog.V(4).Infof("DeleteExternalTargetPoolAndChecks(%v): Health check %v is in used: %v.", lbRefStr, hcName, err)
@ -395,10 +396,10 @@ func (gce *GCECloud) DeleteExternalTargetPoolAndChecks(service *v1.Service, name
// So we should delete the health check firewall as well. // So we should delete the health check firewall as well.
fwName := MakeHealthCheckFirewallName(clusterID, hcName, isNodesHealthCheck) fwName := MakeHealthCheckFirewallName(clusterID, hcName, isNodesHealthCheck)
glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Deleting health check firewall %v.", lbRefStr, fwName) glog.Infof("DeleteExternalTargetPoolAndChecks(%v): Deleting health check firewall %v.", lbRefStr, fwName)
if err := ignoreNotFound(gce.DeleteFirewall(fwName)); err != nil { if err := ignoreNotFound(g.DeleteFirewall(fwName)); err != nil {
if isForbidden(err) && gce.OnXPN() { if isForbidden(err) && g.OnXPN() {
glog.V(4).Infof("DeleteExternalTargetPoolAndChecks(%v): Do not have permission to delete firewall rule %v (on XPN). Raising event.", lbRefStr, fwName) glog.V(4).Infof("DeleteExternalTargetPoolAndChecks(%v): Do not have permission to delete firewall rule %v (on XPN). Raising event.", lbRefStr, fwName)
gce.raiseFirewallChangeNeededEvent(service, FirewallToGCloudDeleteCmd(fwName, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(service, FirewallToGCloudDeleteCmd(fwName, g.NetworkProjectID()))
return nil return nil
} }
return err return err
@ -462,7 +463,7 @@ func verifyUserRequestedIP(s CloudAddressService, region, requestedIP, fwdRuleIP
return false, fmt.Errorf("requested ip %q is neither static nor assigned to the LB", requestedIP) return false, fmt.Errorf("requested ip %q is neither static nor assigned to the LB", requestedIP)
} }
func (gce *GCECloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation bool, svc *v1.Service, loadBalancerName, clusterID, ipAddressToUse string, hosts []*gceInstance, hcToCreate, hcToDelete *compute.HttpHealthCheck) error { func (g *Cloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation bool, svc *v1.Service, loadBalancerName, clusterID, ipAddressToUse string, hosts []*gceInstance, hcToCreate, hcToDelete *compute.HttpHealthCheck) error {
serviceName := types.NamespacedName{Namespace: svc.Namespace, Name: svc.Name} serviceName := types.NamespacedName{Namespace: svc.Namespace, Name: svc.Name}
lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName) lbRefStr := fmt.Sprintf("%v(%v)", loadBalancerName, serviceName)
@ -472,7 +473,7 @@ func (gce *GCECloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation
if hcToDelete != nil { if hcToDelete != nil {
hcNames = append(hcNames, hcToDelete.Name) hcNames = append(hcNames, hcToDelete.Name)
} }
if err := gce.DeleteExternalTargetPoolAndChecks(svc, loadBalancerName, gce.region, clusterID, hcNames...); err != nil { if err := g.DeleteExternalTargetPoolAndChecks(svc, loadBalancerName, g.region, clusterID, hcNames...); err != nil {
return fmt.Errorf("failed to delete existing target pool for load balancer (%s) update: %v", lbRefStr, err) return fmt.Errorf("failed to delete existing target pool for load balancer (%s) update: %v", lbRefStr, err)
} }
glog.Infof("ensureTargetPoolAndHealthCheck(%s): Deleted target pool.", lbRefStr) glog.Infof("ensureTargetPoolAndHealthCheck(%s): Deleted target pool.", lbRefStr)
@ -484,7 +485,7 @@ func (gce *GCECloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation
if len(hosts) > maxTargetPoolCreateInstances { if len(hosts) > maxTargetPoolCreateInstances {
createInstances = createInstances[:maxTargetPoolCreateInstances] createInstances = createInstances[:maxTargetPoolCreateInstances]
} }
if err := gce.createTargetPoolAndHealthCheck(svc, loadBalancerName, serviceName.String(), ipAddressToUse, gce.region, clusterID, createInstances, hcToCreate); err != nil { if err := g.createTargetPoolAndHealthCheck(svc, loadBalancerName, serviceName.String(), ipAddressToUse, g.region, clusterID, createInstances, hcToCreate); err != nil {
return fmt.Errorf("failed to create target pool for load balancer (%s): %v", lbRefStr, err) return fmt.Errorf("failed to create target pool for load balancer (%s): %v", lbRefStr, err)
} }
if hcToCreate != nil { if hcToCreate != nil {
@ -494,19 +495,19 @@ func (gce *GCECloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation
glog.Infof("ensureTargetPoolAndHealthCheck(%s): Created target pool.", lbRefStr) glog.Infof("ensureTargetPoolAndHealthCheck(%s): Created target pool.", lbRefStr)
} else { } else {
glog.Infof("ensureTargetPoolAndHealthCheck(%s): Created initial target pool (now updating the remaining %d hosts).", lbRefStr, len(hosts)-maxTargetPoolCreateInstances) glog.Infof("ensureTargetPoolAndHealthCheck(%s): Created initial target pool (now updating the remaining %d hosts).", lbRefStr, len(hosts)-maxTargetPoolCreateInstances)
if err := gce.updateTargetPool(loadBalancerName, hosts); err != nil { if err := g.updateTargetPool(loadBalancerName, hosts); err != nil {
return fmt.Errorf("failed to update target pool for load balancer (%s): %v", lbRefStr, err) return fmt.Errorf("failed to update target pool for load balancer (%s): %v", lbRefStr, err)
} }
glog.Infof("ensureTargetPoolAndHealthCheck(%s): Updated target pool (with %d hosts).", lbRefStr, len(hosts)-maxTargetPoolCreateInstances) glog.Infof("ensureTargetPoolAndHealthCheck(%s): Updated target pool (with %d hosts).", lbRefStr, len(hosts)-maxTargetPoolCreateInstances)
} }
} else if tpExists { } else if tpExists {
// Ensure hosts are updated even if there is no other changes required on target pool. // Ensure hosts are updated even if there is no other changes required on target pool.
if err := gce.updateTargetPool(loadBalancerName, hosts); err != nil { if err := g.updateTargetPool(loadBalancerName, hosts); err != nil {
return fmt.Errorf("failed to update target pool for load balancer (%s): %v", lbRefStr, err) return fmt.Errorf("failed to update target pool for load balancer (%s): %v", lbRefStr, err)
} }
glog.Infof("ensureTargetPoolAndHealthCheck(%s): Updated target pool (with %d hosts).", lbRefStr, len(hosts)) glog.Infof("ensureTargetPoolAndHealthCheck(%s): Updated target pool (with %d hosts).", lbRefStr, len(hosts))
if hcToCreate != nil { if hcToCreate != nil {
if hc, err := gce.ensureHttpHealthCheck(hcToCreate.Name, hcToCreate.RequestPath, int32(hcToCreate.Port)); err != nil || hc == nil { if hc, err := g.ensureHTTPHealthCheck(hcToCreate.Name, hcToCreate.RequestPath, int32(hcToCreate.Port)); err != nil || hc == nil {
return fmt.Errorf("Failed to ensure health check for %v port %d path %v: %v", loadBalancerName, hcToCreate.Port, hcToCreate.RequestPath, err) return fmt.Errorf("Failed to ensure health check for %v port %d path %v: %v", loadBalancerName, hcToCreate.Port, hcToCreate.RequestPath, err)
} }
} }
@ -517,7 +518,7 @@ func (gce *GCECloud) ensureTargetPoolAndHealthCheck(tpExists, tpNeedsRecreation
return nil return nil
} }
func (gce *GCECloud) createTargetPoolAndHealthCheck(svc *v1.Service, name, serviceName, ipAddress, region, clusterID string, hosts []*gceInstance, hc *compute.HttpHealthCheck) error { func (g *Cloud) createTargetPoolAndHealthCheck(svc *v1.Service, name, serviceName, ipAddress, region, clusterID string, hosts []*gceInstance, hc *compute.HttpHealthCheck) error {
// health check management is coupled with targetPools to prevent leaks. A // health check management is coupled with targetPools to prevent leaks. A
// target pool is the only thing that requires a health check, so we delete // target pool is the only thing that requires a health check, so we delete
// associated checks on teardown, and ensure checks on setup. // associated checks on teardown, and ensure checks on setup.
@ -527,16 +528,16 @@ func (gce *GCECloud) createTargetPoolAndHealthCheck(svc *v1.Service, name, servi
isNodesHealthCheck := hc.Name != name isNodesHealthCheck := hc.Name != name
if isNodesHealthCheck { if isNodesHealthCheck {
// Lock to prevent necessary nodes health check / firewall gets deleted. // Lock to prevent necessary nodes health check / firewall gets deleted.
gce.sharedResourceLock.Lock() g.sharedResourceLock.Lock()
defer gce.sharedResourceLock.Unlock() defer g.sharedResourceLock.Unlock()
} }
if err := gce.ensureHttpHealthCheckFirewall(svc, serviceName, ipAddress, region, clusterID, hosts, hc.Name, int32(hc.Port), isNodesHealthCheck); err != nil { if err := g.ensureHTTPHealthCheckFirewall(svc, serviceName, ipAddress, region, clusterID, hosts, hc.Name, int32(hc.Port), isNodesHealthCheck); err != nil {
return err return err
} }
var err error var err error
hcRequestPath, hcPort := hc.RequestPath, hc.Port hcRequestPath, hcPort := hc.RequestPath, hc.Port
if hc, err = gce.ensureHttpHealthCheck(hc.Name, hc.RequestPath, int32(hc.Port)); err != nil || hc == nil { if hc, err = g.ensureHTTPHealthCheck(hc.Name, hc.RequestPath, int32(hc.Port)); err != nil || hc == nil {
return fmt.Errorf("Failed to ensure health check for %v port %d path %v: %v", name, hcPort, hcRequestPath, err) return fmt.Errorf("Failed to ensure health check for %v port %d path %v: %v", name, hcPort, hcRequestPath, err)
} }
hcLinks = append(hcLinks, hc.SelfLink) hcLinks = append(hcLinks, hc.SelfLink)
@ -555,14 +556,14 @@ func (gce *GCECloud) createTargetPoolAndHealthCheck(svc *v1.Service, name, servi
HealthChecks: hcLinks, HealthChecks: hcLinks,
} }
if err := gce.CreateTargetPool(pool, region); err != nil && !isHTTPErrorCode(err, http.StatusConflict) { if err := g.CreateTargetPool(pool, region); err != nil && !isHTTPErrorCode(err, http.StatusConflict) {
return err return err
} }
return nil return nil
} }
func (gce *GCECloud) updateTargetPool(loadBalancerName string, hosts []*gceInstance) error { func (g *Cloud) updateTargetPool(loadBalancerName string, hosts []*gceInstance) error {
pool, err := gce.GetTargetPool(loadBalancerName, gce.region) pool, err := g.GetTargetPool(loadBalancerName, g.region)
if err != nil { if err != nil {
return err return err
} }
@ -585,13 +586,13 @@ func (gce *GCECloud) updateTargetPool(loadBalancerName string, hosts []*gceInsta
} }
if len(toAdd) > 0 { if len(toAdd) > 0 {
if err := gce.AddInstancesToTargetPool(loadBalancerName, gce.region, toAdd); err != nil { if err := g.AddInstancesToTargetPool(loadBalancerName, g.region, toAdd); err != nil {
return err return err
} }
} }
if len(toRemove) > 0 { if len(toRemove) > 0 {
if err := gce.RemoveInstancesFromTargetPool(loadBalancerName, gce.region, toRemove); err != nil { if err := g.RemoveInstancesFromTargetPool(loadBalancerName, g.region, toRemove); err != nil {
return err return err
} }
} }
@ -599,7 +600,7 @@ func (gce *GCECloud) updateTargetPool(loadBalancerName string, hosts []*gceInsta
// Try to verify that the correct number of nodes are now in the target pool. // Try to verify that the correct number of nodes are now in the target pool.
// We've been bitten by a bug here before (#11327) where all nodes were // We've been bitten by a bug here before (#11327) where all nodes were
// accidentally removed and want to make similar problems easier to notice. // accidentally removed and want to make similar problems easier to notice.
updatedPool, err := gce.GetTargetPool(loadBalancerName, gce.region) updatedPool, err := g.GetTargetPool(loadBalancerName, g.region)
if err != nil { if err != nil {
return err return err
} }
@ -611,11 +612,11 @@ func (gce *GCECloud) updateTargetPool(loadBalancerName string, hosts []*gceInsta
return nil return nil
} }
func (gce *GCECloud) targetPoolURL(name string) string { func (g *Cloud) targetPoolURL(name string) string {
return gce.service.BasePath + strings.Join([]string{gce.projectID, "regions", gce.region, "targetPools", name}, "/") return g.service.BasePath + strings.Join([]string{g.projectID, "regions", g.region, "targetPools", name}, "/")
} }
func makeHttpHealthCheck(name, path string, port int32) *compute.HttpHealthCheck { func makeHTTPHealthCheck(name, path string, port int32) *compute.HttpHealthCheck {
return &compute.HttpHealthCheck{ return &compute.HttpHealthCheck{
Name: name, Name: name,
Port: int64(port), Port: int64(port),
@ -629,13 +630,13 @@ func makeHttpHealthCheck(name, path string, port int32) *compute.HttpHealthCheck
} }
} }
// mergeHttpHealthChecks reconciles HttpHealthCheck configures to be no smaller // mergeHTTPHealthChecks reconciles HttpHealthCheck configures to be no smaller
// than the default values. // than the default values.
// E.g. old health check interval is 2s, new default is 8. // E.g. old health check interval is 2s, new default is 8.
// The HC interval will be reconciled to 8 seconds. // The HC interval will be reconciled to 8 seconds.
// If the existing health check is larger than the default interval, // If the existing health check is larger than the default interval,
// the configuration will be kept. // the configuration will be kept.
func mergeHttpHealthChecks(hc, newHC *compute.HttpHealthCheck) *compute.HttpHealthCheck { func mergeHTTPHealthChecks(hc, newHC *compute.HttpHealthCheck) *compute.HttpHealthCheck {
if hc.CheckIntervalSec > newHC.CheckIntervalSec { if hc.CheckIntervalSec > newHC.CheckIntervalSec {
newHC.CheckIntervalSec = hc.CheckIntervalSec newHC.CheckIntervalSec = hc.CheckIntervalSec
} }
@ -651,24 +652,24 @@ func mergeHttpHealthChecks(hc, newHC *compute.HttpHealthCheck) *compute.HttpHeal
return newHC return newHC
} }
// needToUpdateHttpHealthChecks checks whether the http healthcheck needs to be // needToUpdateHTTPHealthChecks checks whether the http healthcheck needs to be
// updated. // updated.
func needToUpdateHttpHealthChecks(hc, newHC *compute.HttpHealthCheck) bool { func needToUpdateHTTPHealthChecks(hc, newHC *compute.HttpHealthCheck) bool {
changed := hc.Port != newHC.Port || hc.RequestPath != newHC.RequestPath || hc.Description != newHC.Description changed := hc.Port != newHC.Port || hc.RequestPath != newHC.RequestPath || hc.Description != newHC.Description
changed = changed || hc.CheckIntervalSec < newHC.CheckIntervalSec || hc.TimeoutSec < newHC.TimeoutSec changed = changed || hc.CheckIntervalSec < newHC.CheckIntervalSec || hc.TimeoutSec < newHC.TimeoutSec
changed = changed || hc.UnhealthyThreshold < newHC.UnhealthyThreshold || hc.HealthyThreshold < newHC.HealthyThreshold changed = changed || hc.UnhealthyThreshold < newHC.UnhealthyThreshold || hc.HealthyThreshold < newHC.HealthyThreshold
return changed return changed
} }
func (gce *GCECloud) ensureHttpHealthCheck(name, path string, port int32) (hc *compute.HttpHealthCheck, err error) { func (g *Cloud) ensureHTTPHealthCheck(name, path string, port int32) (hc *compute.HttpHealthCheck, err error) {
newHC := makeHttpHealthCheck(name, path, port) newHC := makeHTTPHealthCheck(name, path, port)
hc, err = gce.GetHttpHealthCheck(name) hc, err = g.GetHTTPHealthCheck(name)
if hc == nil || err != nil && isHTTPErrorCode(err, http.StatusNotFound) { if hc == nil || err != nil && isHTTPErrorCode(err, http.StatusNotFound) {
glog.Infof("Did not find health check %v, creating port %v path %v", name, port, path) glog.Infof("Did not find health check %v, creating port %v path %v", name, port, path)
if err = gce.CreateHttpHealthCheck(newHC); err != nil { if err = g.CreateHTTPHealthCheck(newHC); err != nil {
return nil, err return nil, err
} }
hc, err = gce.GetHttpHealthCheck(name) hc, err = g.GetHTTPHealthCheck(name)
if err != nil { if err != nil {
glog.Errorf("Failed to get http health check %v", err) glog.Errorf("Failed to get http health check %v", err)
return nil, err return nil, err
@ -678,15 +679,15 @@ func (gce *GCECloud) ensureHttpHealthCheck(name, path string, port int32) (hc *c
} }
// Validate health check fields // Validate health check fields
glog.V(4).Infof("Checking http health check params %s", name) glog.V(4).Infof("Checking http health check params %s", name)
if needToUpdateHttpHealthChecks(hc, newHC) { if needToUpdateHTTPHealthChecks(hc, newHC) {
glog.Warningf("Health check %v exists but parameters have drifted - updating...", name) glog.Warningf("Health check %v exists but parameters have drifted - updating...", name)
newHC = mergeHttpHealthChecks(hc, newHC) newHC = mergeHTTPHealthChecks(hc, newHC)
if err := gce.UpdateHttpHealthCheck(newHC); err != nil { if err := g.UpdateHTTPHealthCheck(newHC); err != nil {
glog.Warningf("Failed to reconcile http health check %v parameters", name) glog.Warningf("Failed to reconcile http health check %v parameters", name)
return nil, err return nil, err
} }
glog.V(4).Infof("Corrected health check %v parameters successful", name) glog.V(4).Infof("Corrected health check %v parameters successful", name)
hc, err = gce.GetHttpHealthCheck(name) hc, err = g.GetHTTPHealthCheck(name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -698,14 +699,14 @@ func (gce *GCECloud) ensureHttpHealthCheck(name, path string, port int32) (hc *c
// IP is being requested. // IP is being requested.
// Returns whether the forwarding rule exists, whether it needs to be updated, // Returns whether the forwarding rule exists, whether it needs to be updated,
// what its IP address is (if it exists), and any error we encountered. // what its IP address is (if it exists), and any error we encountered.
func (gce *GCECloud) forwardingRuleNeedsUpdate(name, region string, loadBalancerIP string, ports []v1.ServicePort) (exists bool, needsUpdate bool, ipAddress string, err error) { func (g *Cloud) forwardingRuleNeedsUpdate(name, region string, loadBalancerIP string, ports []v1.ServicePort) (exists bool, needsUpdate bool, ipAddress string, err error) {
fwd, err := gce.GetRegionForwardingRule(name, region) fwd, err := g.GetRegionForwardingRule(name, region)
if err != nil { if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) { if isHTTPErrorCode(err, http.StatusNotFound) {
return false, true, "", nil return false, true, "", nil
} }
// Err on the side of caution in case of errors. Caller should notice the error and retry. // Err on the side of caution in case of errors. Caller should notice the error and retry.
// We never want to end up recreating resources because gce api flaked. // We never want to end up recreating resources because g api flaked.
return true, false, "", fmt.Errorf("error getting load balancer's forwarding rule: %v", err) return true, false, "", fmt.Errorf("error getting load balancer's forwarding rule: %v", err)
} }
// If the user asks for a specific static ip through the Service spec, // If the user asks for a specific static ip through the Service spec,
@ -719,7 +720,7 @@ func (gce *GCECloud) forwardingRuleNeedsUpdate(name, region string, loadBalancer
portRange, err := loadBalancerPortRange(ports) portRange, err := loadBalancerPortRange(ports)
if err != nil { if err != nil {
// Err on the side of caution in case of errors. Caller should notice the error and retry. // Err on the side of caution in case of errors. Caller should notice the error and retry.
// We never want to end up recreating resources because gce api flaked. // We never want to end up recreating resources because g api flaked.
return true, false, "", err return true, false, "", err
} }
if portRange != fwd.PortRange { if portRange != fwd.PortRange {
@ -737,14 +738,14 @@ func (gce *GCECloud) forwardingRuleNeedsUpdate(name, region string, loadBalancer
// Doesn't check whether the hosts have changed, since host updating is handled // Doesn't check whether the hosts have changed, since host updating is handled
// separately. // separately.
func (gce *GCECloud) targetPoolNeedsRecreation(name, region string, affinityType v1.ServiceAffinity) (exists bool, needsRecreation bool, err error) { func (g *Cloud) targetPoolNeedsRecreation(name, region string, affinityType v1.ServiceAffinity) (exists bool, needsRecreation bool, err error) {
tp, err := gce.GetTargetPool(name, region) tp, err := g.GetTargetPool(name, region)
if err != nil { if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) { if isHTTPErrorCode(err, http.StatusNotFound) {
return false, true, nil return false, true, nil
} }
// Err on the side of caution in case of errors. Caller should notice the error and retry. // Err on the side of caution in case of errors. Caller should notice the error and retry.
// We never want to end up recreating resources because gce api flaked. // We never want to end up recreating resources because g api flaked.
return true, false, fmt.Errorf("error getting load balancer's target pool: %v", err) return true, false, fmt.Errorf("error getting load balancer's target pool: %v", err)
} }
// TODO: If the user modifies their Service's session affinity, it *should* // TODO: If the user modifies their Service's session affinity, it *should*
@ -818,8 +819,8 @@ func translateAffinityType(affinityType v1.ServiceAffinity) string {
} }
} }
func (gce *GCECloud) firewallNeedsUpdate(name, serviceName, region, ipAddress string, ports []v1.ServicePort, sourceRanges netsets.IPNet) (exists bool, needsUpdate bool, err error) { func (g *Cloud) firewallNeedsUpdate(name, serviceName, region, ipAddress string, ports []v1.ServicePort, sourceRanges netsets.IPNet) (exists bool, needsUpdate bool, err error) {
fw, err := gce.GetFirewall(MakeFirewallName(name)) fw, err := g.GetFirewall(MakeFirewallName(name))
if err != nil { if err != nil {
if isHTTPErrorCode(err, http.StatusNotFound) { if isHTTPErrorCode(err, http.StatusNotFound) {
return false, true, nil return false, true, nil
@ -856,7 +857,7 @@ func (gce *GCECloud) firewallNeedsUpdate(name, serviceName, region, ipAddress st
return true, false, nil return true, false, nil
} }
func (gce *GCECloud) ensureHttpHealthCheckFirewall(svc *v1.Service, serviceName, ipAddress, region, clusterID string, hosts []*gceInstance, hcName string, hcPort int32, isNodesHealthCheck bool) error { func (g *Cloud) ensureHTTPHealthCheckFirewall(svc *v1.Service, serviceName, ipAddress, region, clusterID string, hosts []*gceInstance, hcName string, hcPort int32, isNodesHealthCheck bool) error {
// Prepare the firewall params for creating / checking. // Prepare the firewall params for creating / checking.
desc := fmt.Sprintf(`{"kubernetes.io/cluster-id":"%s"}`, clusterID) desc := fmt.Sprintf(`{"kubernetes.io/cluster-id":"%s"}`, clusterID)
if !isNodesHealthCheck { if !isNodesHealthCheck {
@ -866,13 +867,13 @@ func (gce *GCECloud) ensureHttpHealthCheckFirewall(svc *v1.Service, serviceName,
ports := []v1.ServicePort{{Protocol: "tcp", Port: hcPort}} ports := []v1.ServicePort{{Protocol: "tcp", Port: hcPort}}
fwName := MakeHealthCheckFirewallName(clusterID, hcName, isNodesHealthCheck) fwName := MakeHealthCheckFirewallName(clusterID, hcName, isNodesHealthCheck)
fw, err := gce.GetFirewall(fwName) fw, err := g.GetFirewall(fwName)
if err != nil { if err != nil {
if !isHTTPErrorCode(err, http.StatusNotFound) { if !isHTTPErrorCode(err, http.StatusNotFound) {
return fmt.Errorf("error getting firewall for health checks: %v", err) return fmt.Errorf("error getting firewall for health checks: %v", err)
} }
glog.Infof("Creating firewall %v for health checks.", fwName) glog.Infof("Creating firewall %v for health checks.", fwName)
if err := gce.createFirewall(svc, fwName, region, desc, sourceRanges, ports, hosts); err != nil { if err := g.createFirewall(svc, fwName, region, desc, sourceRanges, ports, hosts); err != nil {
return err return err
} }
glog.Infof("Created firewall %v for health checks.", fwName) glog.Infof("Created firewall %v for health checks.", fwName)
@ -885,7 +886,7 @@ func (gce *GCECloud) ensureHttpHealthCheckFirewall(svc *v1.Service, serviceName,
!equalStringSets(fw.Allowed[0].Ports, []string{strconv.Itoa(int(ports[0].Port))}) || !equalStringSets(fw.Allowed[0].Ports, []string{strconv.Itoa(int(ports[0].Port))}) ||
!equalStringSets(fw.SourceRanges, sourceRanges.StringSlice()) { !equalStringSets(fw.SourceRanges, sourceRanges.StringSlice()) {
glog.Warningf("Firewall %v exists but parameters have drifted - updating...", fwName) glog.Warningf("Firewall %v exists but parameters have drifted - updating...", fwName)
if err := gce.updateFirewall(svc, fwName, region, desc, sourceRanges, ports, hosts); err != nil { if err := g.updateFirewall(svc, fwName, region, desc, sourceRanges, ports, hosts); err != nil {
glog.Warningf("Failed to reconcile firewall %v parameters.", fwName) glog.Warningf("Failed to reconcile firewall %v parameters.", fwName)
return err return err
} }
@ -933,17 +934,17 @@ func createForwardingRule(s CloudForwardingRuleService, name, serviceName, regio
return nil return nil
} }
func (gce *GCECloud) createFirewall(svc *v1.Service, name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) error { func (g *Cloud) createFirewall(svc *v1.Service, name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) error {
firewall, err := gce.firewallObject(name, region, desc, sourceRanges, ports, hosts) firewall, err := g.firewallObject(name, region, desc, sourceRanges, ports, hosts)
if err != nil { if err != nil {
return err return err
} }
if err = gce.CreateFirewall(firewall); err != nil { if err = g.CreateFirewall(firewall); err != nil {
if isHTTPErrorCode(err, http.StatusConflict) { if isHTTPErrorCode(err, http.StatusConflict) {
return nil return nil
} else if isForbidden(err) && gce.OnXPN() { } else if isForbidden(err) && g.OnXPN() {
glog.V(4).Infof("createFirewall(%v): do not have permission to create firewall rule (on XPN). Raising event.", firewall.Name) glog.V(4).Infof("createFirewall(%v): do not have permission to create firewall rule (on XPN). Raising event.", firewall.Name)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudCreateCmd(firewall, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudCreateCmd(firewall, g.NetworkProjectID()))
return nil return nil
} }
return err return err
@ -951,18 +952,18 @@ func (gce *GCECloud) createFirewall(svc *v1.Service, name, region, desc string,
return nil return nil
} }
func (gce *GCECloud) updateFirewall(svc *v1.Service, name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) error { func (g *Cloud) updateFirewall(svc *v1.Service, name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) error {
firewall, err := gce.firewallObject(name, region, desc, sourceRanges, ports, hosts) firewall, err := g.firewallObject(name, region, desc, sourceRanges, ports, hosts)
if err != nil { if err != nil {
return err return err
} }
if err = gce.UpdateFirewall(firewall); err != nil { if err = g.UpdateFirewall(firewall); err != nil {
if isHTTPErrorCode(err, http.StatusConflict) { if isHTTPErrorCode(err, http.StatusConflict) {
return nil return nil
} else if isForbidden(err) && gce.OnXPN() { } else if isForbidden(err) && g.OnXPN() {
glog.V(4).Infof("updateFirewall(%v): do not have permission to update firewall rule (on XPN). Raising event.", firewall.Name) glog.V(4).Infof("updateFirewall(%v): do not have permission to update firewall rule (on XPN). Raising event.", firewall.Name)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudUpdateCmd(firewall, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudUpdateCmd(firewall, g.NetworkProjectID()))
return nil return nil
} }
return err return err
@ -970,25 +971,25 @@ func (gce *GCECloud) updateFirewall(svc *v1.Service, name, region, desc string,
return nil return nil
} }
func (gce *GCECloud) firewallObject(name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) (*compute.Firewall, error) { func (g *Cloud) firewallObject(name, region, desc string, sourceRanges netsets.IPNet, ports []v1.ServicePort, hosts []*gceInstance) (*compute.Firewall, error) {
allowedPorts := make([]string, len(ports)) allowedPorts := make([]string, len(ports))
for ix := range ports { for ix := range ports {
allowedPorts[ix] = strconv.Itoa(int(ports[ix].Port)) allowedPorts[ix] = strconv.Itoa(int(ports[ix].Port))
} }
// If the node tags to be used for this cluster have been predefined in the // If the node tags to be used for this cluster have been predefined in the
// provider config, just use them. Otherwise, invoke computeHostTags method to get the tags. // provider config, just use them. Otherwise, invoke computeHostTags method to get the tags.
hostTags := gce.nodeTags hostTags := g.nodeTags
if len(hostTags) == 0 { if len(hostTags) == 0 {
var err error var err error
if hostTags, err = gce.computeHostTags(hosts); err != nil { if hostTags, err = g.computeHostTags(hosts); err != nil {
return nil, fmt.Errorf("No node tags supplied and also failed to parse the given lists of hosts for tags. Abort creating firewall rule.") return nil, fmt.Errorf("no node tags supplied and also failed to parse the given lists of hosts for tags. Abort creating firewall rule")
} }
} }
firewall := &compute.Firewall{ firewall := &compute.Firewall{
Name: name, Name: name,
Description: desc, Description: desc,
Network: gce.networkURL, Network: g.networkURL,
SourceRanges: sourceRanges.StringSlice(), SourceRanges: sourceRanges.StringSlice(),
TargetTags: hostTags, TargetTags: hostTags,
Allowed: []*compute.FirewallAllowed{ Allowed: []*compute.FirewallAllowed{
@ -1054,8 +1055,8 @@ func ensureStaticIP(s CloudAddressService, name, serviceName, region, existingIP
return addr.Address, existed, nil return addr.Address, existed, nil
} }
func (gce *GCECloud) getServiceNetworkTier(svc *v1.Service) (cloud.NetworkTier, error) { func (g *Cloud) getServiceNetworkTier(svc *v1.Service) (cloud.NetworkTier, error) {
if !gce.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) { if !g.AlphaFeatureGate.Enabled(AlphaFeatureNetworkTiers) {
return cloud.NetworkTierDefault, nil return cloud.NetworkTierDefault, nil
} }
tier, err := GetServiceNetworkTier(svc) tier, err := GetServiceNetworkTier(svc)
@ -1066,12 +1067,12 @@ func (gce *GCECloud) getServiceNetworkTier(svc *v1.Service) (cloud.NetworkTier,
return tier, nil return tier, nil
} }
func (gce *GCECloud) deleteWrongNetworkTieredResources(lbName, lbRef string, desiredNetTier cloud.NetworkTier) error { func (g *Cloud) deleteWrongNetworkTieredResources(lbName, lbRef string, desiredNetTier cloud.NetworkTier) error {
logPrefix := fmt.Sprintf("deleteWrongNetworkTieredResources:(%s)", lbRef) logPrefix := fmt.Sprintf("deleteWrongNetworkTieredResources:(%s)", lbRef)
if err := deleteFWDRuleWithWrongTier(gce, gce.region, lbName, logPrefix, desiredNetTier); err != nil { if err := deleteFWDRuleWithWrongTier(g, g.region, lbName, logPrefix, desiredNetTier); err != nil {
return err return err
} }
if err := deleteAddressWithWrongTier(gce, gce.region, lbName, logPrefix, desiredNetTier); err != nil { if err := deleteAddressWithWrongTier(g, g.region, lbName, logPrefix, desiredNetTier); err != nil {
return err return err
} }
return nil return nil

48
pkg/cloudprovider/providers/gce/gce_loadbalancer_external_test.go
View File

@ -164,7 +164,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
vals := DefaultTestClusterValues() vals := DefaultTestClusterValues()
serviceName := "foo-svc" serviceName := "foo-svc"
baseLinkUrl := "https://www.googleapis.com/compute/%v/projects/%v/regions/%v/forwardingRules/%v" baseLinkURL := "https://www.googleapis.com/compute/%v/projects/%v/regions/%v/forwardingRules/%v"
for desc, tc := range map[string]struct { for desc, tc := range map[string]struct {
netTier cloud.NetworkTier netTier cloud.NetworkTier
@ -180,7 +180,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
PortRange: "123-123", PortRange: "123-123",
Target: target, Target: target,
NetworkTier: "PREMIUM", NetworkTier: "PREMIUM",
SelfLink: fmt.Sprintf(baseLinkUrl, "v1", vals.ProjectID, vals.Region, "lb-1"), SelfLink: fmt.Sprintf(baseLinkURL, "v1", vals.ProjectID, vals.Region, "lb-1"),
}, },
}, },
"Standard tier": { "Standard tier": {
@ -193,7 +193,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
PortRange: "123-123", PortRange: "123-123",
Target: target, Target: target,
NetworkTier: "STANDARD", NetworkTier: "STANDARD",
SelfLink: fmt.Sprintf(baseLinkUrl, "alpha", vals.ProjectID, vals.Region, "lb-2"), SelfLink: fmt.Sprintf(baseLinkURL, "alpha", vals.ProjectID, vals.Region, "lb-2"),
}, },
}, },
} { } {
@ -276,7 +276,7 @@ func TestDeleteAddressWithWrongTier(t *testing.T) {
} }
} }
func createExternalLoadBalancer(gce *GCECloud, svc *v1.Service, nodeNames []string, clusterName, clusterID, zoneName string) (*v1.LoadBalancerStatus, error) { func createExternalLoadBalancer(gce *Cloud, svc *v1.Service, nodeNames []string, clusterName, clusterID, zoneName string) (*v1.LoadBalancerStatus, error) {
nodes, err := createAndInsertNodes(gce, nodeNames, zoneName) nodes, err := createAndInsertNodes(gce, nodeNames, zoneName)
if err != nil { if err != nil {
return nil, err return nil, err
@ -498,7 +498,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports []v1.ServicePort ports []v1.ServicePort
exists bool exists bool
needsUpdate bool needsUpdate bool
expectIpAddr string expectIPAddr string
expectError bool expectError bool
}{ }{
"When the loadBalancerIP does not equal the FwdRule IP address.": { "When the loadBalancerIP does not equal the FwdRule IP address.": {
@ -506,7 +506,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports: svc.Spec.Ports, ports: svc.Spec.Ports,
exists: true, exists: true,
needsUpdate: true, needsUpdate: true,
expectIpAddr: ipAddr, expectIPAddr: ipAddr,
expectError: false, expectError: false,
}, },
"When loadBalancerPortRange returns an error.": { "When loadBalancerPortRange returns an error.": {
@ -514,7 +514,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports: []v1.ServicePort{}, ports: []v1.ServicePort{},
exists: true, exists: true,
needsUpdate: false, needsUpdate: false,
expectIpAddr: "", expectIPAddr: "",
expectError: true, expectError: true,
}, },
"When portRange not equals to the forwardingRule port range.": { "When portRange not equals to the forwardingRule port range.": {
@ -522,7 +522,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports: wrongPorts, ports: wrongPorts,
exists: true, exists: true,
needsUpdate: true, needsUpdate: true,
expectIpAddr: ipAddr, expectIPAddr: ipAddr,
expectError: false, expectError: false,
}, },
"When the ports protocol does not equal the ForwardingRuel IP Protocol.": { "When the ports protocol does not equal the ForwardingRuel IP Protocol.": {
@ -530,7 +530,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports: wrongProtocolPorts, ports: wrongProtocolPorts,
exists: true, exists: true,
needsUpdate: true, needsUpdate: true,
expectIpAddr: ipAddr, expectIPAddr: ipAddr,
expectError: false, expectError: false,
}, },
"When basic workflow.": { "When basic workflow.": {
@ -538,7 +538,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
ports: svc.Spec.Ports, ports: svc.Spec.Ports,
exists: true, exists: true,
needsUpdate: false, needsUpdate: false,
expectIpAddr: ipAddr, expectIPAddr: ipAddr,
expectError: false, expectError: false,
}, },
} { } {
@ -546,7 +546,7 @@ func TestForwardingRuleNeedsUpdate(t *testing.T) {
exists, needsUpdate, ipAddress, err := gce.forwardingRuleNeedsUpdate(lbName, vals.Region, tc.lbIP, tc.ports) exists, needsUpdate, ipAddress, err := gce.forwardingRuleNeedsUpdate(lbName, vals.Region, tc.lbIP, tc.ports)
assert.Equal(t, tc.exists, exists, "'exists' didn't return as expected "+desc) assert.Equal(t, tc.exists, exists, "'exists' didn't return as expected "+desc)
assert.Equal(t, tc.needsUpdate, needsUpdate, "'needsUpdate' didn't return as expected "+desc) assert.Equal(t, tc.needsUpdate, needsUpdate, "'needsUpdate' didn't return as expected "+desc)
assert.Equal(t, tc.expectIpAddr, ipAddress, "'ipAddress' didn't return as expected "+desc) assert.Equal(t, tc.expectIPAddr, ipAddress, "'ipAddress' didn't return as expected "+desc)
if tc.expectError { if tc.expectError {
assert.Error(t, err, "Should returns an error "+desc) assert.Error(t, err, "Should returns an error "+desc)
} else { } else {
@ -806,8 +806,8 @@ func TestEnsureTargetPoolAndHealthCheck(t *testing.T) {
lbName := gce.GetLoadBalancerName(context.TODO(), "", svc) lbName := gce.GetLoadBalancerName(context.TODO(), "", svc)
region := vals.Region region := vals.Region
hcToCreate := makeHttpHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort()) hcToCreate := makeHTTPHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort())
hcToDelete := makeHttpHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort()) hcToDelete := makeHTTPHealthCheck(MakeNodesHealthCheckName(clusterID), GetNodesHealthCheckPath(), GetNodesHealthCheckPort())
// Apply a tag on the target pool. By verifying the change of the tag, target pool update can be ensured. // Apply a tag on the target pool. By verifying the change of the tag, target pool update can be ensured.
tag := "A Tag" tag := "A Tag"
@ -823,7 +823,7 @@ func TestEnsureTargetPoolAndHealthCheck(t *testing.T) {
pool, err = gce.GetTargetPool(lbName, region) pool, err = gce.GetTargetPool(lbName, region)
assert.Equal(t, 1, len(pool.Instances)) assert.Equal(t, 1, len(pool.Instances))
var manyNodeName [maxTargetPoolCreateInstances + 1]string var manyNodeName [maxTargetPoolCreateInstances + 1]string
for i := 0; i < maxTargetPoolCreateInstances+1; i += 1 { for i := 0; i < maxTargetPoolCreateInstances+1; i++ {
manyNodeName[i] = fmt.Sprintf("testnode_%d", i) manyNodeName[i] = fmt.Sprintf("testnode_%d", i)
} }
manyNodes, err := createAndInsertNodes(gce, manyNodeName[:], vals.ZoneName) manyNodes, err := createAndInsertNodes(gce, manyNodeName[:], vals.ZoneName)
@ -1079,17 +1079,17 @@ func TestExternalLoadBalancerEnsureHttpHealthCheck(t *testing.T) {
} }
hcName, hcPath, hcPort := "test-hc", "/healthz", int32(12345) hcName, hcPath, hcPort := "test-hc", "/healthz", int32(12345)
existingHC := makeHttpHealthCheck(hcName, hcPath, hcPort) existingHC := makeHTTPHealthCheck(hcName, hcPath, hcPort)
existingHC = tc.modifier(existingHC) existingHC = tc.modifier(existingHC)
if existingHC != nil { if existingHC != nil {
if err := gce.CreateHttpHealthCheck(existingHC); err != nil { if err := gce.CreateHTTPHealthCheck(existingHC); err != nil {
t.Fatalf("gce.CreateHttpHealthCheck(%#v) = %v; want err = nil", existingHC, err) t.Fatalf("gce.CreateHttpHealthCheck(%#v) = %v; want err = nil", existingHC, err)
} }
} }
if _, err := gce.ensureHttpHealthCheck(hcName, hcPath, hcPort); err != nil { if _, err := gce.ensureHTTPHealthCheck(hcName, hcPath, hcPort); err != nil {
t.Fatalf("gce.ensureHttpHealthCheck(%q, %q, %v) = _, %d; want err = nil", hcName, hcPath, hcPort, err) t.Fatalf("gce.ensureHttpHealthCheck(%q, %q, %v) = _, %d; want err = nil", hcName, hcPath, hcPort, err)
} }
if hc, err := gce.GetHttpHealthCheck(hcName); err != nil { if hc, err := gce.GetHTTPHealthCheck(hcName); err != nil {
t.Fatalf("gce.GetHttpHealthCheck(%q) = _, %d; want err = nil", hcName, err) t.Fatalf("gce.GetHttpHealthCheck(%q) = _, %d; want err = nil", hcName, err)
} else { } else {
if tc.wantEqual { if tc.wantEqual {
@ -1127,14 +1127,14 @@ func TestMergeHttpHealthChecks(t *testing.T) {
{"unhealthy threshold - user configured - should keep", gceHcCheckIntervalSeconds, gceHcTimeoutSeconds, gceHcHealthyThreshold, gceHcUnhealthyThreshold + 1, gceHcCheckIntervalSeconds, gceHcTimeoutSeconds, gceHcHealthyThreshold, gceHcUnhealthyThreshold + 1}, {"unhealthy threshold - user configured - should keep", gceHcCheckIntervalSeconds, gceHcTimeoutSeconds, gceHcHealthyThreshold, gceHcUnhealthyThreshold + 1, gceHcCheckIntervalSeconds, gceHcTimeoutSeconds, gceHcHealthyThreshold, gceHcUnhealthyThreshold + 1},
} { } {
t.Run(tc.desc, func(t *testing.T) { t.Run(tc.desc, func(t *testing.T) {
wantHC := makeHttpHealthCheck("hc", "/", 12345) wantHC := makeHTTPHealthCheck("hc", "/", 12345)
hc := &compute.HttpHealthCheck{ hc := &compute.HttpHealthCheck{
CheckIntervalSec: tc.checkIntervalSec, CheckIntervalSec: tc.checkIntervalSec,
TimeoutSec: tc.timeoutSec, TimeoutSec: tc.timeoutSec,
HealthyThreshold: tc.healthyThreshold, HealthyThreshold: tc.healthyThreshold,
UnhealthyThreshold: tc.unhealthyThreshold, UnhealthyThreshold: tc.unhealthyThreshold,
} }
mergeHttpHealthChecks(hc, wantHC) mergeHTTPHealthChecks(hc, wantHC)
if wantHC.CheckIntervalSec != tc.wantCheckIntervalSec { if wantHC.CheckIntervalSec != tc.wantCheckIntervalSec {
t.Errorf("wantHC.CheckIntervalSec = %d; want %d", wantHC.CheckIntervalSec, tc.checkIntervalSec) t.Errorf("wantHC.CheckIntervalSec = %d; want %d", wantHC.CheckIntervalSec, tc.checkIntervalSec)
} }
@ -1172,13 +1172,13 @@ func TestNeedToUpdateHttpHealthChecks(t *testing.T) {
{"unhealthy threshold does not need update", func(hc *compute.HttpHealthCheck) { hc.UnhealthyThreshold = gceHcUnhealthyThreshold + 1 }, false}, {"unhealthy threshold does not need update", func(hc *compute.HttpHealthCheck) { hc.UnhealthyThreshold = gceHcUnhealthyThreshold + 1 }, false},
} { } {
t.Run(tc.desc, func(t *testing.T) { t.Run(tc.desc, func(t *testing.T) {
hc := makeHttpHealthCheck("hc", "/", 12345) hc := makeHTTPHealthCheck("hc", "/", 12345)
wantHC := makeHttpHealthCheck("hc", "/", 12345) wantHC := makeHTTPHealthCheck("hc", "/", 12345)
if tc.modifier != nil { if tc.modifier != nil {
tc.modifier(hc) tc.modifier(hc)
} }
if gotChanged := needToUpdateHttpHealthChecks(hc, wantHC); gotChanged != tc.wantChanged { if gotChanged := needToUpdateHTTPHealthChecks(hc, wantHC); gotChanged != tc.wantChanged {
t.Errorf("needToUpdateHttpHealthChecks(%#v, %#v) = %t; want changed = %t", hc, wantHC, gotChanged, tc.wantChanged) t.Errorf("needToUpdateHTTPHealthChecks(%#v, %#v) = %t; want changed = %t", hc, wantHC, gotChanged, tc.wantChanged)
} }
}) })
} }

178
pkg/cloudprovider/providers/gce/gce_loadbalancer_internal.go
View File

@ -35,21 +35,21 @@ const (
allInstances = "ALL" allInstances = "ALL"
) )
func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, svc *v1.Service, existingFwdRule *compute.ForwardingRule, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) { func (g *Cloud) ensureInternalLoadBalancer(clusterName, clusterID string, svc *v1.Service, existingFwdRule *compute.ForwardingRule, nodes []*v1.Node) (*v1.LoadBalancerStatus, error) {
nm := types.NamespacedName{Name: svc.Name, Namespace: svc.Namespace} nm := types.NamespacedName{Name: svc.Name, Namespace: svc.Namespace}
ports, protocol := getPortsAndProtocol(svc.Spec.Ports) ports, protocol := getPortsAndProtocol(svc.Spec.Ports)
if protocol != v1.ProtocolTCP && protocol != v1.ProtocolUDP { if protocol != v1.ProtocolTCP && protocol != v1.ProtocolUDP {
return nil, fmt.Errorf("Invalid protocol %s, only TCP and UDP are supported", string(protocol)) return nil, fmt.Errorf("Invalid protocol %s, only TCP and UDP are supported", string(protocol))
} }
scheme := cloud.SchemeInternal scheme := cloud.SchemeInternal
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, svc) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, svc)
sharedBackend := shareBackendService(svc) sharedBackend := shareBackendService(svc)
backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, sharedBackend, scheme, protocol, svc.Spec.SessionAffinity) backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, sharedBackend, scheme, protocol, svc.Spec.SessionAffinity)
backendServiceLink := gce.getBackendServiceLink(backendServiceName) backendServiceLink := g.getBackendServiceLink(backendServiceName)
// Ensure instance groups exist and nodes are assigned to groups // Ensure instance groups exist and nodes are assigned to groups
igName := makeInstanceGroupName(clusterID) igName := makeInstanceGroupName(clusterID)
igLinks, err := gce.ensureInternalInstanceGroups(igName, nodes) igLinks, err := g.ensureInternalInstanceGroups(igName, nodes)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -58,14 +58,14 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
var existingBackendService *compute.BackendService var existingBackendService *compute.BackendService
if existingFwdRule != nil && existingFwdRule.BackendService != "" { if existingFwdRule != nil && existingFwdRule.BackendService != "" {
existingBSName := getNameFromLink(existingFwdRule.BackendService) existingBSName := getNameFromLink(existingFwdRule.BackendService)
if existingBackendService, err = gce.GetRegionBackendService(existingBSName, gce.region); err != nil && !isNotFound(err) { if existingBackendService, err = g.GetRegionBackendService(existingBSName, g.region); err != nil && !isNotFound(err) {
return nil, err return nil, err
} }
} }
// Lock the sharedResourceLock to prevent any deletions of shared resources while assembling shared resources here // Lock the sharedResourceLock to prevent any deletions of shared resources while assembling shared resources here
gce.sharedResourceLock.Lock() g.sharedResourceLock.Lock()
defer gce.sharedResourceLock.Unlock() defer g.sharedResourceLock.Unlock()
// Ensure health check exists before creating the backend service. The health check is shared // Ensure health check exists before creating the backend service. The health check is shared
// if externalTrafficPolicy=Cluster. // if externalTrafficPolicy=Cluster.
@ -76,7 +76,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
// Service requires a special health check, retrieve the OnlyLocal port & path // Service requires a special health check, retrieve the OnlyLocal port & path
hcPath, hcPort = v1_service.GetServiceHealthCheckPathPort(svc) hcPath, hcPort = v1_service.GetServiceHealthCheckPathPort(svc)
} }
hc, err := gce.ensureInternalHealthCheck(hcName, nm, sharedHealthCheck, hcPath, hcPort) hc, err := g.ensureInternalHealthCheck(hcName, nm, sharedHealthCheck, hcPath, hcPort)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -88,7 +88,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
// If the ILB already exists, continue using the subnet that it's already using. // If the ILB already exists, continue using the subnet that it's already using.
// This is to support existing ILBs that were setup using the wrong subnet. // This is to support existing ILBs that were setup using the wrong subnet.
subnetworkURL := gce.SubnetworkURL() subnetworkURL := g.SubnetworkURL()
if existingFwdRule != nil && existingFwdRule.Subnetwork != "" { if existingFwdRule != nil && existingFwdRule.Subnetwork != "" {
// external LBs have an empty Subnetwork field. // external LBs have an empty Subnetwork field.
subnetworkURL = existingFwdRule.Subnetwork subnetworkURL = existingFwdRule.Subnetwork
@ -96,8 +96,8 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
var addrMgr *addressManager var addrMgr *addressManager
// If the network is not a legacy network, use the address manager // If the network is not a legacy network, use the address manager
if !gce.IsLegacyNetwork() { if !g.IsLegacyNetwork() {
addrMgr = newAddressManager(gce, nm.String(), gce.Region(), subnetworkURL, loadBalancerName, requestedIP, cloud.SchemeInternal) addrMgr = newAddressManager(g, nm.String(), g.Region(), subnetworkURL, loadBalancerName, requestedIP, cloud.SchemeInternal)
ipToUse, err = addrMgr.HoldAddress() ipToUse, err = addrMgr.HoldAddress()
if err != nil { if err != nil {
return nil, err return nil, err
@ -106,7 +106,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
} }
// Ensure firewall rules if necessary // Ensure firewall rules if necessary
if err = gce.ensureInternalFirewalls(loadBalancerName, ipToUse, clusterID, nm, svc, strconv.Itoa(int(hcPort)), sharedHealthCheck, nodes); err != nil { if err = g.ensureInternalFirewalls(loadBalancerName, ipToUse, clusterID, nm, svc, strconv.Itoa(int(hcPort)), sharedHealthCheck, nodes); err != nil {
return nil, err return nil, err
} }
@ -125,20 +125,20 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
if subnetworkURL != "" { if subnetworkURL != "" {
expectedFwdRule.Subnetwork = subnetworkURL expectedFwdRule.Subnetwork = subnetworkURL
} else { } else {
expectedFwdRule.Network = gce.networkURL expectedFwdRule.Network = g.networkURL
} }
fwdRuleDeleted := false fwdRuleDeleted := false
if existingFwdRule != nil && !fwdRuleEqual(existingFwdRule, expectedFwdRule) { if existingFwdRule != nil && !fwdRuleEqual(existingFwdRule, expectedFwdRule) {
glog.V(2).Infof("ensureInternalLoadBalancer(%v): deleting existing forwarding rule with IP address %v", loadBalancerName, existingFwdRule.IPAddress) glog.V(2).Infof("ensureInternalLoadBalancer(%v): deleting existing forwarding rule with IP address %v", loadBalancerName, existingFwdRule.IPAddress)
if err = ignoreNotFound(gce.DeleteRegionForwardingRule(loadBalancerName, gce.region)); err != nil { if err = ignoreNotFound(g.DeleteRegionForwardingRule(loadBalancerName, g.region)); err != nil {
return nil, err return nil, err
} }
fwdRuleDeleted = true fwdRuleDeleted = true
} }
bsDescription := makeBackendServiceDescription(nm, sharedBackend) bsDescription := makeBackendServiceDescription(nm, sharedBackend)
err = gce.ensureInternalBackendService(backendServiceName, bsDescription, svc.Spec.SessionAffinity, scheme, protocol, igLinks, hc.SelfLink) err = g.ensureInternalBackendService(backendServiceName, bsDescription, svc.Spec.SessionAffinity, scheme, protocol, igLinks, hc.SelfLink)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -146,7 +146,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
// If we previously deleted the forwarding rule or it never existed, finally create it. // If we previously deleted the forwarding rule or it never existed, finally create it.
if fwdRuleDeleted || existingFwdRule == nil { if fwdRuleDeleted || existingFwdRule == nil {
glog.V(2).Infof("ensureInternalLoadBalancer(%v): creating forwarding rule", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancer(%v): creating forwarding rule", loadBalancerName)
if err = gce.CreateRegionForwardingRule(expectedFwdRule, gce.region); err != nil { if err = g.CreateRegionForwardingRule(expectedFwdRule, g.region); err != nil {
return nil, err return nil, err
} }
glog.V(2).Infof("ensureInternalLoadBalancer(%v): created forwarding rule", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancer(%v): created forwarding rule", loadBalancerName)
@ -154,7 +154,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
// Delete the previous internal load balancer resources if necessary // Delete the previous internal load balancer resources if necessary
if existingBackendService != nil { if existingBackendService != nil {
gce.clearPreviousInternalResources(svc, loadBalancerName, existingBackendService, backendServiceName, hcName) g.clearPreviousInternalResources(svc, loadBalancerName, existingBackendService, backendServiceName, hcName)
} }
if addrMgr != nil { if addrMgr != nil {
@ -165,7 +165,7 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
} }
// Get the most recent forwarding rule for the address. // Get the most recent forwarding rule for the address.
updatedFwdRule, err := gce.GetRegionForwardingRule(loadBalancerName, gce.region) updatedFwdRule, err := g.GetRegionForwardingRule(loadBalancerName, g.region)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -175,11 +175,11 @@ func (gce *GCECloud) ensureInternalLoadBalancer(clusterName, clusterID string, s
return status, nil return status, nil
} }
func (gce *GCECloud) clearPreviousInternalResources(svc *v1.Service, loadBalancerName string, existingBackendService *compute.BackendService, expectedBSName, expectedHCName string) { func (g *Cloud) clearPreviousInternalResources(svc *v1.Service, loadBalancerName string, existingBackendService *compute.BackendService, expectedBSName, expectedHCName string) {
// If a new backend service was created, delete the old one. // If a new backend service was created, delete the old one.
if existingBackendService.Name != expectedBSName { if existingBackendService.Name != expectedBSName {
glog.V(2).Infof("clearPreviousInternalResources(%v): expected backend service %q does not match previous %q - deleting backend service", loadBalancerName, expectedBSName, existingBackendService.Name) glog.V(2).Infof("clearPreviousInternalResources(%v): expected backend service %q does not match previous %q - deleting backend service", loadBalancerName, expectedBSName, existingBackendService.Name)
if err := gce.teardownInternalBackendService(existingBackendService.Name); err != nil && !isNotFound(err) { if err := g.teardownInternalBackendService(existingBackendService.Name); err != nil && !isNotFound(err) {
glog.Warningf("clearPreviousInternalResources: could not delete old backend service: %v, err: %v", existingBackendService.Name, err) glog.Warningf("clearPreviousInternalResources: could not delete old backend service: %v, err: %v", existingBackendService.Name, err)
} }
} }
@ -189,7 +189,7 @@ func (gce *GCECloud) clearPreviousInternalResources(svc *v1.Service, loadBalance
existingHCName := getNameFromLink(existingBackendService.HealthChecks[0]) existingHCName := getNameFromLink(existingBackendService.HealthChecks[0])
if existingHCName != expectedHCName { if existingHCName != expectedHCName {
glog.V(2).Infof("clearPreviousInternalResources(%v): expected health check %q does not match previous %q - deleting health check", loadBalancerName, expectedHCName, existingHCName) glog.V(2).Infof("clearPreviousInternalResources(%v): expected health check %q does not match previous %q - deleting health check", loadBalancerName, expectedHCName, existingHCName)
if err := gce.teardownInternalHealthCheckAndFirewall(svc, existingHCName); err != nil { if err := g.teardownInternalHealthCheckAndFirewall(svc, existingHCName); err != nil {
glog.Warningf("clearPreviousInternalResources: could not delete existing healthcheck: %v, err: %v", existingHCName, err) glog.Warningf("clearPreviousInternalResources: could not delete existing healthcheck: %v, err: %v", existingHCName, err)
} }
} }
@ -200,12 +200,12 @@ func (gce *GCECloud) clearPreviousInternalResources(svc *v1.Service, loadBalance
// updateInternalLoadBalancer is called when the list of nodes has changed. Therefore, only the instance groups // updateInternalLoadBalancer is called when the list of nodes has changed. Therefore, only the instance groups
// and possibly the backend service need to be updated. // and possibly the backend service need to be updated.
func (gce *GCECloud) updateInternalLoadBalancer(clusterName, clusterID string, svc *v1.Service, nodes []*v1.Node) error { func (g *Cloud) updateInternalLoadBalancer(clusterName, clusterID string, svc *v1.Service, nodes []*v1.Node) error {
gce.sharedResourceLock.Lock() g.sharedResourceLock.Lock()
defer gce.sharedResourceLock.Unlock() defer g.sharedResourceLock.Unlock()
igName := makeInstanceGroupName(clusterID) igName := makeInstanceGroupName(clusterID)
igLinks, err := gce.ensureInternalInstanceGroups(igName, nodes) igLinks, err := g.ensureInternalInstanceGroups(igName, nodes)
if err != nil { if err != nil {
return err return err
} }
@ -213,41 +213,41 @@ func (gce *GCECloud) updateInternalLoadBalancer(clusterName, clusterID string, s
// Generate the backend service name // Generate the backend service name
_, protocol := getPortsAndProtocol(svc.Spec.Ports) _, protocol := getPortsAndProtocol(svc.Spec.Ports)
scheme := cloud.SchemeInternal scheme := cloud.SchemeInternal
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, svc) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, svc)
backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, shareBackendService(svc), scheme, protocol, svc.Spec.SessionAffinity) backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, shareBackendService(svc), scheme, protocol, svc.Spec.SessionAffinity)
// Ensure the backend service has the proper backend/instance-group links // Ensure the backend service has the proper backend/instance-group links
return gce.ensureInternalBackendServiceGroups(backendServiceName, igLinks) return g.ensureInternalBackendServiceGroups(backendServiceName, igLinks)
} }
func (gce *GCECloud) ensureInternalLoadBalancerDeleted(clusterName, clusterID string, svc *v1.Service) error { func (g *Cloud) ensureInternalLoadBalancerDeleted(clusterName, clusterID string, svc *v1.Service) error {
loadBalancerName := gce.GetLoadBalancerName(context.TODO(), clusterName, svc) loadBalancerName := g.GetLoadBalancerName(context.TODO(), clusterName, svc)
_, protocol := getPortsAndProtocol(svc.Spec.Ports) _, protocol := getPortsAndProtocol(svc.Spec.Ports)
scheme := cloud.SchemeInternal scheme := cloud.SchemeInternal
sharedBackend := shareBackendService(svc) sharedBackend := shareBackendService(svc)
sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(svc) sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(svc)
gce.sharedResourceLock.Lock() g.sharedResourceLock.Lock()
defer gce.sharedResourceLock.Unlock() defer g.sharedResourceLock.Unlock()
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): attempting delete of region internal address", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): attempting delete of region internal address", loadBalancerName)
ensureAddressDeleted(gce, loadBalancerName, gce.region) ensureAddressDeleted(g, loadBalancerName, g.region)
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting region internal forwarding rule", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting region internal forwarding rule", loadBalancerName)
if err := ignoreNotFound(gce.DeleteRegionForwardingRule(loadBalancerName, gce.region)); err != nil { if err := ignoreNotFound(g.DeleteRegionForwardingRule(loadBalancerName, g.region)); err != nil {
return err return err
} }
backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, sharedBackend, scheme, protocol, svc.Spec.SessionAffinity) backendServiceName := makeBackendServiceName(loadBalancerName, clusterID, sharedBackend, scheme, protocol, svc.Spec.SessionAffinity)
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting region backend service %v", loadBalancerName, backendServiceName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting region backend service %v", loadBalancerName, backendServiceName)
if err := gce.teardownInternalBackendService(backendServiceName); err != nil { if err := g.teardownInternalBackendService(backendServiceName); err != nil {
return err return err
} }
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting firewall for traffic", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting firewall for traffic", loadBalancerName)
if err := ignoreNotFound(gce.DeleteFirewall(loadBalancerName)); err != nil { if err := ignoreNotFound(g.DeleteFirewall(loadBalancerName)); err != nil {
if isForbidden(err) && gce.OnXPN() { if isForbidden(err) && g.OnXPN() {
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): could not delete traffic firewall on XPN cluster. Raising event.", loadBalancerName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): could not delete traffic firewall on XPN cluster. Raising event.", loadBalancerName)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudDeleteCmd(loadBalancerName, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudDeleteCmd(loadBalancerName, g.NetworkProjectID()))
} else { } else {
return err return err
} }
@ -255,21 +255,21 @@ func (gce *GCECloud) ensureInternalLoadBalancerDeleted(clusterName, clusterID st
hcName := makeHealthCheckName(loadBalancerName, clusterID, sharedHealthCheck) hcName := makeHealthCheckName(loadBalancerName, clusterID, sharedHealthCheck)
glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting health check %v and its firewall", loadBalancerName, hcName) glog.V(2).Infof("ensureInternalLoadBalancerDeleted(%v): deleting health check %v and its firewall", loadBalancerName, hcName)
if err := gce.teardownInternalHealthCheckAndFirewall(svc, hcName); err != nil { if err := g.teardownInternalHealthCheckAndFirewall(svc, hcName); err != nil {
return err return err
} }
// Try deleting instance groups - expect ResourceInuse error if needed by other LBs // Try deleting instance groups - expect ResourceInuse error if needed by other LBs
igName := makeInstanceGroupName(clusterID) igName := makeInstanceGroupName(clusterID)
if err := gce.ensureInternalInstanceGroupsDeleted(igName); err != nil && !isInUsedByError(err) { if err := g.ensureInternalInstanceGroupsDeleted(igName); err != nil && !isInUsedByError(err) {
return err return err
} }
return nil return nil
} }
func (gce *GCECloud) teardownInternalBackendService(bsName string) error { func (g *Cloud) teardownInternalBackendService(bsName string) error {
if err := gce.DeleteRegionBackendService(bsName, gce.region); err != nil { if err := g.DeleteRegionBackendService(bsName, g.region); err != nil {
if isNotFound(err) { if isNotFound(err) {
glog.V(2).Infof("teardownInternalBackendService(%v): backend service already deleted. err: %v", bsName, err) glog.V(2).Infof("teardownInternalBackendService(%v): backend service already deleted. err: %v", bsName, err)
return nil return nil
@ -284,8 +284,8 @@ func (gce *GCECloud) teardownInternalBackendService(bsName string) error {
return nil return nil
} }
func (gce *GCECloud) teardownInternalHealthCheckAndFirewall(svc *v1.Service, hcName string) error { func (g *Cloud) teardownInternalHealthCheckAndFirewall(svc *v1.Service, hcName string) error {
if err := gce.DeleteHealthCheck(hcName); err != nil { if err := g.DeleteHealthCheck(hcName); err != nil {
if isNotFound(err) { if isNotFound(err) {
glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): health check does not exist.", hcName) glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): health check does not exist.", hcName)
// Purposely do not early return - double check the firewall does not exist // Purposely do not early return - double check the firewall does not exist
@ -299,10 +299,10 @@ func (gce *GCECloud) teardownInternalHealthCheckAndFirewall(svc *v1.Service, hcN
glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): health check deleted", hcName) glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): health check deleted", hcName)
hcFirewallName := makeHealthCheckFirewallNameFromHC(hcName) hcFirewallName := makeHealthCheckFirewallNameFromHC(hcName)
if err := ignoreNotFound(gce.DeleteFirewall(hcFirewallName)); err != nil { if err := ignoreNotFound(g.DeleteFirewall(hcFirewallName)); err != nil {
if isForbidden(err) && gce.OnXPN() { if isForbidden(err) && g.OnXPN() {
glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): could not delete health check traffic firewall on XPN cluster. Raising Event.", hcName) glog.V(2).Infof("teardownInternalHealthCheckAndFirewall(%v): could not delete health check traffic firewall on XPN cluster. Raising Event.", hcName)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudDeleteCmd(hcFirewallName, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudDeleteCmd(hcFirewallName, g.NetworkProjectID()))
return nil return nil
} }
@ -312,14 +312,14 @@ func (gce *GCECloud) teardownInternalHealthCheckAndFirewall(svc *v1.Service, hcN
return nil return nil
} }
func (gce *GCECloud) ensureInternalFirewall(svc *v1.Service, fwName, fwDesc string, sourceRanges []string, ports []string, protocol v1.Protocol, nodes []*v1.Node) error { func (g *Cloud) ensureInternalFirewall(svc *v1.Service, fwName, fwDesc string, sourceRanges []string, ports []string, protocol v1.Protocol, nodes []*v1.Node) error {
glog.V(2).Infof("ensureInternalFirewall(%v): checking existing firewall", fwName) glog.V(2).Infof("ensureInternalFirewall(%v): checking existing firewall", fwName)
targetTags, err := gce.GetNodeTags(nodeNames(nodes)) targetTags, err := g.GetNodeTags(nodeNames(nodes))
if err != nil { if err != nil {
return err return err
} }
existingFirewall, err := gce.GetFirewall(fwName) existingFirewall, err := g.GetFirewall(fwName)
if err != nil && !isNotFound(err) { if err != nil && !isNotFound(err) {
return err return err
} }
@ -327,7 +327,7 @@ func (gce *GCECloud) ensureInternalFirewall(svc *v1.Service, fwName, fwDesc stri
expectedFirewall := &compute.Firewall{ expectedFirewall := &compute.Firewall{
Name: fwName, Name: fwName,
Description: fwDesc, Description: fwDesc,
Network: gce.networkURL, Network: g.networkURL,
SourceRanges: sourceRanges, SourceRanges: sourceRanges,
TargetTags: targetTags, TargetTags: targetTags,
Allowed: []*compute.FirewallAllowed{ Allowed: []*compute.FirewallAllowed{
@ -340,10 +340,10 @@ func (gce *GCECloud) ensureInternalFirewall(svc *v1.Service, fwName, fwDesc stri
if existingFirewall == nil { if existingFirewall == nil {
glog.V(2).Infof("ensureInternalFirewall(%v): creating firewall", fwName) glog.V(2).Infof("ensureInternalFirewall(%v): creating firewall", fwName)
err = gce.CreateFirewall(expectedFirewall) err = g.CreateFirewall(expectedFirewall)
if err != nil && isForbidden(err) && gce.OnXPN() { if err != nil && isForbidden(err) && g.OnXPN() {
glog.V(2).Infof("ensureInternalFirewall(%v): do not have permission to create firewall rule (on XPN). Raising event.", fwName) glog.V(2).Infof("ensureInternalFirewall(%v): do not have permission to create firewall rule (on XPN). Raising event.", fwName)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudCreateCmd(expectedFirewall, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudCreateCmd(expectedFirewall, g.NetworkProjectID()))
return nil return nil
} }
return err return err
@ -354,16 +354,16 @@ func (gce *GCECloud) ensureInternalFirewall(svc *v1.Service, fwName, fwDesc stri
} }
glog.V(2).Infof("ensureInternalFirewall(%v): updating firewall", fwName) glog.V(2).Infof("ensureInternalFirewall(%v): updating firewall", fwName)
err = gce.UpdateFirewall(expectedFirewall) err = g.UpdateFirewall(expectedFirewall)
if err != nil && isForbidden(err) && gce.OnXPN() { if err != nil && isForbidden(err) && g.OnXPN() {
glog.V(2).Infof("ensureInternalFirewall(%v): do not have permission to update firewall rule (on XPN). Raising event.", fwName) glog.V(2).Infof("ensureInternalFirewall(%v): do not have permission to update firewall rule (on XPN). Raising event.", fwName)
gce.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudUpdateCmd(expectedFirewall, gce.NetworkProjectID())) g.raiseFirewallChangeNeededEvent(svc, FirewallToGCloudUpdateCmd(expectedFirewall, g.NetworkProjectID()))
return nil return nil
} }
return err return err
} }
func (gce *GCECloud) ensureInternalFirewalls(loadBalancerName, ipAddress, clusterID string, nm types.NamespacedName, svc *v1.Service, healthCheckPort string, sharedHealthCheck bool, nodes []*v1.Node) error { func (g *Cloud) ensureInternalFirewalls(loadBalancerName, ipAddress, clusterID string, nm types.NamespacedName, svc *v1.Service, healthCheckPort string, sharedHealthCheck bool, nodes []*v1.Node) error {
// First firewall is for ingress traffic // First firewall is for ingress traffic
fwDesc := makeFirewallDescription(nm.String(), ipAddress) fwDesc := makeFirewallDescription(nm.String(), ipAddress)
ports, protocol := getPortsAndProtocol(svc.Spec.Ports) ports, protocol := getPortsAndProtocol(svc.Spec.Ports)
@ -371,7 +371,7 @@ func (gce *GCECloud) ensureInternalFirewalls(loadBalancerName, ipAddress, cluste
if err != nil { if err != nil {
return err return err
} }
err = gce.ensureInternalFirewall(svc, loadBalancerName, fwDesc, sourceRanges.StringSlice(), ports, protocol, nodes) err = g.ensureInternalFirewall(svc, loadBalancerName, fwDesc, sourceRanges.StringSlice(), ports, protocol, nodes)
if err != nil { if err != nil {
return err return err
} }
@ -379,24 +379,24 @@ func (gce *GCECloud) ensureInternalFirewalls(loadBalancerName, ipAddress, cluste
// Second firewall is for health checking nodes / services // Second firewall is for health checking nodes / services
fwHCName := makeHealthCheckFirewallName(loadBalancerName, clusterID, sharedHealthCheck) fwHCName := makeHealthCheckFirewallName(loadBalancerName, clusterID, sharedHealthCheck)
hcSrcRanges := LoadBalancerSrcRanges() hcSrcRanges := LoadBalancerSrcRanges()
return gce.ensureInternalFirewall(svc, fwHCName, "", hcSrcRanges, []string{healthCheckPort}, v1.ProtocolTCP, nodes) return g.ensureInternalFirewall(svc, fwHCName, "", hcSrcRanges, []string{healthCheckPort}, v1.ProtocolTCP, nodes)
} }
func (gce *GCECloud) ensureInternalHealthCheck(name string, svcName types.NamespacedName, shared bool, path string, port int32) (*compute.HealthCheck, error) { func (g *Cloud) ensureInternalHealthCheck(name string, svcName types.NamespacedName, shared bool, path string, port int32) (*compute.HealthCheck, error) {
glog.V(2).Infof("ensureInternalHealthCheck(%v, %v, %v): checking existing health check", name, path, port) glog.V(2).Infof("ensureInternalHealthCheck(%v, %v, %v): checking existing health check", name, path, port)
expectedHC := newInternalLBHealthCheck(name, svcName, shared, path, port) expectedHC := newInternalLBHealthCheck(name, svcName, shared, path, port)
hc, err := gce.GetHealthCheck(name) hc, err := g.GetHealthCheck(name)
if err != nil && !isNotFound(err) { if err != nil && !isNotFound(err) {
return nil, err return nil, err
} }
if hc == nil { if hc == nil {
glog.V(2).Infof("ensureInternalHealthCheck: did not find health check %v, creating one with port %v path %v", name, port, path) glog.V(2).Infof("ensureInternalHealthCheck: did not find health check %v, creating one with port %v path %v", name, port, path)
if err = gce.CreateHealthCheck(expectedHC); err != nil { if err = g.CreateHealthCheck(expectedHC); err != nil {
return nil, err return nil, err
} }
hc, err = gce.GetHealthCheck(name) hc, err = g.GetHealthCheck(name)
if err != nil { if err != nil {
glog.Errorf("Failed to get http health check %v", err) glog.Errorf("Failed to get http health check %v", err)
return nil, err return nil, err
@ -408,12 +408,12 @@ func (gce *GCECloud) ensureInternalHealthCheck(name string, svcName types.Namesp
if needToUpdateHealthChecks(hc, expectedHC) { if needToUpdateHealthChecks(hc, expectedHC) {
glog.V(2).Infof("ensureInternalHealthCheck: health check %v exists but parameters have drifted - updating...", name) glog.V(2).Infof("ensureInternalHealthCheck: health check %v exists but parameters have drifted - updating...", name)
expectedHC = mergeHealthChecks(hc, expectedHC) expectedHC = mergeHealthChecks(hc, expectedHC)
if err := gce.UpdateHealthCheck(expectedHC); err != nil { if err := g.UpdateHealthCheck(expectedHC); err != nil {
glog.Warningf("Failed to reconcile http health check %v parameters", name) glog.Warningf("Failed to reconcile http health check %v parameters", name)
return nil, err return nil, err
} }
glog.V(2).Infof("ensureInternalHealthCheck: corrected health check %v parameters successful", name) glog.V(2).Infof("ensureInternalHealthCheck: corrected health check %v parameters successful", name)
hc, err = gce.GetHealthCheck(name) hc, err = g.GetHealthCheck(name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -421,9 +421,9 @@ func (gce *GCECloud) ensureInternalHealthCheck(name string, svcName types.Namesp
return hc, nil return hc, nil
} }
func (gce *GCECloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.Node) (string, error) { func (g *Cloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.Node) (string, error) {
glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): checking group that it contains %v nodes", name, zone, len(nodes)) glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): checking group that it contains %v nodes", name, zone, len(nodes))
ig, err := gce.GetInstanceGroup(name, zone) ig, err := g.GetInstanceGroup(name, zone)
if err != nil && !isNotFound(err) { if err != nil && !isNotFound(err) {
return "", err return "", err
} }
@ -437,16 +437,16 @@ func (gce *GCECloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.
if ig == nil { if ig == nil {
glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): creating instance group", name, zone) glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): creating instance group", name, zone)
newIG := &compute.InstanceGroup{Name: name} newIG := &compute.InstanceGroup{Name: name}
if err = gce.CreateInstanceGroup(newIG, zone); err != nil { if err = g.CreateInstanceGroup(newIG, zone); err != nil {
return "", err return "", err
} }
ig, err = gce.GetInstanceGroup(name, zone) ig, err = g.GetInstanceGroup(name, zone)
if err != nil { if err != nil {
return "", err return "", err
} }
} else { } else {
instances, err := gce.ListInstancesInInstanceGroup(name, zone, allInstances) instances, err := g.ListInstancesInInstanceGroup(name, zone, allInstances)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -462,17 +462,17 @@ func (gce *GCECloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.
if len(removeNodes) != 0 { if len(removeNodes) != 0 {
glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): removing nodes: %v", name, zone, removeNodes) glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): removing nodes: %v", name, zone, removeNodes)
instanceRefs := gce.ToInstanceReferences(zone, removeNodes) instanceRefs := g.ToInstanceReferences(zone, removeNodes)
// Possible we'll receive 404's here if the instance was deleted before getting to this point. // Possible we'll receive 404's here if the instance was deleted before getting to this point.
if err = gce.RemoveInstancesFromInstanceGroup(name, zone, instanceRefs); err != nil && !isNotFound(err) { if err = g.RemoveInstancesFromInstanceGroup(name, zone, instanceRefs); err != nil && !isNotFound(err) {
return "", err return "", err
} }
} }
if len(addNodes) != 0 { if len(addNodes) != 0 {
glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): adding nodes: %v", name, zone, addNodes) glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): adding nodes: %v", name, zone, addNodes)
instanceRefs := gce.ToInstanceReferences(zone, addNodes) instanceRefs := g.ToInstanceReferences(zone, addNodes)
if err = gce.AddInstancesToInstanceGroup(name, zone, instanceRefs); err != nil { if err = g.AddInstancesToInstanceGroup(name, zone, instanceRefs); err != nil {
return "", err return "", err
} }
} }
@ -482,12 +482,12 @@ func (gce *GCECloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.
// ensureInternalInstanceGroups generates an unmanaged instance group for every zone // ensureInternalInstanceGroups generates an unmanaged instance group for every zone
// where a K8s node exists. It also ensures that each node belongs to an instance group // where a K8s node exists. It also ensures that each node belongs to an instance group
func (gce *GCECloud) ensureInternalInstanceGroups(name string, nodes []*v1.Node) ([]string, error) { func (g *Cloud) ensureInternalInstanceGroups(name string, nodes []*v1.Node) ([]string, error) {
zonedNodes := splitNodesByZone(nodes) zonedNodes := splitNodesByZone(nodes)
glog.V(2).Infof("ensureInternalInstanceGroups(%v): %d nodes over %d zones in region %v", name, len(nodes), len(zonedNodes), gce.region) glog.V(2).Infof("ensureInternalInstanceGroups(%v): %d nodes over %d zones in region %v", name, len(nodes), len(zonedNodes), g.region)
var igLinks []string var igLinks []string
for zone, nodes := range zonedNodes { for zone, nodes := range zonedNodes {
igLink, err := gce.ensureInternalInstanceGroup(name, zone, nodes) igLink, err := g.ensureInternalInstanceGroup(name, zone, nodes)
if err != nil { if err != nil {
return []string{}, err return []string{}, err
} }
@ -497,25 +497,25 @@ func (gce *GCECloud) ensureInternalInstanceGroups(name string, nodes []*v1.Node)
return igLinks, nil return igLinks, nil
} }
func (gce *GCECloud) ensureInternalInstanceGroupsDeleted(name string) error { func (g *Cloud) ensureInternalInstanceGroupsDeleted(name string) error {
// List of nodes isn't available here - fetch all zones in region and try deleting this cluster's ig // List of nodes isn't available here - fetch all zones in region and try deleting this cluster's ig
zones, err := gce.ListZonesInRegion(gce.region) zones, err := g.ListZonesInRegion(g.region)
if err != nil { if err != nil {
return err return err
} }
glog.V(2).Infof("ensureInternalInstanceGroupsDeleted(%v): attempting delete instance group in all %d zones", name, len(zones)) glog.V(2).Infof("ensureInternalInstanceGroupsDeleted(%v): attempting delete instance group in all %d zones", name, len(zones))
for _, z := range zones { for _, z := range zones {
if err := gce.DeleteInstanceGroup(name, z.Name); err != nil && !isNotFoundOrInUse(err) { if err := g.DeleteInstanceGroup(name, z.Name); err != nil && !isNotFoundOrInUse(err) {
return err return err
} }
} }
return nil return nil
} }
func (gce *GCECloud) ensureInternalBackendService(name, description string, affinityType v1.ServiceAffinity, scheme cloud.LbScheme, protocol v1.Protocol, igLinks []string, hcLink string) error { func (g *Cloud) ensureInternalBackendService(name, description string, affinityType v1.ServiceAffinity, scheme cloud.LbScheme, protocol v1.Protocol, igLinks []string, hcLink string) error {
glog.V(2).Infof("ensureInternalBackendService(%v, %v, %v): checking existing backend service with %d groups", name, scheme, protocol, len(igLinks)) glog.V(2).Infof("ensureInternalBackendService(%v, %v, %v): checking existing backend service with %d groups", name, scheme, protocol, len(igLinks))
bs, err := gce.GetRegionBackendService(name, gce.region) bs, err := g.GetRegionBackendService(name, g.region)
if err != nil && !isNotFound(err) { if err != nil && !isNotFound(err) {
return err return err
} }
@ -534,7 +534,7 @@ func (gce *GCECloud) ensureInternalBackendService(name, description string, affi
// Create backend service if none was found // Create backend service if none was found
if bs == nil { if bs == nil {
glog.V(2).Infof("ensureInternalBackendService: creating backend service %v", name) glog.V(2).Infof("ensureInternalBackendService: creating backend service %v", name)
err := gce.CreateRegionBackendService(expectedBS, gce.region) err := g.CreateRegionBackendService(expectedBS, g.region)
if err != nil { if err != nil {
return err return err
} }
@ -549,7 +549,7 @@ func (gce *GCECloud) ensureInternalBackendService(name, description string, affi
glog.V(2).Infof("ensureInternalBackendService: updating backend service %v", name) glog.V(2).Infof("ensureInternalBackendService: updating backend service %v", name)
// Set fingerprint for optimistic locking // Set fingerprint for optimistic locking
expectedBS.Fingerprint = bs.Fingerprint expectedBS.Fingerprint = bs.Fingerprint
if err := gce.UpdateRegionBackendService(expectedBS, gce.region); err != nil { if err := g.UpdateRegionBackendService(expectedBS, g.region); err != nil {
return err return err
} }
glog.V(2).Infof("ensureInternalBackendService: updated backend service %v successfully", name) glog.V(2).Infof("ensureInternalBackendService: updated backend service %v successfully", name)
@ -557,9 +557,9 @@ func (gce *GCECloud) ensureInternalBackendService(name, description string, affi
} }
// ensureInternalBackendServiceGroups updates backend services if their list of backend instance groups is incorrect. // ensureInternalBackendServiceGroups updates backend services if their list of backend instance groups is incorrect.
func (gce *GCECloud) ensureInternalBackendServiceGroups(name string, igLinks []string) error { func (g *Cloud) ensureInternalBackendServiceGroups(name string, igLinks []string) error {
glog.V(2).Infof("ensureInternalBackendServiceGroups(%v): checking existing backend service's groups", name) glog.V(2).Infof("ensureInternalBackendServiceGroups(%v): checking existing backend service's groups", name)
bs, err := gce.GetRegionBackendService(name, gce.region) bs, err := g.GetRegionBackendService(name, g.region)
if err != nil { if err != nil {
return err return err
} }
@ -573,7 +573,7 @@ func (gce *GCECloud) ensureInternalBackendServiceGroups(name string, igLinks []s
bs.Backends = backends bs.Backends = backends
glog.V(2).Infof("ensureInternalBackendServiceGroups: updating backend service %v", name) glog.V(2).Infof("ensureInternalBackendServiceGroups: updating backend service %v", name)
if err := gce.UpdateRegionBackendService(bs, gce.region); err != nil { if err := g.UpdateRegionBackendService(bs, g.region); err != nil {
return err return err
} }
glog.V(2).Infof("ensureInternalBackendServiceGroups: updated backend service %v successfully", name) glog.V(2).Infof("ensureInternalBackendServiceGroups: updated backend service %v successfully", name)
@ -707,8 +707,8 @@ func getPortsAndProtocol(svcPorts []v1.ServicePort) (ports []string, protocol v1
return ports, protocol return ports, protocol
} }
func (gce *GCECloud) getBackendServiceLink(name string) string { func (g *Cloud) getBackendServiceLink(name string) string {
return gce.service.BasePath + strings.Join([]string{gce.projectID, "regions", gce.region, "backendServices", name}, "/") return g.service.BasePath + strings.Join([]string{g.projectID, "regions", g.region, "backendServices", name}, "/")
} }
func getNameFromLink(link string) string { func getNameFromLink(link string) string {

36
pkg/cloudprovider/providers/gce/gce_loadbalancer_internal_test.go
View File

@ -34,7 +34,7 @@ import (
"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/mock" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/mock"
) )
func createInternalLoadBalancer(gce *GCECloud, svc *v1.Service, existingFwdRule *compute.ForwardingRule, nodeNames []string, clusterName, clusterID, zoneName string) (*v1.LoadBalancerStatus, error) { func createInternalLoadBalancer(gce *Cloud, svc *v1.Service, existingFwdRule *compute.ForwardingRule, nodeNames []string, clusterName, clusterID, zoneName string) (*v1.LoadBalancerStatus, error) {
nodes, err := createAndInsertNodes(gce, nodeNames, zoneName) nodes, err := createAndInsertNodes(gce, nodeNames, zoneName)
if err != nil { if err != nil {
return nil, err return nil, err
@ -335,19 +335,19 @@ func TestUpdateInternalLoadBalancerBackendServices(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
// Check that the new BackendService has the correct attributes // Check that the new BackendService has the correct attributes
url_base := fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s", vals.ProjectID) urlBase := fmt.Sprintf("https://www.googleapis.com/compute/v1/projects/%s", vals.ProjectID)
assert.NotEqual(t, existingBS, bs) assert.NotEqual(t, existingBS, bs)
assert.Equal( assert.Equal(
t, t,
bs.SelfLink, bs.SelfLink,
fmt.Sprintf("%s/regions/%s/backendServices/%s", url_base, vals.Region, bs.Name), fmt.Sprintf("%s/regions/%s/backendServices/%s", urlBase, vals.Region, bs.Name),
) )
assert.Equal(t, bs.Description, `{"kubernetes.io/service-name":"/"}`) assert.Equal(t, bs.Description, `{"kubernetes.io/service-name":"/"}`)
assert.Equal( assert.Equal(
t, t,
bs.HealthChecks, bs.HealthChecks,
[]string{fmt.Sprintf("%s/global/healthChecks/k8s-%s-node", url_base, vals.ClusterID)}, []string{fmt.Sprintf("%s/global/healthChecks/k8s-%s-node", urlBase, vals.ClusterID)},
) )
} }
@ -487,16 +487,16 @@ func TestClearPreviousInternalResources(t *testing.T) {
c := gce.c.(*cloud.MockGCE) c := gce.c.(*cloud.MockGCE)
require.NoError(t, err) require.NoError(t, err)
hc_1, err := gce.ensureInternalHealthCheck("hc_1", nm, false, "healthz", 12345) hc1, err := gce.ensureInternalHealthCheck("hc1", nm, false, "healthz", 12345)
require.NoError(t, err) require.NoError(t, err)
hc_2, err := gce.ensureInternalHealthCheck("hc_2", nm, false, "healthz", 12346) hc2, err := gce.ensureInternalHealthCheck("hc2", nm, false, "healthz", 12346)
require.NoError(t, err) require.NoError(t, err)
err = gce.ensureInternalBackendService(svc.ObjectMeta.Name, "", svc.Spec.SessionAffinity, cloud.SchemeInternal, v1.ProtocolTCP, []string{}, "") err = gce.ensureInternalBackendService(svc.ObjectMeta.Name, "", svc.Spec.SessionAffinity, cloud.SchemeInternal, v1.ProtocolTCP, []string{}, "")
require.NoError(t, err) require.NoError(t, err)
backendSvc, err := gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region) backendSvc, err := gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region)
backendSvc.HealthChecks = []string{hc_1.SelfLink, hc_2.SelfLink} backendSvc.HealthChecks = []string{hc1.SelfLink, hc2.SelfLink}
c.MockRegionBackendServices.DeleteHook = mock.DeleteRegionBackendServicesErrHook c.MockRegionBackendServices.DeleteHook = mock.DeleteRegionBackendServicesErrHook
c.MockHealthChecks.DeleteHook = mock.DeleteHealthChecksInternalErrHook c.MockHealthChecks.DeleteHook = mock.DeleteHealthChecksInternalErrHook
@ -505,27 +505,27 @@ func TestClearPreviousInternalResources(t *testing.T) {
backendSvc, err = gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region) backendSvc, err = gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region)
assert.NoError(t, err) assert.NoError(t, err)
assert.NotNil(t, backendSvc, "BackendService should not be deleted when api is mocked out.") assert.NotNil(t, backendSvc, "BackendService should not be deleted when api is mocked out.")
hc_1, err = gce.GetHealthCheck("hc_1") hc1, err = gce.GetHealthCheck("hc1")
assert.NoError(t, err) assert.NoError(t, err)
assert.NotNil(t, hc_1, "HealthCheck should not be deleted when there are more than one healthcheck attached.") assert.NotNil(t, hc1, "HealthCheck should not be deleted when there are more than one healthcheck attached.")
hc_2, err = gce.GetHealthCheck("hc_2") hc2, err = gce.GetHealthCheck("hc2")
assert.NoError(t, err) assert.NoError(t, err)
assert.NotNil(t, hc_2, "HealthCheck should not be deleted when there are more than one healthcheck attached.") assert.NotNil(t, hc2, "HealthCheck should not be deleted when there are more than one healthcheck attached.")
c.MockRegionBackendServices.DeleteHook = mock.DeleteRegionBackendServicesInUseErrHook c.MockRegionBackendServices.DeleteHook = mock.DeleteRegionBackendServicesInUseErrHook
backendSvc.HealthChecks = []string{hc_1.SelfLink} backendSvc.HealthChecks = []string{hc1.SelfLink}
gce.clearPreviousInternalResources(svc, loadBalancerName, backendSvc, "expectedBSName", "expectedHCName") gce.clearPreviousInternalResources(svc, loadBalancerName, backendSvc, "expectedBSName", "expectedHCName")
hc_1, err = gce.GetHealthCheck("hc_1") hc1, err = gce.GetHealthCheck("hc1")
assert.NoError(t, err) assert.NoError(t, err)
assert.NotNil(t, hc_1, "HealthCheck should not be deleted when api is mocked out.") assert.NotNil(t, hc1, "HealthCheck should not be deleted when api is mocked out.")
c.MockHealthChecks.DeleteHook = mock.DeleteHealthChecksInuseErrHook c.MockHealthChecks.DeleteHook = mock.DeleteHealthChecksInuseErrHook
gce.clearPreviousInternalResources(svc, loadBalancerName, backendSvc, "expectedBSName", "expectedHCName") gce.clearPreviousInternalResources(svc, loadBalancerName, backendSvc, "expectedBSName", "expectedHCName")
hc_1, err = gce.GetHealthCheck("hc_1") hc1, err = gce.GetHealthCheck("hc1")
assert.NoError(t, err) assert.NoError(t, err)
assert.NotNil(t, hc_1, "HealthCheck should not be deleted when api is mocked out.") assert.NotNil(t, hc1, "HealthCheck should not be deleted when api is mocked out.")
c.MockRegionBackendServices.DeleteHook = nil c.MockRegionBackendServices.DeleteHook = nil
c.MockHealthChecks.DeleteHook = nil c.MockHealthChecks.DeleteHook = nil
@ -534,9 +534,9 @@ func TestClearPreviousInternalResources(t *testing.T) {
backendSvc, err = gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region) backendSvc, err = gce.GetRegionBackendService(svc.ObjectMeta.Name, gce.region)
assert.Error(t, err) assert.Error(t, err)
assert.Nil(t, backendSvc, "BackendService should be deleted.") assert.Nil(t, backendSvc, "BackendService should be deleted.")
hc_1, err = gce.GetHealthCheck("hc_1") hc1, err = gce.GetHealthCheck("hc1")
assert.Error(t, err) assert.Error(t, err)
assert.Nil(t, hc_1, "HealthCheck should be deleted.") assert.Nil(t, hc1, "HealthCheck should be deleted.")
} }
func TestEnsureInternalFirewallSucceedsOnXPN(t *testing.T) { func TestEnsureInternalFirewallSucceedsOnXPN(t *testing.T) {

14
pkg/cloudprovider/providers/gce/gce_loadbalancer_utils_test.go
View File

@ -67,7 +67,7 @@ var (
FilewallChangeMsg = fmt.Sprintf("%s %s %s", v1.EventTypeNormal, eventReasonManualChange, eventMsgFirewallChange) FilewallChangeMsg = fmt.Sprintf("%s %s %s", v1.EventTypeNormal, eventReasonManualChange, eventMsgFirewallChange)
) )
func createAndInsertNodes(gce *GCECloud, nodeNames []string, zoneName string) ([]*v1.Node, error) { func createAndInsertNodes(gce *Cloud, nodeNames []string, zoneName string) ([]*v1.Node, error) {
nodes := []*v1.Node{} nodes := []*v1.Node{}
for _, name := range nodeNames { for _, name := range nodeNames {
@ -116,7 +116,7 @@ func createAndInsertNodes(gce *GCECloud, nodeNames []string, zoneName string) ([
return nodes, nil return nodes, nil
} }
func assertExternalLbResources(t *testing.T, gce *GCECloud, apiService *v1.Service, vals TestClusterValues, nodeNames []string) { func assertExternalLbResources(t *testing.T, gce *Cloud, apiService *v1.Service, vals TestClusterValues, nodeNames []string) {
lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService) lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService)
hcName := MakeNodesHealthCheckName(vals.ClusterID) hcName := MakeNodesHealthCheckName(vals.ClusterID)
@ -141,7 +141,7 @@ func assertExternalLbResources(t *testing.T, gce *GCECloud, apiService *v1.Servi
assert.Equal(t, 1, len(pool.Instances)) assert.Equal(t, 1, len(pool.Instances))
// Check that HealthCheck is created // Check that HealthCheck is created
healthcheck, err := gce.GetHttpHealthCheck(hcName) healthcheck, err := gce.GetHTTPHealthCheck(hcName)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, hcName, healthcheck.Name) assert.Equal(t, hcName, healthcheck.Name)
@ -153,7 +153,7 @@ func assertExternalLbResources(t *testing.T, gce *GCECloud, apiService *v1.Servi
assert.Equal(t, "123-123", fwdRule.PortRange) assert.Equal(t, "123-123", fwdRule.PortRange)
} }
func assertExternalLbResourcesDeleted(t *testing.T, gce *GCECloud, apiService *v1.Service, vals TestClusterValues, firewallsDeleted bool) { func assertExternalLbResourcesDeleted(t *testing.T, gce *Cloud, apiService *v1.Service, vals TestClusterValues, firewallsDeleted bool) {
lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService) lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService)
hcName := MakeNodesHealthCheckName(vals.ClusterID) hcName := MakeNodesHealthCheckName(vals.ClusterID)
@ -182,13 +182,13 @@ func assertExternalLbResourcesDeleted(t *testing.T, gce *GCECloud, apiService *v
assert.Nil(t, pool) assert.Nil(t, pool)
// Check that HealthCheck is deleted // Check that HealthCheck is deleted
healthcheck, err := gce.GetHttpHealthCheck(hcName) healthcheck, err := gce.GetHTTPHealthCheck(hcName)
require.Error(t, err) require.Error(t, err)
assert.Nil(t, healthcheck) assert.Nil(t, healthcheck)
} }
func assertInternalLbResources(t *testing.T, gce *GCECloud, apiService *v1.Service, vals TestClusterValues, nodeNames []string) { func assertInternalLbResources(t *testing.T, gce *Cloud, apiService *v1.Service, vals TestClusterValues, nodeNames []string) {
lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService) lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService)
// Check that Instance Group is created // Check that Instance Group is created
@ -241,7 +241,7 @@ func assertInternalLbResources(t *testing.T, gce *GCECloud, apiService *v1.Servi
assert.Equal(t, gce.NetworkURL(), fwdRule.Subnetwork) assert.Equal(t, gce.NetworkURL(), fwdRule.Subnetwork)
} }
func assertInternalLbResourcesDeleted(t *testing.T, gce *GCECloud, apiService *v1.Service, vals TestClusterValues, firewallsDeleted bool) { func assertInternalLbResourcesDeleted(t *testing.T, gce *Cloud, apiService *v1.Service, vals TestClusterValues, firewallsDeleted bool) {
lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService) lbName := gce.GetLoadBalancerName(context.TODO(), "", apiService)
sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(apiService) sharedHealthCheck := !v1_service.RequestsOnlyLocalTraffic(apiService)
hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck) hcName := makeHealthCheckName(lbName, vals.ClusterID, sharedHealthCheck)

43
pkg/cloudprovider/providers/gce/gce_networkendpointgroup.go
View File

@ -27,40 +27,38 @@ import (
"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
) )
const (
NEGIPPortNetworkEndpointType = "GCE_VM_IP_PORT"
)
func newNetworkEndpointGroupMetricContext(request string, zone string) *metricContext { func newNetworkEndpointGroupMetricContext(request string, zone string) *metricContext {
return newGenericMetricContext("networkendpointgroup_", request, unusedMetricLabel, zone, computeBetaVersion) return newGenericMetricContext("networkendpointgroup_", request, unusedMetricLabel, zone, computeBetaVersion)
} }
func (gce *GCECloud) GetNetworkEndpointGroup(name string, zone string) (*computebeta.NetworkEndpointGroup, error) { // GetNetworkEndpointGroup returns the collection of network endpoints for the name in zone
func (g *Cloud) GetNetworkEndpointGroup(name string, zone string) (*computebeta.NetworkEndpointGroup, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newNetworkEndpointGroupMetricContext("get", zone) mc := newNetworkEndpointGroupMetricContext("get", zone)
v, err := gce.c.BetaNetworkEndpointGroups().Get(ctx, meta.ZonalKey(name, zone)) v, err := g.c.BetaNetworkEndpointGroups().Get(ctx, meta.ZonalKey(name, zone))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
func (gce *GCECloud) ListNetworkEndpointGroup(zone string) ([]*computebeta.NetworkEndpointGroup, error) { // ListNetworkEndpointGroup returns the collection of network endpoints for the zone
func (g *Cloud) ListNetworkEndpointGroup(zone string) ([]*computebeta.NetworkEndpointGroup, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newNetworkEndpointGroupMetricContext("list", zone) mc := newNetworkEndpointGroupMetricContext("list", zone)
negs, err := gce.c.BetaNetworkEndpointGroups().List(ctx, zone, filter.None) negs, err := g.c.BetaNetworkEndpointGroups().List(ctx, zone, filter.None)
return negs, mc.Observe(err) return negs, mc.Observe(err)
} }
// AggregatedListNetworkEndpointGroup returns a map of zone -> endpoint group. // AggregatedListNetworkEndpointGroup returns a map of zone -> endpoint group.
func (gce *GCECloud) AggregatedListNetworkEndpointGroup() (map[string][]*computebeta.NetworkEndpointGroup, error) { func (g *Cloud) AggregatedListNetworkEndpointGroup() (map[string][]*computebeta.NetworkEndpointGroup, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newNetworkEndpointGroupMetricContext("aggregated_list", "") mc := newNetworkEndpointGroupMetricContext("aggregated_list", "")
// TODO: filter for the region the cluster is in. // TODO: filter for the region the cluster is in.
all, err := gce.c.BetaNetworkEndpointGroups().AggregatedList(ctx, filter.None) all, err := g.c.BetaNetworkEndpointGroups().AggregatedList(ctx, filter.None)
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
@ -77,23 +75,26 @@ func (gce *GCECloud) AggregatedListNetworkEndpointGroup() (map[string][]*compute
return ret, mc.Observe(nil) return ret, mc.Observe(nil)
} }
func (gce *GCECloud) CreateNetworkEndpointGroup(neg *computebeta.NetworkEndpointGroup, zone string) error { // CreateNetworkEndpointGroup creates an endpoint group in the zone
func (g *Cloud) CreateNetworkEndpointGroup(neg *computebeta.NetworkEndpointGroup, zone string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newNetworkEndpointGroupMetricContext("create", zone) mc := newNetworkEndpointGroupMetricContext("create", zone)
return mc.Observe(gce.c.BetaNetworkEndpointGroups().Insert(ctx, meta.ZonalKey(neg.Name, zone), neg)) return mc.Observe(g.c.BetaNetworkEndpointGroups().Insert(ctx, meta.ZonalKey(neg.Name, zone), neg))
} }
func (gce *GCECloud) DeleteNetworkEndpointGroup(name string, zone string) error { // DeleteNetworkEndpointGroup deletes the name endpoint group from the zone
func (g *Cloud) DeleteNetworkEndpointGroup(name string, zone string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newNetworkEndpointGroupMetricContext("delete", zone) mc := newNetworkEndpointGroupMetricContext("delete", zone)
return mc.Observe(gce.c.BetaNetworkEndpointGroups().Delete(ctx, meta.ZonalKey(name, zone))) return mc.Observe(g.c.BetaNetworkEndpointGroups().Delete(ctx, meta.ZonalKey(name, zone)))
} }
func (gce *GCECloud) AttachNetworkEndpoints(name, zone string, endpoints []*computebeta.NetworkEndpoint) error { // AttachNetworkEndpoints associates the referenced endpoints with the named endpoint group in the zone
func (g *Cloud) AttachNetworkEndpoints(name, zone string, endpoints []*computebeta.NetworkEndpoint) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -101,10 +102,11 @@ func (gce *GCECloud) AttachNetworkEndpoints(name, zone string, endpoints []*comp
req := &computebeta.NetworkEndpointGroupsAttachEndpointsRequest{ req := &computebeta.NetworkEndpointGroupsAttachEndpointsRequest{
NetworkEndpoints: endpoints, NetworkEndpoints: endpoints,
} }
return mc.Observe(gce.c.BetaNetworkEndpointGroups().AttachNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req)) return mc.Observe(g.c.BetaNetworkEndpointGroups().AttachNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req))
} }
func (gce *GCECloud) DetachNetworkEndpoints(name, zone string, endpoints []*computebeta.NetworkEndpoint) error { // DetachNetworkEndpoints breaks the association between the referenced endpoints and the named endpoint group in the zone
func (g *Cloud) DetachNetworkEndpoints(name, zone string, endpoints []*computebeta.NetworkEndpoint) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -112,10 +114,11 @@ func (gce *GCECloud) DetachNetworkEndpoints(name, zone string, endpoints []*comp
req := &computebeta.NetworkEndpointGroupsDetachEndpointsRequest{ req := &computebeta.NetworkEndpointGroupsDetachEndpointsRequest{
NetworkEndpoints: endpoints, NetworkEndpoints: endpoints,
} }
return mc.Observe(gce.c.BetaNetworkEndpointGroups().DetachNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req)) return mc.Observe(g.c.BetaNetworkEndpointGroups().DetachNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req))
} }
func (gce *GCECloud) ListNetworkEndpoints(name, zone string, showHealthStatus bool) ([]*computebeta.NetworkEndpointWithHealthStatus, error) { // ListNetworkEndpoints returns all the endpoints associated with the endpoint group in zone and optionally their status.
func (g *Cloud) ListNetworkEndpoints(name, zone string, showHealthStatus bool) ([]*computebeta.NetworkEndpointWithHealthStatus, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -127,6 +130,6 @@ func (gce *GCECloud) ListNetworkEndpoints(name, zone string, showHealthStatus bo
req := &computebeta.NetworkEndpointGroupsListEndpointsRequest{ req := &computebeta.NetworkEndpointGroupsListEndpointsRequest{
HealthStatus: healthStatus, HealthStatus: healthStatus,
} }
l, err := gce.c.BetaNetworkEndpointGroups().ListNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req, filter.None) l, err := g.c.BetaNetworkEndpointGroups().ListNetworkEndpoints(ctx, meta.ZonalKey(name, zone), req, filter.None)
return l, mc.Observe(err) return l, mc.Observe(err)
} }

18
pkg/cloudprovider/providers/gce/gce_routes.go
View File

@ -37,14 +37,14 @@ func newRoutesMetricContext(request string) *metricContext {
} }
// ListRoutes in the cloud environment. // ListRoutes in the cloud environment.
func (gce *GCECloud) ListRoutes(ctx context.Context, clusterName string) ([]*cloudprovider.Route, error) { func (g *Cloud) ListRoutes(ctx context.Context, clusterName string) ([]*cloudprovider.Route, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newRoutesMetricContext("list") mc := newRoutesMetricContext("list")
prefix := truncateClusterName(clusterName) prefix := truncateClusterName(clusterName)
f := filter.Regexp("name", prefix+"-.*").AndRegexp("network", gce.NetworkURL()).AndRegexp("description", k8sNodeRouteTag) f := filter.Regexp("name", prefix+"-.*").AndRegexp("network", g.NetworkURL()).AndRegexp("description", k8sNodeRouteTag)
routes, err := gce.c.Routes().List(ctx, f) routes, err := g.c.Routes().List(ctx, f)
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
@ -63,13 +63,13 @@ func (gce *GCECloud) ListRoutes(ctx context.Context, clusterName string) ([]*clo
} }
// CreateRoute in the cloud environment. // CreateRoute in the cloud environment.
func (gce *GCECloud) CreateRoute(ctx context.Context, clusterName string, nameHint string, route *cloudprovider.Route) error { func (g *Cloud) CreateRoute(ctx context.Context, clusterName string, nameHint string, route *cloudprovider.Route) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newRoutesMetricContext("create") mc := newRoutesMetricContext("create")
targetInstance, err := gce.getInstanceByName(mapNodeNameToInstanceName(route.TargetNode)) targetInstance, err := g.getInstanceByName(mapNodeNameToInstanceName(route.TargetNode))
if err != nil { if err != nil {
return mc.Observe(err) return mc.Observe(err)
} }
@ -77,11 +77,11 @@ func (gce *GCECloud) CreateRoute(ctx context.Context, clusterName string, nameHi
Name: truncateClusterName(clusterName) + "-" + nameHint, Name: truncateClusterName(clusterName) + "-" + nameHint,
DestRange: route.DestinationCIDR, DestRange: route.DestinationCIDR,
NextHopInstance: fmt.Sprintf("zones/%s/instances/%s", targetInstance.Zone, targetInstance.Name), NextHopInstance: fmt.Sprintf("zones/%s/instances/%s", targetInstance.Zone, targetInstance.Name),
Network: gce.NetworkURL(), Network: g.NetworkURL(),
Priority: 1000, Priority: 1000,
Description: k8sNodeRouteTag, Description: k8sNodeRouteTag,
} }
err = gce.c.Routes().Insert(ctx, meta.GlobalKey(cr.Name), cr) err = g.c.Routes().Insert(ctx, meta.GlobalKey(cr.Name), cr)
if isHTTPErrorCode(err, http.StatusConflict) { if isHTTPErrorCode(err, http.StatusConflict) {
glog.Infof("Route %q already exists.", cr.Name) glog.Infof("Route %q already exists.", cr.Name)
err = nil err = nil
@ -90,12 +90,12 @@ func (gce *GCECloud) CreateRoute(ctx context.Context, clusterName string, nameHi
} }
// DeleteRoute from the cloud environment. // DeleteRoute from the cloud environment.
func (gce *GCECloud) DeleteRoute(ctx context.Context, clusterName string, route *cloudprovider.Route) error { func (g *Cloud) DeleteRoute(ctx context.Context, clusterName string, route *cloudprovider.Route) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newRoutesMetricContext("delete") mc := newRoutesMetricContext("delete")
return mc.Observe(gce.c.Routes().Delete(ctx, meta.GlobalKey(route.Name))) return mc.Observe(g.c.Routes().Delete(ctx, meta.GlobalKey(route.Name)))
} }
func truncateClusterName(clusterName string) string { func truncateClusterName(clusterName string) string {

36
pkg/cloudprovider/providers/gce/gce_securitypolicy.go
View File

@ -29,88 +29,88 @@ func newSecurityPolicyMetricContextWithVersion(request, version string) *metricC
} }
// GetBetaSecurityPolicy retrieves a security policy. // GetBetaSecurityPolicy retrieves a security policy.
func (gce *GCECloud) GetBetaSecurityPolicy(name string) (*computebeta.SecurityPolicy, error) { func (g *Cloud) GetBetaSecurityPolicy(name string) (*computebeta.SecurityPolicy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("get", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("get", computeBetaVersion)
v, err := gce.c.BetaSecurityPolicies().Get(ctx, meta.GlobalKey(name)) v, err := g.c.BetaSecurityPolicies().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// ListBetaSecurityPolicy lists all security policies in the project. // ListBetaSecurityPolicy lists all security policies in the project.
func (gce *GCECloud) ListBetaSecurityPolicy() ([]*computebeta.SecurityPolicy, error) { func (g *Cloud) ListBetaSecurityPolicy() ([]*computebeta.SecurityPolicy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("list", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("list", computeBetaVersion)
v, err := gce.c.BetaSecurityPolicies().List(ctx, filter.None) v, err := g.c.BetaSecurityPolicies().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateBetaSecurityPolicy creates the given security policy. // CreateBetaSecurityPolicy creates the given security policy.
func (gce *GCECloud) CreateBetaSecurityPolicy(sp *computebeta.SecurityPolicy) error { func (g *Cloud) CreateBetaSecurityPolicy(sp *computebeta.SecurityPolicy) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("create", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("create", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().Insert(ctx, meta.GlobalKey(sp.Name), sp)) return mc.Observe(g.c.BetaSecurityPolicies().Insert(ctx, meta.GlobalKey(sp.Name), sp))
} }
// DeleteBetaSecurityPolicy deletes the given security policy. // DeleteBetaSecurityPolicy deletes the given security policy.
func (gce *GCECloud) DeleteBetaSecurityPolicy(name string) error { func (g *Cloud) DeleteBetaSecurityPolicy(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("delete", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("delete", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.BetaSecurityPolicies().Delete(ctx, meta.GlobalKey(name)))
} }
// PatchBetaSecurityPolicy applies the given security policy as a // PatchBetaSecurityPolicy applies the given security policy as a
// patch to an existing security policy. // patch to an existing security policy.
func (gce *GCECloud) PatchBetaSecurityPolicy(sp *computebeta.SecurityPolicy) error { func (g *Cloud) PatchBetaSecurityPolicy(sp *computebeta.SecurityPolicy) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("patch", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("patch", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().Patch(ctx, meta.GlobalKey(sp.Name), sp)) return mc.Observe(g.c.BetaSecurityPolicies().Patch(ctx, meta.GlobalKey(sp.Name), sp))
} }
// GetRuleForBetaSecurityPolicy gets rule from a security policy. // GetRuleForBetaSecurityPolicy gets rule from a security policy.
func (gce *GCECloud) GetRuleForBetaSecurityPolicy(name string) (*computebeta.SecurityPolicyRule, error) { func (g *Cloud) GetRuleForBetaSecurityPolicy(name string) (*computebeta.SecurityPolicyRule, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("get_rule", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("get_rule", computeBetaVersion)
v, err := gce.c.BetaSecurityPolicies().GetRule(ctx, meta.GlobalKey(name)) v, err := g.c.BetaSecurityPolicies().GetRule(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// AddRuletoBetaSecurityPolicy adds the given security policy rule to // AddRuletoBetaSecurityPolicy adds the given security policy rule to
// a security policy. // a security policy.
func (gce *GCECloud) AddRuletoBetaSecurityPolicy(name string, spr *computebeta.SecurityPolicyRule) error { func (g *Cloud) AddRuletoBetaSecurityPolicy(name string, spr *computebeta.SecurityPolicyRule) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("add_rule", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("add_rule", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().AddRule(ctx, meta.GlobalKey(name), spr)) return mc.Observe(g.c.BetaSecurityPolicies().AddRule(ctx, meta.GlobalKey(name), spr))
} }
// PatchRuleForBetaSecurityPolicy patches the given security policy // PatchRuleForBetaSecurityPolicy patches the given security policy
// rule to a security policy. // rule to a security policy.
func (gce *GCECloud) PatchRuleForBetaSecurityPolicy(name string, spr *computebeta.SecurityPolicyRule) error { func (g *Cloud) PatchRuleForBetaSecurityPolicy(name string, spr *computebeta.SecurityPolicyRule) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("patch_rule", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("patch_rule", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().PatchRule(ctx, meta.GlobalKey(name), spr)) return mc.Observe(g.c.BetaSecurityPolicies().PatchRule(ctx, meta.GlobalKey(name), spr))
} }
// RemoveRuleFromBetaSecurityPolicy removes rule from a security policy. // RemoveRuleFromBetaSecurityPolicy removes rule from a security policy.
func (gce *GCECloud) RemoveRuleFromBetaSecurityPolicy(name string) error { func (g *Cloud) RemoveRuleFromBetaSecurityPolicy(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newSecurityPolicyMetricContextWithVersion("remove_rule", computeBetaVersion) mc := newSecurityPolicyMetricContextWithVersion("remove_rule", computeBetaVersion)
return mc.Observe(gce.c.BetaSecurityPolicies().RemoveRule(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.BetaSecurityPolicies().RemoveRule(ctx, meta.GlobalKey(name)))
} }

20
pkg/cloudprovider/providers/gce/gce_targetpool.go
View File

@ -28,35 +28,35 @@ func newTargetPoolMetricContext(request, region string) *metricContext {
} }
// GetTargetPool returns the TargetPool by name. // GetTargetPool returns the TargetPool by name.
func (gce *GCECloud) GetTargetPool(name, region string) (*compute.TargetPool, error) { func (g *Cloud) GetTargetPool(name, region string) (*compute.TargetPool, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetPoolMetricContext("get", region) mc := newTargetPoolMetricContext("get", region)
v, err := gce.c.TargetPools().Get(ctx, meta.RegionalKey(name, region)) v, err := g.c.TargetPools().Get(ctx, meta.RegionalKey(name, region))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateTargetPool creates the passed TargetPool // CreateTargetPool creates the passed TargetPool
func (gce *GCECloud) CreateTargetPool(tp *compute.TargetPool, region string) error { func (g *Cloud) CreateTargetPool(tp *compute.TargetPool, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetPoolMetricContext("create", region) mc := newTargetPoolMetricContext("create", region)
return mc.Observe(gce.c.TargetPools().Insert(ctx, meta.RegionalKey(tp.Name, region), tp)) return mc.Observe(g.c.TargetPools().Insert(ctx, meta.RegionalKey(tp.Name, region), tp))
} }
// DeleteTargetPool deletes TargetPool by name. // DeleteTargetPool deletes TargetPool by name.
func (gce *GCECloud) DeleteTargetPool(name, region string) error { func (g *Cloud) DeleteTargetPool(name, region string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetPoolMetricContext("delete", region) mc := newTargetPoolMetricContext("delete", region)
return mc.Observe(gce.c.TargetPools().Delete(ctx, meta.RegionalKey(name, region))) return mc.Observe(g.c.TargetPools().Delete(ctx, meta.RegionalKey(name, region)))
} }
// AddInstancesToTargetPool adds instances by link to the TargetPool // AddInstancesToTargetPool adds instances by link to the TargetPool
func (gce *GCECloud) AddInstancesToTargetPool(name, region string, instanceRefs []*compute.InstanceReference) error { func (g *Cloud) AddInstancesToTargetPool(name, region string, instanceRefs []*compute.InstanceReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -64,11 +64,11 @@ func (gce *GCECloud) AddInstancesToTargetPool(name, region string, instanceRefs
Instances: instanceRefs, Instances: instanceRefs,
} }
mc := newTargetPoolMetricContext("add_instances", region) mc := newTargetPoolMetricContext("add_instances", region)
return mc.Observe(gce.c.TargetPools().AddInstance(ctx, meta.RegionalKey(name, region), req)) return mc.Observe(g.c.TargetPools().AddInstance(ctx, meta.RegionalKey(name, region), req))
} }
// RemoveInstancesFromTargetPool removes instances by link to the TargetPool // RemoveInstancesFromTargetPool removes instances by link to the TargetPool
func (gce *GCECloud) RemoveInstancesFromTargetPool(name, region string, instanceRefs []*compute.InstanceReference) error { func (g *Cloud) RemoveInstancesFromTargetPool(name, region string, instanceRefs []*compute.InstanceReference) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -76,5 +76,5 @@ func (gce *GCECloud) RemoveInstancesFromTargetPool(name, region string, instance
Instances: instanceRefs, Instances: instanceRefs,
} }
mc := newTargetPoolMetricContext("remove_instances", region) mc := newTargetPoolMetricContext("remove_instances", region)
return mc.Observe(gce.c.TargetPools().RemoveInstance(ctx, meta.RegionalKey(name, region), req)) return mc.Observe(g.c.TargetPools().RemoveInstance(ctx, meta.RegionalKey(name, region), req))
} }

66
pkg/cloudprovider/providers/gce/gce_targetproxy.go
View File

@ -28,87 +28,87 @@ func newTargetProxyMetricContext(request string) *metricContext {
return newGenericMetricContext("targetproxy", request, unusedMetricLabel, unusedMetricLabel, computeV1Version) return newGenericMetricContext("targetproxy", request, unusedMetricLabel, unusedMetricLabel, computeV1Version)
} }
// GetTargetHttpProxy returns the UrlMap by name. // GetTargetHTTPProxy returns the UrlMap by name.
func (gce *GCECloud) GetTargetHttpProxy(name string) (*compute.TargetHttpProxy, error) { func (g *Cloud) GetTargetHTTPProxy(name string) (*compute.TargetHttpProxy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("get") mc := newTargetProxyMetricContext("get")
v, err := gce.c.TargetHttpProxies().Get(ctx, meta.GlobalKey(name)) v, err := g.c.TargetHttpProxies().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateTargetHttpProxy creates a TargetHttpProxy // CreateTargetHTTPProxy creates a TargetHttpProxy
func (gce *GCECloud) CreateTargetHttpProxy(proxy *compute.TargetHttpProxy) error { func (g *Cloud) CreateTargetHTTPProxy(proxy *compute.TargetHttpProxy) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("create") mc := newTargetProxyMetricContext("create")
return mc.Observe(gce.c.TargetHttpProxies().Insert(ctx, meta.GlobalKey(proxy.Name), proxy)) return mc.Observe(g.c.TargetHttpProxies().Insert(ctx, meta.GlobalKey(proxy.Name), proxy))
} }
// SetUrlMapForTargetHttpProxy sets the given UrlMap for the given TargetHttpProxy. // SetURLMapForTargetHTTPProxy sets the given UrlMap for the given TargetHttpProxy.
func (gce *GCECloud) SetUrlMapForTargetHttpProxy(proxy *compute.TargetHttpProxy, urlMapLink string) error { func (g *Cloud) SetURLMapForTargetHTTPProxy(proxy *compute.TargetHttpProxy, urlMapLink string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
ref := &compute.UrlMapReference{UrlMap: urlMapLink} ref := &compute.UrlMapReference{UrlMap: urlMapLink}
mc := newTargetProxyMetricContext("set_url_map") mc := newTargetProxyMetricContext("set_url_map")
return mc.Observe(gce.c.TargetHttpProxies().SetUrlMap(ctx, meta.GlobalKey(proxy.Name), ref)) return mc.Observe(g.c.TargetHttpProxies().SetUrlMap(ctx, meta.GlobalKey(proxy.Name), ref))
} }
// DeleteTargetHttpProxy deletes the TargetHttpProxy by name. // DeleteTargetHTTPProxy deletes the TargetHttpProxy by name.
func (gce *GCECloud) DeleteTargetHttpProxy(name string) error { func (g *Cloud) DeleteTargetHTTPProxy(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("delete") mc := newTargetProxyMetricContext("delete")
return mc.Observe(gce.c.TargetHttpProxies().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.TargetHttpProxies().Delete(ctx, meta.GlobalKey(name)))
} }
// ListTargetHttpProxies lists all TargetHttpProxies in the project. // ListTargetHTTPProxies lists all TargetHttpProxies in the project.
func (gce *GCECloud) ListTargetHttpProxies() ([]*compute.TargetHttpProxy, error) { func (g *Cloud) ListTargetHTTPProxies() ([]*compute.TargetHttpProxy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("list") mc := newTargetProxyMetricContext("list")
v, err := gce.c.TargetHttpProxies().List(ctx, filter.None) v, err := g.c.TargetHttpProxies().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// TargetHttpsProxy management // TargetHttpsProxy management
// GetTargetHttpsProxy returns the UrlMap by name. // GetTargetHTTPSProxy returns the UrlMap by name.
func (gce *GCECloud) GetTargetHttpsProxy(name string) (*compute.TargetHttpsProxy, error) { func (g *Cloud) GetTargetHTTPSProxy(name string) (*compute.TargetHttpsProxy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("get") mc := newTargetProxyMetricContext("get")
v, err := gce.c.TargetHttpsProxies().Get(ctx, meta.GlobalKey(name)) v, err := g.c.TargetHttpsProxies().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateTargetHttpsProxy creates a TargetHttpsProxy // CreateTargetHTTPSProxy creates a TargetHttpsProxy
func (gce *GCECloud) CreateTargetHttpsProxy(proxy *compute.TargetHttpsProxy) error { func (g *Cloud) CreateTargetHTTPSProxy(proxy *compute.TargetHttpsProxy) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("create") mc := newTargetProxyMetricContext("create")
return mc.Observe(gce.c.TargetHttpsProxies().Insert(ctx, meta.GlobalKey(proxy.Name), proxy)) return mc.Observe(g.c.TargetHttpsProxies().Insert(ctx, meta.GlobalKey(proxy.Name), proxy))
} }
// SetUrlMapForTargetHttpsProxy sets the given UrlMap for the given TargetHttpsProxy. // SetURLMapForTargetHTTPSProxy sets the given UrlMap for the given TargetHttpsProxy.
func (gce *GCECloud) SetUrlMapForTargetHttpsProxy(proxy *compute.TargetHttpsProxy, urlMapLink string) error { func (g *Cloud) SetURLMapForTargetHTTPSProxy(proxy *compute.TargetHttpsProxy, urlMapLink string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("set_url_map") mc := newTargetProxyMetricContext("set_url_map")
ref := &compute.UrlMapReference{UrlMap: urlMapLink} ref := &compute.UrlMapReference{UrlMap: urlMapLink}
return mc.Observe(gce.c.TargetHttpsProxies().SetUrlMap(ctx, meta.GlobalKey(proxy.Name), ref)) return mc.Observe(g.c.TargetHttpsProxies().SetUrlMap(ctx, meta.GlobalKey(proxy.Name), ref))
} }
// SetSslCertificateForTargetHttpsProxy sets the given SslCertificate for the given TargetHttpsProxy. // SetSslCertificateForTargetHTTPSProxy sets the given SslCertificate for the given TargetHttpsProxy.
func (gce *GCECloud) SetSslCertificateForTargetHttpsProxy(proxy *compute.TargetHttpsProxy, sslCertURLs []string) error { func (g *Cloud) SetSslCertificateForTargetHTTPSProxy(proxy *compute.TargetHttpsProxy, sslCertURLs []string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
@ -116,24 +116,24 @@ func (gce *GCECloud) SetSslCertificateForTargetHttpsProxy(proxy *compute.TargetH
req := &compute.TargetHttpsProxiesSetSslCertificatesRequest{ req := &compute.TargetHttpsProxiesSetSslCertificatesRequest{
SslCertificates: sslCertURLs, SslCertificates: sslCertURLs,
} }
return mc.Observe(gce.c.TargetHttpsProxies().SetSslCertificates(ctx, meta.GlobalKey(proxy.Name), req)) return mc.Observe(g.c.TargetHttpsProxies().SetSslCertificates(ctx, meta.GlobalKey(proxy.Name), req))
} }
// DeleteTargetHttpsProxy deletes the TargetHttpsProxy by name. // DeleteTargetHTTPSProxy deletes the TargetHttpsProxy by name.
func (gce *GCECloud) DeleteTargetHttpsProxy(name string) error { func (g *Cloud) DeleteTargetHTTPSProxy(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("delete") mc := newTargetProxyMetricContext("delete")
return mc.Observe(gce.c.TargetHttpsProxies().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.TargetHttpsProxies().Delete(ctx, meta.GlobalKey(name)))
} }
// ListTargetHttpsProxies lists all TargetHttpsProxies in the project. // ListTargetHTTPSProxies lists all TargetHttpsProxies in the project.
func (gce *GCECloud) ListTargetHttpsProxies() ([]*compute.TargetHttpsProxy, error) { func (g *Cloud) ListTargetHTTPSProxies() ([]*compute.TargetHttpsProxy, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newTargetProxyMetricContext("list") mc := newTargetProxyMetricContext("list")
v, err := gce.c.TargetHttpsProxies().List(ctx, filter.None) v, err := g.c.TargetHttpsProxies().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }

12
pkg/cloudprovider/providers/gce/gce_test.go
View File

@ -91,7 +91,7 @@ func TestGetRegion(t *testing.T) {
if regionName != "us-central1" { if regionName != "us-central1" {
t.Errorf("Unexpected region from GetGCERegion: %s", regionName) t.Errorf("Unexpected region from GetGCERegion: %s", regionName)
} }
gce := &GCECloud{ gce := &Cloud{
localZone: zoneName, localZone: zoneName,
region: regionName, region: regionName,
} }
@ -299,7 +299,7 @@ func TestGetZoneByProviderID(t *testing.T) {
}, },
} }
gce := &GCECloud{ gce := &Cloud{
localZone: "us-central1-f", localZone: "us-central1-f",
region: "us-central1", region: "us-central1",
} }
@ -331,13 +331,13 @@ func TestGenerateCloudConfigs(t *testing.T) {
NodeInstancePrefix: "node-prefix", NodeInstancePrefix: "node-prefix",
Multizone: false, Multizone: false,
Regional: false, Regional: false,
ApiEndpoint: "", APIEndpoint: "",
LocalZone: "us-central1-a", LocalZone: "us-central1-a",
AlphaFeatures: []string{}, AlphaFeatures: []string{},
} }
cloudBoilerplate := CloudConfig{ cloudBoilerplate := CloudConfig{
ApiEndpoint: "", APIEndpoint: "",
ProjectID: "project-id", ProjectID: "project-id",
NetworkProjectID: "", NetworkProjectID: "",
Region: "us-central1", Region: "us-central1",
@ -395,12 +395,12 @@ func TestGenerateCloudConfigs(t *testing.T) {
name: "Specified API Endpint", name: "Specified API Endpint",
config: func() ConfigGlobal { config: func() ConfigGlobal {
v := configBoilerplate v := configBoilerplate
v.ApiEndpoint = "https://www.googleapis.com/compute/staging_v1/" v.APIEndpoint = "https://www.googleapis.com/compute/staging_v1/"
return v return v
}, },
cloud: func() CloudConfig { cloud: func() CloudConfig {
v := cloudBoilerplate v := cloudBoilerplate
v.ApiEndpoint = "https://www.googleapis.com/compute/staging_v1/" v.APIEndpoint = "https://www.googleapis.com/compute/staging_v1/"
return v return v
}, },
}, },

40
pkg/cloudprovider/providers/gce/gce_tpu.go
View File

@ -50,20 +50,20 @@ type tpuService struct {
// CreateTPU creates the Cloud TPU node with the specified name in the // CreateTPU creates the Cloud TPU node with the specified name in the
// specified zone. // specified zone.
func (gce *GCECloud) CreateTPU(ctx context.Context, name, zone string, node *tpuapi.Node) (*tpuapi.Node, error) { func (g *Cloud) CreateTPU(ctx context.Context, name, zone string, node *tpuapi.Node) (*tpuapi.Node, error) {
var err error var err error
mc := newTPUMetricContext("create", zone) mc := newTPUMetricContext("create", zone)
defer mc.Observe(err) defer mc.Observe(err)
var op *tpuapi.Operation var op *tpuapi.Operation
parent := getTPUParentName(gce.projectID, zone) parent := getTPUParentName(g.projectID, zone)
op, err = gce.tpuService.projects.Locations.Nodes.Create(parent, node).NodeId(name).Do() op, err = g.tpuService.projects.Locations.Nodes.Create(parent, node).NodeId(name).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
glog.V(2).Infof("Creating Cloud TPU %q in zone %q with operation %q", name, zone, op.Name) glog.V(2).Infof("Creating Cloud TPU %q in zone %q with operation %q", name, zone, op.Name)
op, err = gce.waitForTPUOp(ctx, op) op, err = g.waitForTPUOp(ctx, op)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -83,20 +83,20 @@ func (gce *GCECloud) CreateTPU(ctx context.Context, name, zone string, node *tpu
// DeleteTPU deletes the Cloud TPU with the specified name in the specified // DeleteTPU deletes the Cloud TPU with the specified name in the specified
// zone. // zone.
func (gce *GCECloud) DeleteTPU(ctx context.Context, name, zone string) error { func (g *Cloud) DeleteTPU(ctx context.Context, name, zone string) error {
var err error var err error
mc := newTPUMetricContext("delete", zone) mc := newTPUMetricContext("delete", zone)
defer mc.Observe(err) defer mc.Observe(err)
var op *tpuapi.Operation var op *tpuapi.Operation
name = getTPUName(gce.projectID, zone, name) name = getTPUName(g.projectID, zone, name)
op, err = gce.tpuService.projects.Locations.Nodes.Delete(name).Do() op, err = g.tpuService.projects.Locations.Nodes.Delete(name).Do()
if err != nil { if err != nil {
return err return err
} }
glog.V(2).Infof("Deleting Cloud TPU %q in zone %q with operation %q", name, zone, op.Name) glog.V(2).Infof("Deleting Cloud TPU %q in zone %q with operation %q", name, zone, op.Name)
op, err = gce.waitForTPUOp(ctx, op) op, err = g.waitForTPUOp(ctx, op)
if err != nil { if err != nil {
return err return err
} }
@ -108,11 +108,11 @@ func (gce *GCECloud) DeleteTPU(ctx context.Context, name, zone string) error {
} }
// GetTPU returns the Cloud TPU with the specified name in the specified zone. // GetTPU returns the Cloud TPU with the specified name in the specified zone.
func (gce *GCECloud) GetTPU(ctx context.Context, name, zone string) (*tpuapi.Node, error) { func (g *Cloud) GetTPU(ctx context.Context, name, zone string) (*tpuapi.Node, error) {
mc := newTPUMetricContext("get", zone) mc := newTPUMetricContext("get", zone)
name = getTPUName(gce.projectID, zone, name) name = getTPUName(g.projectID, zone, name)
node, err := gce.tpuService.projects.Locations.Nodes.Get(name).Do() node, err := g.tpuService.projects.Locations.Nodes.Get(name).Do()
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
@ -120,11 +120,11 @@ func (gce *GCECloud) GetTPU(ctx context.Context, name, zone string) (*tpuapi.Nod
} }
// ListTPUs returns Cloud TPUs in the specified zone. // ListTPUs returns Cloud TPUs in the specified zone.
func (gce *GCECloud) ListTPUs(ctx context.Context, zone string) ([]*tpuapi.Node, error) { func (g *Cloud) ListTPUs(ctx context.Context, zone string) ([]*tpuapi.Node, error) {
mc := newTPUMetricContext("list", zone) mc := newTPUMetricContext("list", zone)
parent := getTPUParentName(gce.projectID, zone) parent := getTPUParentName(g.projectID, zone)
response, err := gce.tpuService.projects.Locations.Nodes.List(parent).Do() response, err := g.tpuService.projects.Locations.Nodes.List(parent).Do()
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
@ -132,10 +132,10 @@ func (gce *GCECloud) ListTPUs(ctx context.Context, zone string) ([]*tpuapi.Node,
} }
// ListLocations returns the zones where Cloud TPUs are available. // ListLocations returns the zones where Cloud TPUs are available.
func (gce *GCECloud) ListLocations(ctx context.Context) ([]*tpuapi.Location, error) { func (g *Cloud) ListLocations(ctx context.Context) ([]*tpuapi.Location, error) {
mc := newTPUMetricContext("list_locations", "") mc := newTPUMetricContext("list_locations", "")
parent := getTPUProjectURL(gce.projectID) parent := getTPUProjectURL(g.projectID)
response, err := gce.tpuService.projects.Locations.List(parent).Do() response, err := g.tpuService.projects.Locations.List(parent).Do()
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
@ -144,7 +144,7 @@ func (gce *GCECloud) ListLocations(ctx context.Context) ([]*tpuapi.Location, err
// waitForTPUOp checks whether the op is done every 30 seconds before the ctx // waitForTPUOp checks whether the op is done every 30 seconds before the ctx
// is cancelled. // is cancelled.
func (gce *GCECloud) waitForTPUOp(ctx context.Context, op *tpuapi.Operation) (*tpuapi.Operation, error) { func (g *Cloud) waitForTPUOp(ctx context.Context, op *tpuapi.Operation) (*tpuapi.Operation, error) {
if err := wait.PollInfinite(30*time.Second, func() (bool, error) { if err := wait.PollInfinite(30*time.Second, func() (bool, error) {
// Check if context has been cancelled. // Check if context has been cancelled.
select { select {
@ -157,14 +157,14 @@ func (gce *GCECloud) waitForTPUOp(ctx context.Context, op *tpuapi.Operation) (*t
glog.V(3).Infof("Waiting for operation %q to complete...", op.Name) glog.V(3).Infof("Waiting for operation %q to complete...", op.Name)
start := time.Now() start := time.Now()
gce.operationPollRateLimiter.Accept() g.operationPollRateLimiter.Accept()
duration := time.Now().Sub(start) duration := time.Now().Sub(start)
if duration > 5*time.Second { if duration > 5*time.Second {
glog.V(2).Infof("Getting operation %q throttled for %v", op.Name, duration) glog.V(2).Infof("Getting operation %q throttled for %v", op.Name, duration)
} }
var err error var err error
op, err = gce.tpuService.projects.Locations.Operations.Get(op.Name).Do() op, err = g.tpuService.projects.Locations.Operations.Get(op.Name).Do()
if err != nil { if err != nil {
return true, err return true, err
} }

42
pkg/cloudprovider/providers/gce/gce_urlmap.go
View File

@ -24,53 +24,53 @@ import (
"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
) )
func newUrlMapMetricContext(request string) *metricContext { func newURLMapMetricContext(request string) *metricContext {
return newGenericMetricContext("urlmap", request, unusedMetricLabel, unusedMetricLabel, computeV1Version) return newGenericMetricContext("urlmap", request, unusedMetricLabel, unusedMetricLabel, computeV1Version)
} }
// GetUrlMap returns the UrlMap by name. // GetURLMap returns the UrlMap by name.
func (gce *GCECloud) GetUrlMap(name string) (*compute.UrlMap, error) { func (g *Cloud) GetURLMap(name string) (*compute.UrlMap, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newUrlMapMetricContext("get") mc := newURLMapMetricContext("get")
v, err := gce.c.UrlMaps().Get(ctx, meta.GlobalKey(name)) v, err := g.c.UrlMaps().Get(ctx, meta.GlobalKey(name))
return v, mc.Observe(err) return v, mc.Observe(err)
} }
// CreateUrlMap creates a url map // CreateURLMap creates a url map
func (gce *GCECloud) CreateUrlMap(urlMap *compute.UrlMap) error { func (g *Cloud) CreateURLMap(urlMap *compute.UrlMap) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newUrlMapMetricContext("create") mc := newURLMapMetricContext("create")
return mc.Observe(gce.c.UrlMaps().Insert(ctx, meta.GlobalKey(urlMap.Name), urlMap)) return mc.Observe(g.c.UrlMaps().Insert(ctx, meta.GlobalKey(urlMap.Name), urlMap))
} }
// UpdateUrlMap applies the given UrlMap as an update // UpdateURLMap applies the given UrlMap as an update
func (gce *GCECloud) UpdateUrlMap(urlMap *compute.UrlMap) error { func (g *Cloud) UpdateURLMap(urlMap *compute.UrlMap) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newUrlMapMetricContext("update") mc := newURLMapMetricContext("update")
return mc.Observe(gce.c.UrlMaps().Update(ctx, meta.GlobalKey(urlMap.Name), urlMap)) return mc.Observe(g.c.UrlMaps().Update(ctx, meta.GlobalKey(urlMap.Name), urlMap))
} }
// DeleteUrlMap deletes a url map by name. // DeleteURLMap deletes a url map by name.
func (gce *GCECloud) DeleteUrlMap(name string) error { func (g *Cloud) DeleteURLMap(name string) error {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newUrlMapMetricContext("delete") mc := newURLMapMetricContext("delete")
return mc.Observe(gce.c.UrlMaps().Delete(ctx, meta.GlobalKey(name))) return mc.Observe(g.c.UrlMaps().Delete(ctx, meta.GlobalKey(name)))
} }
// ListUrlMaps lists all UrlMaps in the project. // ListURLMaps lists all UrlMaps in the project.
func (gce *GCECloud) ListUrlMaps() ([]*compute.UrlMap, error) { func (g *Cloud) ListURLMaps() ([]*compute.UrlMap, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newUrlMapMetricContext("list") mc := newURLMapMetricContext("list")
v, err := gce.c.UrlMaps().List(ctx, filter.None) v, err := g.c.UrlMaps().List(ctx, filter.None)
return v, mc.Observe(err) return v, mc.Observe(err)
} }

18
pkg/cloudprovider/providers/gce/gce_util.go
View File

@ -38,8 +38,8 @@ import (
"google.golang.org/api/googleapi" "google.golang.org/api/googleapi"
) )
func fakeGCECloud(vals TestClusterValues) (*GCECloud, error) { func fakeGCECloud(vals TestClusterValues) (*Cloud, error) {
gce := simpleFakeGCECloud(vals) gce := NewFakeGCECloud(vals)
gce.AlphaFeatureGate = NewAlphaFeatureGate([]string{}) gce.AlphaFeatureGate = NewAlphaFeatureGate([]string{})
gce.nodeInformerSynced = func() bool { return true } gce.nodeInformerSynced = func() bool { return true }
@ -88,7 +88,7 @@ var (
} }
) )
var providerIdRE = regexp.MustCompile(`^` + ProviderName + `://([^/]+)/([^/]+)/([^/]+)$`) var providerIDRE = regexp.MustCompile(`^` + ProviderName + `://([^/]+)/([^/]+)/([^/]+)$`)
func getProjectAndZone() (string, string, error) { func getProjectAndZone() (string, string, error) {
result, err := metadata.Get("instance/zone") result, err := metadata.Get("instance/zone")
@ -107,10 +107,10 @@ func getProjectAndZone() (string, string, error) {
return projectID, zone, nil return projectID, zone, nil
} }
func (gce *GCECloud) raiseFirewallChangeNeededEvent(svc *v1.Service, cmd string) { func (g *Cloud) raiseFirewallChangeNeededEvent(svc *v1.Service, cmd string) {
msg := fmt.Sprintf("Firewall change required by network admin: `%v`", cmd) msg := fmt.Sprintf("Firewall change required by network admin: `%v`", cmd)
if gce.eventRecorder != nil && svc != nil { if g.eventRecorder != nil && svc != nil {
gce.eventRecorder.Event(svc, v1.EventTypeNormal, "LoadBalancerManualChange", msg) g.eventRecorder.Event(svc, v1.EventTypeNormal, "LoadBalancerManualChange", msg)
} }
} }
@ -120,13 +120,13 @@ func FirewallToGCloudCreateCmd(fw *compute.Firewall, projectID string) string {
return fmt.Sprintf("gcloud compute firewall-rules create %v --network %v %v", fw.Name, getNameFromLink(fw.Network), args) return fmt.Sprintf("gcloud compute firewall-rules create %v --network %v %v", fw.Name, getNameFromLink(fw.Network), args)
} }
// FirewallToGCloudCreateCmd generates a gcloud command to update a firewall to specified params // FirewallToGCloudUpdateCmd generates a gcloud command to update a firewall to specified params
func FirewallToGCloudUpdateCmd(fw *compute.Firewall, projectID string) string { func FirewallToGCloudUpdateCmd(fw *compute.Firewall, projectID string) string {
args := firewallToGcloudArgs(fw, projectID) args := firewallToGcloudArgs(fw, projectID)
return fmt.Sprintf("gcloud compute firewall-rules update %v %v", fw.Name, args) return fmt.Sprintf("gcloud compute firewall-rules update %v %v", fw.Name, args)
} }
// FirewallToGCloudCreateCmd generates a gcloud command to delete a firewall to specified params // FirewallToGCloudDeleteCmd generates a gcloud command to delete a firewall to specified params
func FirewallToGCloudDeleteCmd(fwName, projectID string) string { func FirewallToGCloudDeleteCmd(fwName, projectID string) string {
return fmt.Sprintf("gcloud compute firewall-rules delete %v --project %v", fwName, projectID) return fmt.Sprintf("gcloud compute firewall-rules delete %v --project %v", fwName, projectID)
} }
@ -205,7 +205,7 @@ func isInUsedByError(err error) bool {
// A providerID is build out of '${ProviderName}://${project-id}/${zone}/${instance-name}' // A providerID is build out of '${ProviderName}://${project-id}/${zone}/${instance-name}'
// See cloudprovider.GetInstanceProviderID. // See cloudprovider.GetInstanceProviderID.
func splitProviderID(providerID string) (project, zone, instance string, err error) { func splitProviderID(providerID string) (project, zone, instance string, err error) {
matches := providerIdRE.FindStringSubmatch(providerID) matches := providerIDRE.FindStringSubmatch(providerID)
if len(matches) != 4 { if len(matches) != 4 {
return "", "", "", errors.New("error splitting providerID") return "", "", "", errors.New("error splitting providerID")
} }

20
pkg/cloudprovider/providers/gce/gce_zones.go
View File

@ -33,17 +33,17 @@ func newZonesMetricContext(request, region string) *metricContext {
} }
// GetZone creates a cloudprovider.Zone of the current zone and region // GetZone creates a cloudprovider.Zone of the current zone and region
func (gce *GCECloud) GetZone(ctx context.Context) (cloudprovider.Zone, error) { func (g *Cloud) GetZone(ctx context.Context) (cloudprovider.Zone, error) {
return cloudprovider.Zone{ return cloudprovider.Zone{
FailureDomain: gce.localZone, FailureDomain: g.localZone,
Region: gce.region, Region: g.region,
}, nil }, nil
} }
// GetZoneByProviderID implements Zones.GetZoneByProviderID // GetZoneByProviderID implements Zones.GetZoneByProviderID
// This is particularly useful in external cloud providers where the kubelet // This is particularly useful in external cloud providers where the kubelet
// does not initialize node data. // does not initialize node data.
func (gce *GCECloud) GetZoneByProviderID(ctx context.Context, providerID string) (cloudprovider.Zone, error) { func (g *Cloud) GetZoneByProviderID(ctx context.Context, providerID string) (cloudprovider.Zone, error) {
_, zone, _, err := splitProviderID(providerID) _, zone, _, err := splitProviderID(providerID)
if err != nil { if err != nil {
return cloudprovider.Zone{}, err return cloudprovider.Zone{}, err
@ -58,9 +58,9 @@ func (gce *GCECloud) GetZoneByProviderID(ctx context.Context, providerID string)
// GetZoneByNodeName implements Zones.GetZoneByNodeName // GetZoneByNodeName implements Zones.GetZoneByNodeName
// This is particularly useful in external cloud providers where the kubelet // This is particularly useful in external cloud providers where the kubelet
// does not initialize node data. // does not initialize node data.
func (gce *GCECloud) GetZoneByNodeName(ctx context.Context, nodeName types.NodeName) (cloudprovider.Zone, error) { func (g *Cloud) GetZoneByNodeName(ctx context.Context, nodeName types.NodeName) (cloudprovider.Zone, error) {
instanceName := mapNodeNameToInstanceName(nodeName) instanceName := mapNodeNameToInstanceName(nodeName)
instance, err := gce.getInstanceByName(instanceName) instance, err := g.getInstanceByName(instanceName)
if err != nil { if err != nil {
return cloudprovider.Zone{}, err return cloudprovider.Zone{}, err
} }
@ -72,18 +72,18 @@ func (gce *GCECloud) GetZoneByNodeName(ctx context.Context, nodeName types.NodeN
} }
// ListZonesInRegion returns all zones in a GCP region // ListZonesInRegion returns all zones in a GCP region
func (gce *GCECloud) ListZonesInRegion(region string) ([]*compute.Zone, error) { func (g *Cloud) ListZonesInRegion(region string) ([]*compute.Zone, error) {
ctx, cancel := cloud.ContextWithCallTimeout() ctx, cancel := cloud.ContextWithCallTimeout()
defer cancel() defer cancel()
mc := newZonesMetricContext("list", region) mc := newZonesMetricContext("list", region)
list, err := gce.c.Zones().List(ctx, filter.Regexp("region", gce.getRegionLink(region))) list, err := g.c.Zones().List(ctx, filter.Regexp("region", g.getRegionLink(region)))
if err != nil { if err != nil {
return nil, mc.Observe(err) return nil, mc.Observe(err)
} }
return list, mc.Observe(err) return list, mc.Observe(err)
} }
func (gce *GCECloud) getRegionLink(region string) string { func (g *Cloud) getRegionLink(region string) string {
return gce.service.BasePath + strings.Join([]string{gce.projectID, "regions", region}, "/") return g.service.BasePath + strings.Join([]string{g.projectID, "regions", region}, "/")
} }

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

@ -25,7 +25,7 @@ import (
// gceProjectRouter sends requests to the appropriate project ID. // gceProjectRouter sends requests to the appropriate project ID.
type gceProjectRouter struct { type gceProjectRouter struct {
gce *GCECloud gce *Cloud
} }
// ProjectID returns the project ID to be used for the given operation. // ProjectID returns the project ID to be used for the given operation.
@ -40,7 +40,7 @@ func (r *gceProjectRouter) ProjectID(ctx context.Context, version meta.Version,
// gceRateLimiter implements cloud.RateLimiter. // gceRateLimiter implements cloud.RateLimiter.
type gceRateLimiter struct { type gceRateLimiter struct {
gce *GCECloud gce *Cloud
} }
// Accept blocks until the operation can be performed. // Accept blocks until the operation can be performed.
@ -63,10 +63,10 @@ func (l *gceRateLimiter) Accept(ctx context.Context, key *cloud.RateLimitKey) er
return nil return nil
} }
// CreateGCECloudWithCloud is a helper function to create an instance of GCECloud with the // CreateGCECloudWithCloud is a helper function to create an instance of Cloud with the
// given Cloud interface implementation. Typical usage is to use cloud.NewMockGCE to get a // given Cloud interface implementation. Typical usage is to use cloud.NewMockGCE to get a
// handle to a mock Cloud instance and then use that for testing. // handle to a mock Cloud instance and then use that for testing.
func CreateGCECloudWithCloud(config *CloudConfig, c cloud.Cloud) (*GCECloud, error) { func CreateGCECloudWithCloud(config *CloudConfig, c cloud.Cloud) (*Cloud, error) {
gceCloud, err := CreateGCECloud(config) gceCloud, err := CreateGCECloud(config)
if err == nil { if err == nil {
gceCloud.c = c gceCloud.c = c

3
pkg/cloudprovider/providers/gce/token_source.go
View File

@ -57,6 +57,7 @@ func init() {
prometheus.MustRegister(getTokenFailCounter) prometheus.MustRegister(getTokenFailCounter)
} }
// AltTokenSource is the structure holding the data for the functionality needed to generates tokens
type AltTokenSource struct { type AltTokenSource struct {
oauthClient *http.Client oauthClient *http.Client
tokenURL string tokenURL string
@ -64,6 +65,7 @@ type AltTokenSource struct {
throttle flowcontrol.RateLimiter throttle flowcontrol.RateLimiter
} }
// Token returns a token which may be used for authentication
func (a *AltTokenSource) Token() (*oauth2.Token, error) { func (a *AltTokenSource) Token() (*oauth2.Token, error) {
a.throttle.Accept() a.throttle.Accept()
getTokenCounter.Inc() getTokenCounter.Inc()
@ -100,6 +102,7 @@ func (a *AltTokenSource) token() (*oauth2.Token, error) {
}, nil }, nil
} }
// NewAltTokenSource constructs a new alternate token source for generating tokens.
func NewAltTokenSource(tokenURL, tokenBody string) oauth2.TokenSource { func NewAltTokenSource(tokenURL, tokenBody string) oauth2.TokenSource {
client := oauth2.NewClient(oauth2.NoContext, google.ComputeTokenSource("")) client := oauth2.NewClient(oauth2.NoContext, google.ComputeTokenSource(""))
a := &AltTokenSource{ a := &AltTokenSource{

4
pkg/controller/nodeipam/ipam/adapter.go
View File

@ -36,12 +36,12 @@ import (
type adapter struct { type adapter struct {
k8s clientset.Interface k8s clientset.Interface
cloud *gce.GCECloud cloud *gce.Cloud
recorder record.EventRecorder recorder record.EventRecorder
} }
func newAdapter(k8s clientset.Interface, cloud *gce.GCECloud) *adapter { func newAdapter(k8s clientset.Interface, cloud *gce.Cloud) *adapter {
ret := &adapter{ ret := &adapter{
k8s: k8s, k8s: k8s,
cloud: cloud, cloud: cloud,

4
pkg/controller/nodeipam/ipam/cloud_cidr_allocator.go
View File

@ -59,7 +59,7 @@ type nodeProcessingInfo struct {
// merely takes the assignment and updates the node spec. // merely takes the assignment and updates the node spec.
type cloudCIDRAllocator struct { type cloudCIDRAllocator struct {
client clientset.Interface client clientset.Interface
cloud *gce.GCECloud cloud *gce.Cloud
// nodeLister is able to list/get nodes and is populated by the shared informer passed to // nodeLister is able to list/get nodes and is populated by the shared informer passed to
// NewCloudCIDRAllocator. // NewCloudCIDRAllocator.
@ -93,7 +93,7 @@ func NewCloudCIDRAllocator(client clientset.Interface, cloud cloudprovider.Inter
glog.V(0).Infof("Sending events to api server.") glog.V(0).Infof("Sending events to api server.")
eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: client.CoreV1().Events("")}) eventBroadcaster.StartRecordingToSink(&v1core.EventSinkImpl{Interface: client.CoreV1().Events("")})
gceCloud, ok := cloud.(*gce.GCECloud) gceCloud, ok := cloud.(*gce.Cloud)
if !ok { if !ok {
err := fmt.Errorf("cloudCIDRAllocator does not support %v provider", cloud.ProviderName()) err := fmt.Errorf("cloudCIDRAllocator does not support %v provider", cloud.ProviderName())
return nil, err return nil, err

2
pkg/controller/nodeipam/ipam/controller.go
View File

@ -71,7 +71,7 @@ func NewController(
return nil, fmt.Errorf("invalid IPAM controller mode %q", config.Mode) return nil, fmt.Errorf("invalid IPAM controller mode %q", config.Mode)
} }
gceCloud, ok := cloud.(*gce.GCECloud) gceCloud, ok := cloud.(*gce.Cloud)
if !ok { if !ok {
return nil, fmt.Errorf("cloud IPAM controller does not support %q provider", cloud.ProviderName()) return nil, fmt.Errorf("cloud IPAM controller does not support %q provider", cloud.ProviderName())
} }

2
pkg/controller/nodeipam/node_ipam_controller_test.go
View File

@ -48,7 +48,7 @@ func newTestNodeIpamController(clusterCIDR, serviceCIDR *net.IPNet, nodeCIDRMask
fakeNodeInformer.Informer().GetStore().Add(node) fakeNodeInformer.Informer().GetStore().Add(node)
} }
fakeGCE := gce.FakeGCECloud(gce.DefaultTestClusterValues()) fakeGCE := gce.NewFakeGCECloud(gce.DefaultTestClusterValues())
return NewNodeIpamController( return NewNodeIpamController(
fakeNodeInformer, fakeGCE, clientSet, fakeNodeInformer, fakeGCE, clientSet,
clusterCIDR, serviceCIDR, nodeCIDRMaskSize, allocatorType, clusterCIDR, serviceCIDR, nodeCIDRMaskSize, allocatorType,

4
pkg/volume/gcepd/gce_util.go
View File

@ -284,10 +284,10 @@ func getDiskByIDPaths(pdName string, partition string) []string {
} }
// Return cloud provider // Return cloud provider
func getCloudProvider(cloudProvider cloudprovider.Interface) (*gcecloud.GCECloud, error) { func getCloudProvider(cloudProvider cloudprovider.Interface) (*gcecloud.Cloud, error) {
var err error var err error
for numRetries := 0; numRetries < maxRetries; numRetries++ { for numRetries := 0; numRetries < maxRetries; numRetries++ {
gceCloudProvider, ok := cloudProvider.(*gcecloud.GCECloud) gceCloudProvider, ok := cloudProvider.(*gcecloud.Cloud)
if !ok || gceCloudProvider == nil { if !ok || gceCloudProvider == nil {
// Retry on error. See issue #11321 // Retry on error. See issue #11321
glog.Errorf("Failed to get GCE Cloud Provider. plugin.host.GetCloudProvider returned %v instead", cloudProvider) glog.Errorf("Failed to get GCE Cloud Provider. plugin.host.GetCloudProvider returned %v instead", cloudProvider)

6
plugin/pkg/admission/storage/persistentvolume/label/admission.go
View File

@ -58,7 +58,7 @@ type persistentVolumeLabel struct {
mutex sync.Mutex mutex sync.Mutex
ebsVolumes aws.Volumes ebsVolumes aws.Volumes
cloudConfig []byte cloudConfig []byte
gceCloudProvider *gce.GCECloud gceCloudProvider *gce.Cloud
azureProvider *azure.Cloud azureProvider *azure.Cloud
} }
@ -259,7 +259,7 @@ func (l *persistentVolumeLabel) findGCEPDLabels(volume *api.PersistentVolume) (m
} }
// getGCECloudProvider returns the GCE cloud provider, for use for querying volume labels // getGCECloudProvider returns the GCE cloud provider, for use for querying volume labels
func (l *persistentVolumeLabel) getGCECloudProvider() (*gce.GCECloud, error) { func (l *persistentVolumeLabel) getGCECloudProvider() (*gce.Cloud, error) {
l.mutex.Lock() l.mutex.Lock()
defer l.mutex.Unlock() defer l.mutex.Unlock()
@ -272,7 +272,7 @@ func (l *persistentVolumeLabel) getGCECloudProvider() (*gce.GCECloud, error) {
if err != nil || cloudProvider == nil { if err != nil || cloudProvider == nil {
return nil, err return nil, err
} }
gceCloudProvider, ok := cloudProvider.(*gce.GCECloud) gceCloudProvider, ok := cloudProvider.(*gce.Cloud)
if !ok { if !ok {
// GetCloudProvider has gone very wrong // GetCloudProvider has gone very wrong
return nil, fmt.Errorf("error retrieving GCE cloud provider") return nil, fmt.Errorf("error retrieving GCE cloud provider")

2
test/e2e/framework/providers/gce/firewall.go
View File

@ -401,7 +401,7 @@ func VerifyFirewallRule(res, exp *compute.Firewall, network string, portsSubset
return nil return nil
} }
func WaitForFirewallRule(gceCloud *gcecloud.GCECloud, fwName string, exist bool, timeout time.Duration) (*compute.Firewall, error) { func WaitForFirewallRule(gceCloud *gcecloud.Cloud, fwName string, exist bool, timeout time.Duration) (*compute.Firewall, error) {
framework.Logf("Waiting up to %v for firewall %v exist=%v", timeout, fwName, exist) framework.Logf("Waiting up to %v for firewall %v exist=%v", timeout, fwName, exist)
var fw *compute.Firewall var fw *compute.Firewall
var err error var err error

10
test/e2e/framework/providers/gce/gce.go
View File

@ -58,7 +58,7 @@ func factory() (framework.ProviderInterface, error) {
} }
gceCloud, err := gcecloud.CreateGCECloud(&gcecloud.CloudConfig{ gceCloud, err := gcecloud.CreateGCECloud(&gcecloud.CloudConfig{
ApiEndpoint: framework.TestContext.CloudConfig.ApiEndpoint, APIEndpoint: framework.TestContext.CloudConfig.ApiEndpoint,
ProjectID: framework.TestContext.CloudConfig.ProjectID, ProjectID: framework.TestContext.CloudConfig.ProjectID,
Region: region, Region: region,
Zone: zone, Zone: zone,
@ -89,7 +89,7 @@ func factory() (framework.ProviderInterface, error) {
return NewProvider(gceCloud), nil return NewProvider(gceCloud), nil
} }
func NewProvider(gceCloud *gcecloud.GCECloud) framework.ProviderInterface { func NewProvider(gceCloud *gcecloud.Cloud) framework.ProviderInterface {
return &Provider{ return &Provider{
gceCloud: gceCloud, gceCloud: gceCloud,
} }
@ -97,7 +97,7 @@ func NewProvider(gceCloud *gcecloud.GCECloud) framework.ProviderInterface {
type Provider struct { type Provider struct {
framework.NullProvider framework.NullProvider
gceCloud *gcecloud.GCECloud gceCloud *gcecloud.Cloud
} }
func (p *Provider) ResizeGroup(group string, size int32) error { func (p *Provider) ResizeGroup(group string, size int32) error {
@ -279,7 +279,7 @@ func (p *Provider) cleanupGCEResources(c clientset.Interface, loadBalancerName,
return return
} }
hcNames := []string{gcecloud.MakeNodesHealthCheckName(clusterID)} hcNames := []string{gcecloud.MakeNodesHealthCheckName(clusterID)}
hc, getErr := p.gceCloud.GetHttpHealthCheck(loadBalancerName) hc, getErr := p.gceCloud.GetHTTPHealthCheck(loadBalancerName)
if getErr != nil && !IsGoogleAPIHTTPErrorCode(getErr, http.StatusNotFound) { if getErr != nil && !IsGoogleAPIHTTPErrorCode(getErr, http.StatusNotFound) {
retErr = fmt.Errorf("%v\n%v", retErr, getErr) retErr = fmt.Errorf("%v\n%v", retErr, getErr)
return return
@ -351,7 +351,7 @@ func IsGoogleAPIHTTPErrorCode(err error, code int) bool {
return ok && apiErr.Code == code return ok && apiErr.Code == code
} }
func GetGCECloud() (*gcecloud.GCECloud, error) { func GetGCECloud() (*gcecloud.Cloud, error) {
p, ok := framework.TestContext.CloudConfig.Provider.(*Provider) p, ok := framework.TestContext.CloudConfig.Provider.(*Provider)
if !ok { if !ok {
return nil, fmt.Errorf("failed to convert CloudConfig.Provider to GCE provider: %#v", framework.TestContext.CloudConfig.Provider) return nil, fmt.Errorf("failed to convert CloudConfig.Provider to GCE provider: %#v", framework.TestContext.CloudConfig.Provider)

14
test/e2e/framework/providers/gce/ingress.go
View File

@ -198,7 +198,7 @@ func (cont *GCEIngressController) deleteAddresses(del bool) string {
func (cont *GCEIngressController) ListTargetHttpProxies() []*compute.TargetHttpProxy { func (cont *GCEIngressController) ListTargetHttpProxies() []*compute.TargetHttpProxy {
gceCloud := cont.Cloud.Provider.(*Provider).gceCloud gceCloud := cont.Cloud.Provider.(*Provider).gceCloud
tpList := []*compute.TargetHttpProxy{} tpList := []*compute.TargetHttpProxy{}
l, err := gceCloud.ListTargetHttpProxies() l, err := gceCloud.ListTargetHTTPProxies()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
for _, tp := range l { for _, tp := range l {
if cont.isOwned(tp.Name) { if cont.isOwned(tp.Name) {
@ -211,7 +211,7 @@ func (cont *GCEIngressController) ListTargetHttpProxies() []*compute.TargetHttpP
func (cont *GCEIngressController) ListTargetHttpsProxies() []*compute.TargetHttpsProxy { func (cont *GCEIngressController) ListTargetHttpsProxies() []*compute.TargetHttpsProxy {
gceCloud := cont.Cloud.Provider.(*Provider).gceCloud gceCloud := cont.Cloud.Provider.(*Provider).gceCloud
tpsList := []*compute.TargetHttpsProxy{} tpsList := []*compute.TargetHttpsProxy{}
l, err := gceCloud.ListTargetHttpsProxies() l, err := gceCloud.ListTargetHTTPSProxies()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
for _, tps := range l { for _, tps := range l {
if cont.isOwned(tps.Name) { if cont.isOwned(tps.Name) {
@ -259,7 +259,7 @@ func (cont *GCEIngressController) deleteTargetProxy(del bool) string {
func (cont *GCEIngressController) ListUrlMaps() []*compute.UrlMap { func (cont *GCEIngressController) ListUrlMaps() []*compute.UrlMap {
gceCloud := cont.Cloud.Provider.(*Provider).gceCloud gceCloud := cont.Cloud.Provider.(*Provider).gceCloud
umList := []*compute.UrlMap{} umList := []*compute.UrlMap{}
l, err := gceCloud.ListUrlMaps() l, err := gceCloud.ListURLMaps()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
for _, um := range l { for _, um := range l {
if cont.isOwned(um.Name) { if cont.isOwned(um.Name) {
@ -271,7 +271,7 @@ func (cont *GCEIngressController) ListUrlMaps() []*compute.UrlMap {
func (cont *GCEIngressController) deleteURLMap(del bool) (msg string) { func (cont *GCEIngressController) deleteURLMap(del bool) (msg string) {
gceCloud := cont.Cloud.Provider.(*Provider).gceCloud gceCloud := cont.Cloud.Provider.(*Provider).gceCloud
umList, err := gceCloud.ListUrlMaps() umList, err := gceCloud.ListURLMaps()
if err != nil { if err != nil {
if cont.isHTTPErrorCode(err, http.StatusNotFound) { if cont.isHTTPErrorCode(err, http.StatusNotFound) {
return msg return msg
@ -287,7 +287,7 @@ func (cont *GCEIngressController) deleteURLMap(del bool) (msg string) {
} }
if del { if del {
framework.Logf("Deleting url-map: %s", um.Name) framework.Logf("Deleting url-map: %s", um.Name)
if err := gceCloud.DeleteUrlMap(um.Name); err != nil && if err := gceCloud.DeleteURLMap(um.Name); err != nil &&
!cont.isHTTPErrorCode(err, http.StatusNotFound) { !cont.isHTTPErrorCode(err, http.StatusNotFound) {
msg += fmt.Sprintf("Failed to delete url map %v\n", um.Name) msg += fmt.Sprintf("Failed to delete url map %v\n", um.Name)
} }
@ -343,7 +343,7 @@ func (cont *GCEIngressController) deleteBackendService(del bool) (msg string) {
func (cont *GCEIngressController) deleteHTTPHealthCheck(del bool) (msg string) { func (cont *GCEIngressController) deleteHTTPHealthCheck(del bool) (msg string) {
gceCloud := cont.Cloud.Provider.(*Provider).gceCloud gceCloud := cont.Cloud.Provider.(*Provider).gceCloud
hcList, err := gceCloud.ListHttpHealthChecks() hcList, err := gceCloud.ListHTTPHealthChecks()
if err != nil { if err != nil {
if cont.isHTTPErrorCode(err, http.StatusNotFound) { if cont.isHTTPErrorCode(err, http.StatusNotFound) {
return msg return msg
@ -359,7 +359,7 @@ func (cont *GCEIngressController) deleteHTTPHealthCheck(del bool) (msg string) {
} }
if del { if del {
framework.Logf("Deleting http-health-check: %s", hc.Name) framework.Logf("Deleting http-health-check: %s", hc.Name)
if err := gceCloud.DeleteHttpHealthCheck(hc.Name); err != nil && if err := gceCloud.DeleteHTTPHealthCheck(hc.Name); err != nil &&
!cont.isHTTPErrorCode(err, http.StatusNotFound) { !cont.isHTTPErrorCode(err, http.StatusNotFound) {
msg += fmt.Sprintf("Failed to delete HTTP health check %v\n", hc.Name) msg += fmt.Sprintf("Failed to delete HTTP health check %v\n", hc.Name)
} }

2
test/e2e/framework/test_context.go
View File

@ -252,7 +252,7 @@ func RegisterClusterFlags() {
// TODO: Flags per provider? Rename gce-project/gce-zone? // TODO: Flags per provider? Rename gce-project/gce-zone?
cloudConfig := &TestContext.CloudConfig cloudConfig := &TestContext.CloudConfig
flag.StringVar(&cloudConfig.MasterName, "kube-master", "", "Name of the kubernetes master. Only required if provider is gce or gke") flag.StringVar(&cloudConfig.MasterName, "kube-master", "", "Name of the kubernetes master. Only required if provider is gce or gke")
flag.StringVar(&cloudConfig.ApiEndpoint, "gce-api-endpoint", "", "The GCE ApiEndpoint being used, if applicable") flag.StringVar(&cloudConfig.ApiEndpoint, "gce-api-endpoint", "", "The GCE APIEndpoint being used, if applicable")
flag.StringVar(&cloudConfig.ProjectID, "gce-project", "", "The GCE project being used, if applicable") flag.StringVar(&cloudConfig.ProjectID, "gce-project", "", "The GCE project being used, if applicable")
flag.StringVar(&cloudConfig.Zone, "gce-zone", "", "GCE zone being used, if applicable") flag.StringVar(&cloudConfig.Zone, "gce-zone", "", "GCE zone being used, if applicable")
flag.StringVar(&cloudConfig.Region, "gce-region", "", "GCE region being used, if applicable") flag.StringVar(&cloudConfig.Region, "gce-region", "", "GCE region being used, if applicable")

2
test/e2e/network/firewall.go
View File

@ -39,7 +39,7 @@ var _ = SIGDescribe("Firewall rule", func() {
var cs clientset.Interface var cs clientset.Interface
var cloudConfig framework.CloudConfig var cloudConfig framework.CloudConfig
var gceCloud *gcecloud.GCECloud var gceCloud *gcecloud.Cloud
BeforeEach(func() { BeforeEach(func() {
framework.SkipUnlessProviderIs("gce") framework.SkipUnlessProviderIs("gce")

2
test/e2e/network/network_tiers.go
View File

@ -222,7 +222,7 @@ func clearNetworkTier(svc *v1.Service) {
// TODO: add retries if this turns out to be flaky. // TODO: add retries if this turns out to be flaky.
// TODO(#51665): remove this helper function once Network Tiers becomes beta. // TODO(#51665): remove this helper function once Network Tiers becomes beta.
func reserveAlphaRegionalAddress(cloud *gcecloud.GCECloud, name string, netTier cloud.NetworkTier) (string, error) { func reserveAlphaRegionalAddress(cloud *gcecloud.Cloud, name string, netTier cloud.NetworkTier) (string, error) {
alphaAddr := &computealpha.Address{ alphaAddr := &computealpha.Address{
Name: name, Name: name,
NetworkTier: netTier.ToGCEValue(), NetworkTier: netTier.ToGCEValue(),

6
test/e2e/network/service.go
View File

@ -1585,7 +1585,7 @@ var _ = SIGDescribe("Services", func() {
svc = jig.WaitForLoadBalancerOrFail(namespace, serviceName, framework.LoadBalancerCreateTimeoutDefault) svc = jig.WaitForLoadBalancerOrFail(namespace, serviceName, framework.LoadBalancerCreateTimeoutDefault)
hcName := gcecloud.MakeNodesHealthCheckName(clusterID) hcName := gcecloud.MakeNodesHealthCheckName(clusterID)
hc, err := gceCloud.GetHttpHealthCheck(hcName) hc, err := gceCloud.GetHTTPHealthCheck(hcName)
if err != nil { if err != nil {
framework.Failf("gceCloud.GetHttpHealthCheck(%q) = _, %v; want nil", hcName, err) framework.Failf("gceCloud.GetHttpHealthCheck(%q) = _, %v; want nil", hcName, err)
} }
@ -1593,7 +1593,7 @@ var _ = SIGDescribe("Services", func() {
By("modify the health check interval") By("modify the health check interval")
hc.CheckIntervalSec = gceHcCheckIntervalSeconds - 1 hc.CheckIntervalSec = gceHcCheckIntervalSeconds - 1
if err = gceCloud.UpdateHttpHealthCheck(hc); err != nil { if err = gceCloud.UpdateHTTPHealthCheck(hc); err != nil {
framework.Failf("gcecloud.UpdateHttpHealthCheck(%#v) = %v; want nil", hc, err) framework.Failf("gcecloud.UpdateHttpHealthCheck(%#v) = %v; want nil", hc, err)
} }
@ -1608,7 +1608,7 @@ var _ = SIGDescribe("Services", func() {
By("health check should be reconciled") By("health check should be reconciled")
pollInterval := framework.Poll * 10 pollInterval := framework.Poll * 10
if pollErr := wait.PollImmediate(pollInterval, framework.LoadBalancerCreateTimeoutDefault, func() (bool, error) { if pollErr := wait.PollImmediate(pollInterval, framework.LoadBalancerCreateTimeoutDefault, func() (bool, error) {
hc, err := gceCloud.GetHttpHealthCheck(hcName) hc, err := gceCloud.GetHTTPHealthCheck(hcName)
if err != nil { if err != nil {
framework.Logf("Failed to get HttpHealthCheck(%q): %v", hcName, err) framework.Logf("Failed to get HttpHealthCheck(%q): %v", hcName, err)
return false, err return false, err

4
test/integration/util/cloud.go
View File

@ -52,9 +52,9 @@ func (*mockTokenSource) Token() (*oauth2.Token, error) {
}, nil }, nil
} }
// NewMockGCECloud returns a handle to a GCECloud instance that is // NewMockGCECloud returns a handle to a Cloud instance that is
// served by a mock http server // served by a mock http server
func NewMockGCECloud(cloud cloud.Cloud) (*gce.GCECloud, error) { func NewMockGCECloud(cloud cloud.Cloud) (*gce.Cloud, error) {
config := &gce.CloudConfig{ config := &gce.CloudConfig{
ProjectID: TestProjectID, ProjectID: TestProjectID,
NetworkProjectID: TestNetworkProjectID, NetworkProjectID: TestNetworkProjectID,