Update vendored dependencies

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/BUILD

@@ -14,6 +14,7 @@ go_library(
         "doc.go",
         "gce.go",
         "gce_addresses.go",
+        "gce_addresses_fakes.go",
         "gce_annotations.go",
         "gce_backendservice.go",
         "gce_cert.go",
@@ -25,6 +26,7 @@ go_library(
         "gce_healthchecks.go",
         "gce_instancegroup.go",
         "gce_instances.go",
+        "gce_interfaces.go",
         "gce_loadbalancer.go",
         "gce_loadbalancer_external.go",
         "gce_loadbalancer_internal.go",
@@ -42,7 +44,6 @@ go_library(
     tags = ["automanaged"],
     deps = [
         "//pkg/api/v1/service:go_default_library",
-        "//pkg/client/clientset_generated/clientset:go_default_library",
         "//pkg/cloudprovider:go_default_library",
         "//pkg/controller:go_default_library",
         "//pkg/kubelet/apis:go_default_library",
@@ -71,6 +72,7 @@ go_library(
         "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/client-go/tools/cache:go_default_library",
         "//vendor/k8s.io/client-go/util/flowcontrol:go_default_library",
     ],
@@ -81,6 +83,7 @@ go_test(
     srcs = [
         "gce_disks_test.go",
         "gce_healthchecks_test.go",
+        "gce_loadbalancer_external_test.go",
         "gce_test.go",
     ],
     library = ":go_default_library",

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce.go

@@ -198,11 +198,11 @@ func newGCECloud(config io.Reader) (*GCECloud, error) {
 	var nodeTags []string
 	var nodeInstancePrefix string
 	if config != nil {
-		var cfg Config
-		if err := gcfg.ReadInto(&cfg, config); err != nil {
-			glog.Errorf("Couldn't read config: %v", err)
+		cfg, err := readConfig(config)
+		if err != nil {
 			return nil, err
 		}
+
 		glog.Infof("Using GCE provider config %+v", cfg)
 		if cfg.Global.ApiEndpoint != "" {
 			apiEndpoint = cfg.Global.ApiEndpoint
@@ -211,17 +211,22 @@ func newGCECloud(config io.Reader) (*GCECloud, error) {
 			projectID = cfg.Global.ProjectID
 		}
 
-		if cfg.Global.NetworkName != "" && strings.Contains(cfg.Global.NetworkName, "/") {
-			networkURL = cfg.Global.NetworkName
-		} else {
-			networkURL = gceNetworkURL(apiEndpoint, projectID, networkName)
+		if cfg.Global.NetworkName != "" {
+			if strings.Contains(cfg.Global.NetworkName, "/") {
+				networkURL = cfg.Global.NetworkName
+			} else {
+				networkURL = gceNetworkURL(apiEndpoint, projectID, cfg.Global.NetworkName)
+			}
 		}
 
-		if cfg.Global.SubnetworkName != "" && strings.Contains(cfg.Global.SubnetworkName, "/") {
-			subnetworkURL = cfg.Global.SubnetworkName
-		} else {
-			subnetworkURL = gceSubnetworkURL(apiEndpoint, cfg.Global.ProjectID, region, cfg.Global.SubnetworkName)
+		if cfg.Global.SubnetworkName != "" {
+			if strings.Contains(cfg.Global.SubnetworkName, "/") {
+				subnetworkURL = cfg.Global.SubnetworkName
+			} else {
+				subnetworkURL = gceSubnetworkURL(apiEndpoint, projectID, region, cfg.Global.SubnetworkName)
+			}
 		}
+
 		if cfg.Global.TokenURL != "" {
 			tokenSource = NewAltTokenSource(cfg.Global.TokenURL, cfg.Global.TokenBody)
 		}
@@ -236,6 +241,15 @@ func newGCECloud(config io.Reader) (*GCECloud, error) {
 		nodeTags, nodeInstancePrefix, tokenSource, true /* useMetadataServer */)
 }
 
+func readConfig(reader io.Reader) (*Config, error) {
+	cfg := &Config{}
+	if err := gcfg.FatalOnly(gcfg.ReadInto(cfg, reader)); err != nil {
+		glog.Errorf("Couldn't read config: %v", err)
+		return nil, err
+	}
+	return cfg, nil
+}
+
 // Creates a GCECloud object using the specified parameters.
 // If no networkUrl is specified, loads networkName via rest call.
 // If no tokenSource is specified, uses oauth2.DefaultTokenSource.
@@ -318,6 +332,7 @@ func CreateGCECloud(apiEndpoint, projectID, region, zone string, managedZones []
 
 	gce := &GCECloud{
 		service:                  service,
+		serviceAlpha:             serviceAlpha,
 		serviceBeta:              serviceBeta,
 		containerService:         containerService,
 		cloudkmsService:          cloudkmsService,

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_addresses_fakes.go

@@ -0,0 +1,77 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package gce
+
+import (
+	"fmt"
+	"net/http"
+
+	compute "google.golang.org/api/compute/v1"
+	"google.golang.org/api/googleapi"
+)
+
+type FakeCloudAddressService struct {
+	count int
+	// reservedAddrs tracks usage of IP addresses
+	// Key is the IP address as a string
+	reservedAddrs map[string]bool
+	// addrsByRegionAndName
+	// Outer key is for region string; inner key is for address name.
+	addrsByRegionAndName map[string]map[string]*compute.Address
+}
+
+func NewFakeCloudAddressService() *FakeCloudAddressService {
+	return &FakeCloudAddressService{
+		reservedAddrs:        make(map[string]bool),
+		addrsByRegionAndName: make(map[string]map[string]*compute.Address),
+	}
+}
+
+func (cas *FakeCloudAddressService) ReserveRegionAddress(addr *compute.Address, region string) error {
+	if addr.Address == "" {
+		addr.Address = fmt.Sprintf("1.2.3.%d", cas.count)
+		cas.count++
+	}
+
+	if cas.reservedAddrs[addr.Address] {
+		return &googleapi.Error{Code: http.StatusConflict}
+	}
+
+	if _, exists := cas.addrsByRegionAndName[region]; !exists {
+		cas.addrsByRegionAndName[region] = make(map[string]*compute.Address)
+	}
+
+	if _, exists := cas.addrsByRegionAndName[region][addr.Name]; exists {
+		return &googleapi.Error{Code: http.StatusConflict}
+	}
+
+	cas.addrsByRegionAndName[region][addr.Name] = addr
+	cas.reservedAddrs[addr.Address] = true
+	return nil
+}
+
+func (cas *FakeCloudAddressService) GetRegionAddress(name, region string) (*compute.Address, error) {
+	if _, exists := cas.addrsByRegionAndName[region]; !exists {
+		return nil, &googleapi.Error{Code: http.StatusNotFound}
+	}
+
+	if addr, exists := cas.addrsByRegionAndName[region][name]; !exists {
+		return nil, &googleapi.Error{Code: http.StatusNotFound}
+	} else {
+		return addr, nil
+	}
+}

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_clusterid.go

@@ -31,8 +31,8 @@ import (
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/watch"
+	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/clientset"
 )
 
 const (

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_forwardingrule.go

@@ -29,27 +29,14 @@ func newForwardingRuleMetricContext(request, region string) *metricContext {
 	}
 }
 
-// CreateGlobalForwardingRule creates and returns a
-// GlobalForwardingRule that points to the given TargetHttp(s)Proxy.
-// targetProxyLink is the SelfLink of a TargetHttp(s)Proxy.
-func (gce *GCECloud) CreateGlobalForwardingRule(targetProxyLink, ip, name, portRange string) (*compute.ForwardingRule, error) {
+// CreateGlobalForwardingRule creates the passed GlobalForwardingRule
+func (gce *GCECloud) CreateGlobalForwardingRule(rule *compute.ForwardingRule) error {
 	mc := newForwardingRuleMetricContext("create", "")
-	rule := &compute.ForwardingRule{
-		Name:       name,
-		IPAddress:  ip,
-		Target:     targetProxyLink,
-		PortRange:  portRange,
-		IPProtocol: "TCP",
-	}
 	op, err := gce.service.GlobalForwardingRules.Insert(gce.projectID, rule).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
-	if err = gce.waitForGlobalOp(op, mc); err != nil {
-		return nil, err
-	}
-
-	return gce.GetGlobalForwardingRule(name)
+	return gce.waitForGlobalOp(op, mc)
 }
 
 // SetProxyForGlobalForwardingRule links the given TargetHttp(s)Proxy with the given GlobalForwardingRule.

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_healthchecks.go

@@ -37,8 +37,8 @@ var (
 )
 
 func init() {
-	if v, err := utilversion.ParseGeneric("1.7.0"); err != nil {
-		panic(err)
+	if v, err := utilversion.ParseGeneric("1.7.2"); err != nil {
+		glog.Fatalf("Failed to parse version for minNodesHealthCheckVersion: %v", err)
 	} else {
 		minNodesHealthCheckVersion = v
 	}

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_instancegroup.go

@@ -31,20 +31,14 @@ func newInstanceGroupMetricContext(request string, zone string) *metricContext {
 
 // CreateInstanceGroup creates an instance group with the given
 // instances. It is the callers responsibility to add named ports.
-func (gce *GCECloud) CreateInstanceGroup(name string, zone string) (*compute.InstanceGroup, error) {
+func (gce *GCECloud) CreateInstanceGroup(ig *compute.InstanceGroup, zone string) error {
 	mc := newInstanceGroupMetricContext("create", zone)
-	op, err := gce.service.InstanceGroups.Insert(
-		gce.projectID, zone, &compute.InstanceGroup{Name: name}).Do()
+	op, err := gce.service.InstanceGroups.Insert(gce.projectID, zone, ig).Do()
 	if err != nil {
-		mc.Observe(err)
-		return nil, err
+		return mc.Observe(err)
 	}
 
-	if err = gce.waitForZoneOp(op, zone, mc); err != nil {
-		return nil, err
-	}
-
-	return gce.GetInstanceGroup(name, zone)
+	return gce.waitForZoneOp(op, zone, mc)
 }
 
 // DeleteInstanceGroup deletes an instance group.

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_interfaces.go

@@ -0,0 +1,27 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package gce
+
+import compute "google.golang.org/api/compute/v1"
+
+// CloudAddressService is an interface for managing addresses
+type CloudAddressService interface {
+	ReserveRegionAddress(*compute.Address, string) error
+	GetRegionAddress(string, string) (*compute.Address, error)
+	// TODO: Mock `DeleteRegionAddress(name, region string) endpoint
+	// TODO: Mock Global endpoints
+}

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_loadbalancer_external.go

@@ -140,7 +140,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName, clusterID string, a
 			// to this forwarding rule, so we can keep it.
 			isUserOwnedIP = false
 			isSafeToReleaseIP = true
-			ipAddress, _, err = gce.ensureStaticIP(loadBalancerName, serviceName.String(), gce.region, fwdRuleIP)
+			ipAddress, _, err = ensureStaticIP(gce, loadBalancerName, serviceName.String(), gce.region, fwdRuleIP)
 			if err != nil {
 				return nil, fmt.Errorf("failed to ensure static IP %s: %v", fwdRuleIP, err)
 			}
@@ -161,7 +161,7 @@ func (gce *GCECloud) ensureExternalLoadBalancer(clusterName, clusterID string, a
 		// IP from ephemeral to static, or it will just get the IP if it is
 		// already static.
 		existed := false
-		ipAddress, existed, err = gce.ensureStaticIP(loadBalancerName, serviceName.String(), gce.region, fwdRuleIP)
+		ipAddress, existed, err = ensureStaticIP(gce, loadBalancerName, serviceName.String(), gce.region, fwdRuleIP)
 		if err != nil {
 			return nil, fmt.Errorf("failed to ensure static IP %s: %v", fwdRuleIP, err)
 		}
@@ -494,7 +494,7 @@ func (gce *GCECloud) createTargetPool(name, serviceName, ipAddress, region, clus
 		HealthChecks:    hcLinks,
 	}
 
-	if _, err := gce.CreateTargetPool(pool, region); err != nil && !isHTTPErrorCode(err, http.StatusConflict) {
+	if err := gce.CreateTargetPool(pool, region); err != nil && !isHTTPErrorCode(err, http.StatusConflict) {
 		return err
 	}
 	return nil
@@ -906,7 +906,7 @@ func (gce *GCECloud) projectOwnsStaticIP(name, region string, ipAddress string)
 	return false, nil
 }
 
-func (gce *GCECloud) ensureStaticIP(name, serviceName, region, existingIP string) (ipAddress string, created bool, err error) {
+func ensureStaticIP(s CloudAddressService, name, serviceName, region, existingIP string) (ipAddress string, existing bool, err error) {
 	// If the address doesn't exist, this will create it.
 	// If the existingIP exists but is ephemeral, this will promote it to static.
 	// If the address already exists, this will harmlessly return a StatusConflict
@@ -921,7 +921,7 @@ func (gce *GCECloud) ensureStaticIP(name, serviceName, region, existingIP string
 		addressObj.Address = existingIP
 	}
 
-	if err = gce.ReserveRegionAddress(addressObj, region); err != nil {
+	if err = s.ReserveRegionAddress(addressObj, region); err != nil {
 		if !isHTTPErrorCode(err, http.StatusConflict) {
 			return "", false, fmt.Errorf("error creating gce static IP address: %v", err)
 		}
@@ -929,7 +929,7 @@ func (gce *GCECloud) ensureStaticIP(name, serviceName, region, existingIP string
 		existed = true
 	}
 
-	addr, err := gce.GetRegionAddress(name, region)
+	addr, err := s.GetRegionAddress(name, region)
 	if err != nil {
 		return "", false, fmt.Errorf("error getting static IP address: %v", err)
 	}

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_loadbalancer_internal.go

@@ -376,7 +376,12 @@ func (gce *GCECloud) ensureInternalInstanceGroup(name, zone string, nodes []*v1.
 	gceNodes := sets.NewString()
 	if ig == nil {
 		glog.V(2).Infof("ensureInternalInstanceGroup(%v, %v): creating instance group", name, zone)
-		ig, err = gce.CreateInstanceGroup(name, zone)
+		newIG := &compute.InstanceGroup{Name: name}
+		if err = gce.CreateInstanceGroup(newIG, zone); err != nil {
+			return "", err
+		}
+
+		ig, err = gce.GetInstanceGroup(name, zone)
 		if err != nil {
 			return "", err
 		}

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_targetpool.go

@@ -37,18 +37,14 @@ func (gce *GCECloud) GetTargetPool(name, region string) (*compute.TargetPool, er
 }
 
 // CreateTargetPool creates the passed TargetPool
-func (gce *GCECloud) CreateTargetPool(tp *compute.TargetPool, region string) (*compute.TargetPool, error) {
+func (gce *GCECloud) CreateTargetPool(tp *compute.TargetPool, region string) error {
 	mc := newTargetPoolMetricContext("create", region)
 	op, err := gce.service.TargetPools.Insert(gce.projectID, region, tp).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
 
-	if err := gce.waitForRegionOp(op, region, mc); err != nil {
-		return nil, err
-	}
-
-	return gce.GetTargetPool(tp.Name, region)
+	return gce.waitForRegionOp(op, region, mc)
 }
 
 // DeleteTargetPool deletes TargetPool by name.

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_targetproxy.go

@@ -37,22 +37,14 @@ func (gce *GCECloud) GetTargetHttpProxy(name string) (*compute.TargetHttpProxy,
 	return v, mc.Observe(err)
 }
 
-// CreateTargetHttpProxy creates and returns a TargetHttpProxy with the given UrlMap.
-func (gce *GCECloud) CreateTargetHttpProxy(urlMap *compute.UrlMap, name string) (*compute.TargetHttpProxy, error) {
-	proxy := &compute.TargetHttpProxy{
-		Name:   name,
-		UrlMap: urlMap.SelfLink,
-	}
-
+// CreateTargetHttpProxy creates a TargetHttpProxy
+func (gce *GCECloud) CreateTargetHttpProxy(proxy *compute.TargetHttpProxy) error {
 	mc := newTargetProxyMetricContext("create")
 	op, err := gce.service.TargetHttpProxies.Insert(gce.projectID, proxy).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
-	if err = gce.waitForGlobalOp(op, mc); err != nil {
-		return nil, err
-	}
-	return gce.GetTargetHttpProxy(name)
+	return gce.waitForGlobalOp(op, mc)
 }
 
 // SetUrlMapForTargetHttpProxy sets the given UrlMap for the given TargetHttpProxy.
@@ -96,22 +88,14 @@ func (gce *GCECloud) GetTargetHttpsProxy(name string) (*compute.TargetHttpsProxy
 	return v, mc.Observe(err)
 }
 
-// CreateTargetHttpsProxy creates and returns a TargetHttpsProxy with the given UrlMap and SslCertificate.
-func (gce *GCECloud) CreateTargetHttpsProxy(urlMap *compute.UrlMap, sslCert *compute.SslCertificate, name string) (*compute.TargetHttpsProxy, error) {
+// CreateTargetHttpsProxy creates a TargetHttpsProxy
+func (gce *GCECloud) CreateTargetHttpsProxy(proxy *compute.TargetHttpsProxy) error {
 	mc := newTargetProxyMetricContext("create")
-	proxy := &compute.TargetHttpsProxy{
-		Name:            name,
-		UrlMap:          urlMap.SelfLink,
-		SslCertificates: []string{sslCert.SelfLink},
-	}
 	op, err := gce.service.TargetHttpsProxies.Insert(gce.projectID, proxy).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
-	if err = gce.waitForGlobalOp(op, mc); err != nil {
-		return nil, err
-	}
-	return gce.GetTargetHttpsProxy(name)
+	return gce.waitForGlobalOp(op, mc)
 }
 
 // SetUrlMapForTargetHttpsProxy sets the given UrlMap for the given TargetHttpsProxy.

vendor/k8s.io/kubernetes/pkg/cloudprovider/providers/gce/gce_urlmap.go

@@ -37,34 +37,24 @@ func (gce *GCECloud) GetUrlMap(name string) (*compute.UrlMap, error) {
 	return v, mc.Observe(err)
 }
 
-// CreateUrlMap creates an url map, using the given backend service as the default service.
-func (gce *GCECloud) CreateUrlMap(backend *compute.BackendService, name string) (*compute.UrlMap, error) {
-	urlMap := &compute.UrlMap{
-		Name:           name,
-		DefaultService: backend.SelfLink,
-	}
+// CreateUrlMap creates a url map
+func (gce *GCECloud) CreateUrlMap(urlMap *compute.UrlMap) error {
 	mc := newUrlMapMetricContext("create")
 	op, err := gce.service.UrlMaps.Insert(gce.projectID, urlMap).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
-	if err = gce.waitForGlobalOp(op, mc); err != nil {
-		return nil, err
-	}
-	return gce.GetUrlMap(name)
+	return gce.waitForGlobalOp(op, mc)
 }
 
-// UpdateUrlMap applies the given UrlMap as an update, and returns the new UrlMap.
-func (gce *GCECloud) UpdateUrlMap(urlMap *compute.UrlMap) (*compute.UrlMap, error) {
+// UpdateUrlMap applies the given UrlMap as an update
+func (gce *GCECloud) UpdateUrlMap(urlMap *compute.UrlMap) error {
 	mc := newUrlMapMetricContext("update")
 	op, err := gce.service.UrlMaps.Update(gce.projectID, urlMap.Name, urlMap).Do()
 	if err != nil {
-		return nil, mc.Observe(err)
+		return mc.Observe(err)
 	}
-	if err = gce.waitForGlobalOp(op, mc); err != nil {
-		return nil, err
-	}
-	return gce.service.UrlMaps.Get(gce.projectID, urlMap.Name).Do()
+	return gce.waitForGlobalOp(op, mc)
 }
 
 // DeleteUrlMap deletes a url map by name.