adapt gce controller to godep updates

.gitignore

@@ -2,6 +2,9 @@
 ._*
 .DS_Store
 
+# intellij files
+.idea/*
+
 # Eclipse files
 .classpath
 .project

controllers/gce/backends/backends.go

@@ -161,7 +161,7 @@ func (b *Backends) Init(pp probeProvider) {
 
 // Get returns a single backend.
 func (b *Backends) Get(port int64) (*compute.BackendService, error) {
-	be, err := b.cloud.GetBackendService(b.namer.BeName(port))
+	be, err := b.cloud.GetGlobalBackendService(b.namer.BeName(port))
 	if err != nil {
 		return nil, err
 	}
@@ -203,7 +203,7 @@ func (b *Backends) create(namedPort *compute.NamedPort, hcLink string, sp Servic
 		Port:         namedPort.Port,
 		PortName:     namedPort.Name,
 	}
-	if err := b.cloud.CreateBackendService(bs); err != nil {
+	if err := b.cloud.CreateGlobalBackendService(bs); err != nil {
 		return nil, err
 	}
 	return b.Get(namedPort.Port)
@@ -248,7 +248,7 @@ func (b *Backends) Add(p ServicePort) error {
 		be.Protocol = string(p.Protocol)
 		be.HealthChecks = []string{hcLink}
 		be.Description = p.Description()
-		if err = b.cloud.UpdateBackendService(be); err != nil {
+		if err = b.cloud.UpdateGlobalBackendService(be); err != nil {
 			return err
 		}
 	}
@@ -282,7 +282,7 @@ func (b *Backends) Delete(port int64) (err error) {
 		}
 	}()
 	// Try deleting health checks even if a backend is not found.
-	if err = b.cloud.DeleteBackendService(name); err != nil && !utils.IsHTTPErrorCode(err, http.StatusNotFound) {
+	if err = b.cloud.DeleteGlobalBackendService(name); err != nil && !utils.IsHTTPErrorCode(err, http.StatusNotFound) {
 		return err
 	}
 
@@ -294,7 +294,7 @@ func (b *Backends) List() ([]interface{}, error) {
 	// TODO: for consistency with the rest of this sub-package this method
 	// should return a list of backend ports.
 	interList := []interface{}{}
-	be, err := b.cloud.ListBackendServices()
+	be, err := b.cloud.ListGlobalBackendServices()
 	if err != nil {
 		return interList, err
 	}
@@ -361,7 +361,7 @@ func (b *Backends) edgeHop(be *compute.BackendService, igs []*compute.InstanceGr
 		newBackends := getBackendsForIGs(addIGs, bm)
 		be.Backends = append(originalBackends, newBackends...)
 
-		if err := b.cloud.UpdateBackendService(be); err != nil {
+		if err := b.cloud.UpdateGlobalBackendService(be); err != nil {
 			if utils.IsHTTPErrorCode(err, http.StatusBadRequest) {
 				glog.V(2).Infof("Updating backend service backends with balancing mode %v failed, will try another mode. err:%v", bm, err)
 				errs = append(errs, err.Error())
@@ -427,14 +427,14 @@ func (b *Backends) Shutdown() error {
 
 // Status returns the status of the given backend by name.
 func (b *Backends) Status(name string) string {
-	backend, err := b.cloud.GetBackendService(name)
+	backend, err := b.cloud.GetGlobalBackendService(name)
 	if err != nil || len(backend.Backends) == 0 {
 		return "Unknown"
 	}
 
 	// TODO: Look at more than one backend's status
 	// TODO: Include port, ip in the status, since it's in the health info.
-	hs, err := b.cloud.GetHealth(name, backend.Backends[0].Group)
+	hs, err := b.cloud.GetGlobalBackendServiceHealth(name, backend.Backends[0].Group)
 	if err != nil || len(hs.HealthStatus) == 0 || hs.HealthStatus[0] == nil {
 		return "Unknown"
 	}

controllers/gce/backends/backends_test.go

@@ -87,7 +87,7 @@ func TestBackendPoolAdd(t *testing.T) {
 			beName := namer.BeName(nodePort.Port)
 
 			// Check that the new backend has the right port
-			be, err := f.GetBackendService(beName)
+			be, err := f.GetGlobalBackendService(beName)
 			if err != nil {
 				t.Fatalf("Did not find expected backend %v", beName)
 			}
@@ -171,7 +171,7 @@ func TestBackendPoolUpdate(t *testing.T) {
 	pool.Add(p)
 	beName := namer.BeName(p.Port)
 
-	be, err := f.GetBackendService(beName)
+	be, err := f.GetGlobalBackendService(beName)
 	if err != nil {
 		t.Fatalf("Unexpected err: %v", err)
 	}
@@ -190,7 +190,7 @@ func TestBackendPoolUpdate(t *testing.T) {
 	p.Protocol = utils.ProtocolHTTPS
 	pool.Sync([]ServicePort{p})
 
-	be, err = f.GetBackendService(beName)
+	be, err = f.GetGlobalBackendService(beName)
 	if err != nil {
 		t.Fatalf("Unexpected err retrieving backend service after update: %v", err)
 	}
@@ -217,23 +217,23 @@ func TestBackendPoolChaosMonkey(t *testing.T) {
 	pool.Add(nodePort)
 	beName := namer.BeName(nodePort.Port)
 
-	be, _ := f.GetBackendService(beName)
+	be, _ := f.GetGlobalBackendService(beName)
 
 	// Mess up the link between backend service and instance group.
 	// This simulates a user doing foolish things through the UI.
 	be.Backends = []*compute.Backend{
 		{Group: "test edge hop"},
 	}
 	f.calls = []int{}
-	f.UpdateBackendService(be)
+	f.UpdateGlobalBackendService(be)
 
 	pool.Add(nodePort)
 	for _, call := range f.calls {
 		if call == utils.Create {
 			t.Fatalf("Unexpected create for existing backend service")
 		}
 	}
-	gotBackend, err := f.GetBackendService(beName)
+	gotBackend, err := f.GetGlobalBackendService(beName)
 	if err != nil {
 		t.Fatalf("Failed to find a backend with name %v: %v", beName, err)
 	}
@@ -296,12 +296,12 @@ func TestBackendPoolSync(t *testing.T) {
 	// k8s-be-3001--uid - another cluster tagged with uid
 	unrelatedBackends := sets.NewString([]string{"foo", "k8s-be-foo", "k8s--bar--foo", "k8s-be-30001--uid"}...)
 	for _, name := range unrelatedBackends.List() {
-		f.CreateBackendService(&compute.BackendService{Name: name})
+		f.CreateGlobalBackendService(&compute.BackendService{Name: name})
 	}
 
 	namer := &utils.Namer{}
 	// This backend should get deleted again since it is managed by this cluster.
-	f.CreateBackendService(&compute.BackendService{Name: namer.BeName(deletedPorts[0].Port)})
+	f.CreateGlobalBackendService(&compute.BackendService{Name: namer.BeName(deletedPorts[0].Port)})
 
 	// TODO: Avoid casting.
 	// Repopulate the pool with a cloud list, which now includes the 82 port
@@ -311,7 +311,7 @@ func TestBackendPoolSync(t *testing.T) {
 
 	pool.GC(svcNodePorts)
 
-	currBackends, _ := f.ListBackendServices()
+	currBackends, _ := f.ListGlobalBackendServices()
 	currSet := sets.NewString()
 	for _, b := range currBackends.Items {
 		currSet.Insert(b.Name)
@@ -355,7 +355,7 @@ func TestBackendPoolDeleteLegacyHealthChecks(t *testing.T) {
 	}
 
 	// Create backend service with expected name and link to legacy health check
-	f.CreateBackendService(&compute.BackendService{
+	f.CreateGlobalBackendService(&compute.BackendService{
 		Name:         beName,
 		HealthChecks: []string{hc.SelfLink},
 	})
@@ -390,7 +390,7 @@ func TestBackendPoolShutdown(t *testing.T) {
 	// Add a backend-service and verify that it doesn't exist after Shutdown()
 	pool.Add(ServicePort{Port: 80})
 	pool.Shutdown()
-	if _, err := f.GetBackendService(namer.BeName(80)); err == nil {
+	if _, err := f.GetGlobalBackendService(namer.BeName(80)); err == nil {
 		t.Fatalf("%v", err)
 	}
 }
@@ -404,7 +404,7 @@ func TestBackendInstanceGroupClobbering(t *testing.T) {
 	// This will add the instance group k8s-ig to the instance pool
 	pool.Add(ServicePort{Port: 80})
 
-	be, err := f.GetBackendService(namer.BeName(80))
+	be, err := f.GetGlobalBackendService(namer.BeName(80))
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
@@ -415,13 +415,13 @@ func TestBackendInstanceGroupClobbering(t *testing.T) {
 		{Group: "k8s-ig-foo"},
 	}
 	be.Backends = append(be.Backends, newGroups...)
-	if err = f.UpdateBackendService(be); err != nil {
+	if err = f.UpdateGlobalBackendService(be); err != nil {
 		t.Fatalf("Failed to update backend service %v", be.Name)
 	}
 
 	// Make sure repeated adds don't clobber the inserted instance group
 	pool.Add(ServicePort{Port: 80})
-	be, err = f.GetBackendService(namer.BeName(80))
+	be, err = f.GetGlobalBackendService(namer.BeName(80))
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
@@ -463,7 +463,7 @@ func TestBackendCreateBalancingMode(t *testing.T) {
 		}
 
 		pool.Add(nodePort)
-		be, err := f.GetBackendService(namer.BeName(nodePort.Port))
+		be, err := f.GetGlobalBackendService(namer.BeName(nodePort.Port))
 		if err != nil {
 			t.Fatalf("%v", err)
 		}

controllers/gce/backends/fakes.go

@@ -44,8 +44,8 @@ type FakeBackendServices struct {
 	errFunc         func(op int, be *compute.BackendService) error
 }
 
-// GetBackendService fakes getting a backend service from the cloud.
-func (f *FakeBackendServices) GetBackendService(name string) (*compute.BackendService, error) {
+// GetGlobalBackendService fakes getting a backend service from the cloud.
+func (f *FakeBackendServices) GetGlobalBackendService(name string) (*compute.BackendService, error) {
 	f.calls = append(f.calls, utils.Get)
 	obj, exists, err := f.backendServices.GetByKey(name)
 	if !exists {
@@ -62,8 +62,8 @@ func (f *FakeBackendServices) GetBackendService(name string) (*compute.BackendSe
 	return nil, fmt.Errorf("backend service %v not found", name)
 }
 
-// CreateBackendService fakes backend service creation.
-func (f *FakeBackendServices) CreateBackendService(be *compute.BackendService) error {
+// CreateGlobalBackendService fakes backend service creation.
+func (f *FakeBackendServices) CreateGlobalBackendService(be *compute.BackendService) error {
 	if f.errFunc != nil {
 		if err := f.errFunc(utils.Create, be); err != nil {
 			return err
@@ -74,8 +74,8 @@ func (f *FakeBackendServices) CreateBackendService(be *compute.BackendService) e
 	return f.backendServices.Update(be)
 }
 
-// DeleteBackendService fakes backend service deletion.
-func (f *FakeBackendServices) DeleteBackendService(name string) error {
+// DeleteGlobalBackendService fakes backend service deletion.
+func (f *FakeBackendServices) DeleteGlobalBackendService(name string) error {
 	f.calls = append(f.calls, utils.Delete)
 	svc, exists, err := f.backendServices.GetByKey(name)
 	if !exists {
@@ -87,8 +87,8 @@ func (f *FakeBackendServices) DeleteBackendService(name string) error {
 	return f.backendServices.Delete(svc)
 }
 
-// ListBackendServices fakes backend service listing.
-func (f *FakeBackendServices) ListBackendServices() (*compute.BackendServiceList, error) {
+// ListGlobalBackendServices fakes backend service listing.
+func (f *FakeBackendServices) ListGlobalBackendServices() (*compute.BackendServiceList, error) {
 	var svcs []*compute.BackendService
 	for _, s := range f.backendServices.List() {
 		svc := s.(*compute.BackendService)
@@ -97,8 +97,8 @@ func (f *FakeBackendServices) ListBackendServices() (*compute.BackendServiceList
 	return &compute.BackendServiceList{Items: svcs}, nil
 }
 
-// UpdateBackendService fakes updating a backend service.
-func (f *FakeBackendServices) UpdateBackendService(be *compute.BackendService) error {
+// UpdateGlobalBackendService fakes updating a backend service.
+func (f *FakeBackendServices) UpdateGlobalBackendService(be *compute.BackendService) error {
 	if f.errFunc != nil {
 		if err := f.errFunc(utils.Update, be); err != nil {
 			return err
@@ -108,9 +108,9 @@ func (f *FakeBackendServices) UpdateBackendService(be *compute.BackendService) e
 	return f.backendServices.Update(be)
 }
 
-// GetHealth fakes getting backend service health.
-func (f *FakeBackendServices) GetHealth(name, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
-	be, err := f.GetBackendService(name)
+// GetGlobalBackendServiceHealth fakes getting backend service health.
+func (f *FakeBackendServices) GetGlobalBackendServiceHealth(name, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error) {
+	be, err := f.GetGlobalBackendService(name)
 	if err != nil {
 		return nil, err
 	}

controllers/gce/backends/interfaces.go

@@ -42,10 +42,10 @@ type BackendPool interface {
 
 // BackendServices is an interface for managing gce backend services.
 type BackendServices interface {
-	GetBackendService(name string) (*compute.BackendService, error)
-	UpdateBackendService(bg *compute.BackendService) error
-	CreateBackendService(bg *compute.BackendService) error
-	DeleteBackendService(name string) error
-	ListBackendServices() (*compute.BackendServiceList, error)
-	GetHealth(name, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error)
+	GetGlobalBackendService(name string) (*compute.BackendService, error)
+	UpdateGlobalBackendService(bg *compute.BackendService) error
+	CreateGlobalBackendService(bg *compute.BackendService) error
+	DeleteGlobalBackendService(name string) error
+	ListGlobalBackendServices() (*compute.BackendServiceList, error)
+	GetGlobalBackendServiceHealth(name, instanceGroupLink string) (*compute.BackendServiceGroupHealth, error)
 }

controllers/gce/controller/cluster_manager.go

@@ -224,7 +224,7 @@ func getGCEClient(config io.Reader) *gce.GCECloud {
 			// user has no need for Ingress in this case. If they grant
 			// permissions to the node they will have to restart the controller
 			// manually to re-create the client.
-			if _, err = cloud.ListBackendServices(); err == nil || utils.IsHTTPErrorCode(err, http.StatusForbidden) {
+			if _, err = cloud.ListGlobalBackendServices(); err == nil || utils.IsHTTPErrorCode(err, http.StatusForbidden) {
 				return cloud
 			}
 			glog.Warningf("Failed to list backend services, retrying: %v", err)

controllers/gce/controller/controller_test.go

@@ -428,7 +428,7 @@ func TestLbChangeStaticIP(t *testing.T) {
 	}
 
 	ing.Annotations = map[string]string{staticIPNameKey: "testip"}
-	cm.fakeLbs.ReserveGlobalStaticIP("testip", "1.2.3.4")
+	cm.fakeLbs.ReserveGlobalAddress(&compute.Address{Name: "testip", Address: "1.2.3.4"})
 
 	// Second sync reassigns 1.2.3.4 to existing forwarding rule (by recreating it)
 	lbc.sync(ingStoreKey)

controllers/gce/controller/fakes.go

@@ -65,7 +65,7 @@ func NewFakeClusterManager(clusterName, firewallName string) *fakeClusterManager
 		testDefaultBeNodePort,
 		namer,
 	)
-	frPool := firewalls.NewFirewallPool(firewalls.NewFakeFirewallsProvider(namer), namer)
+	frPool := firewalls.NewFirewallPool(firewalls.NewFakeFirewallsProvider(), namer)
 	cm := &ClusterManager{
 		ClusterNamer: namer,
 		instancePool: nodePool,

controllers/gce/controller/util_test.go

@@ -76,20 +76,19 @@ func TestInstancesAddedToZones(t *testing.T) {
 	lbc.CloudClusterManager.instancePool.Sync([]string{"n1", "n2", "n3"})
 	gotZonesToNode := cm.fakeIGs.GetInstancesByZone()
 
-	i := 0
+	if cm.fakeIGs.Ports[0] != testPort {
+		t.Errorf("Expected the same node port on all igs, got ports %+v", cm.fakeIGs.Ports)
+	}
+
 	for z, nodeNames := range zoneToNode {
 		if ig, err := cm.fakeIGs.GetInstanceGroup(testIG, z); err != nil {
 			t.Errorf("Failed to find ig %v in zone %v, found %+v: %v", testIG, z, ig, err)
 		}
-		if cm.fakeIGs.Ports[i] != testPort {
-			t.Errorf("Expected the same node port on all igs, got ports %+v", cm.fakeIGs.Ports)
-		}
 		expNodes := sets.NewString(nodeNames...)
 		gotNodes := sets.NewString(gotZonesToNode[z]...)
 		if !gotNodes.Equal(expNodes) {
 			t.Errorf("Nodes not added to zones, expected %+v got %+v", expNodes, gotNodes)
 		}
-		i++
 	}
 }