Centralize more of the naming of GCE resources

- Make Namer.Truncate private
- Rename GetClusterName() to Cluster()
- Rename GetFirewallName => Firewall()
- More naming consistency cleanups
- BeName() -> Backend()
- BePort() -> BackendPortName()
- firewall_name -> name
- NEGName -> NEG
- IGName() -> InstanceGroup()
- FrSuffix -> FirewallRuleSuffix
- FrName -> FirewallRule
- Remove useless argument to FirewallRule
- All calls use FirewallRuleSuffix, push back into the method.
- SSLCertName -> SSLCert
- Remove stutter on ClusterName, FirewallName
- Reduce leakage of NEGPrefix (use IsNEG) from Namer
- Cluster() -> UID()

cmd/glbc/main.go

@@ -298,8 +298,8 @@ func main() {
 		glog.Fatalf("%v", err)
 	}
 
-	if clusterManager.ClusterNamer.GetClusterName() != "" {
-		glog.V(3).Infof("Cluster name %+v", clusterManager.ClusterNamer.GetClusterName())
+	if clusterManager.ClusterNamer.UID() != "" {
+		glog.V(3).Infof("Cluster name %+v", clusterManager.ClusterNamer.UID())
 	}
 	clusterManager.Init(&controller.GCETranslator{LoadBalancerController: lbc})
 
@@ -353,14 +353,14 @@ func newNamer(kubeClient kubernetes.Interface, clusterName string, fwName string
 
 				switch key {
 				case storage.UidDataKey:
-					if uid := namer.GetClusterName(); uid != val {
+					if uid := namer.UID(); uid != val {
 						glog.Infof("Cluster uid changed from %v -> %v", uid, val)
-						namer.SetClusterName(val)
+						namer.SetUID(val)
 					}
 				case storage.ProviderDataKey:
-					if fw_name := namer.GetFirewallName(); fw_name != val {
+					if fw_name := namer.Firewall(); fw_name != val {
 						glog.Infof("Cluster firewall name changed from %v -> %v", fw_name, val)
-						namer.SetFirewallName(val)
+						namer.SetFirewall(val)
 					}
 				}
 			}

pkg/backends/backends.go

@@ -151,7 +151,7 @@ func NewBackendPool(
 			if !namer.NameBelongsToCluster(bs.Name) {
 				return "", fmt.Errorf("unrecognized name %v", bs.Name)
 			}
-			port, err := namer.BePort(bs.Name)
+			port, err := namer.BackendPort(bs.Name)
 			if err != nil {
 				return "", err
 			}
@@ -170,7 +170,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.GetGlobalBackendService(b.namer.BeName(port))
+	be, err := b.cloud.GetGlobalBackendService(b.namer.Backend(port))
 	if err != nil {
 		return nil, err
 	}
@@ -262,7 +262,7 @@ func (b *Backends) ensureBackendService(p ServicePort, igs []*compute.InstanceGr
 	}
 
 	// Verify existance of a backend service for the proper port, but do not specify any backends/igs
-	beName := b.namer.BeName(p.Port)
+	beName := b.namer.Backend(p.Port)
 	be, _ = b.Get(p.Port)
 	if be == nil {
 		namedPort := utils.GetNamedPort(p.Port)
@@ -318,7 +318,7 @@ func (b *Backends) ensureBackendService(p ServicePort, igs []*compute.InstanceGr
 
 // Delete deletes the Backend for the given port.
 func (b *Backends) Delete(port int64) (err error) {
-	name := b.namer.BeName(port)
+	name := b.namer.Backend(port)
 	glog.V(2).Infof("Deleting backend service %v", name)
 	defer func() {
 		if utils.IsHTTPErrorCode(err, http.StatusNotFound) {
@@ -501,7 +501,7 @@ func (b *Backends) Link(port ServicePort, zones []string) error {
 	if !port.NEGEnabled {
 		return nil
 	}
-	negName := b.namer.NEGName(port.SvcName.Namespace, port.SvcName.Name, port.SvcTargetPort)
+	negName := b.namer.NEG(port.SvcName.Namespace, port.SvcName.Name, port.SvcTargetPort)
 	var negs []*computealpha.NetworkEndpointGroup
 	var err error
 	for _, zone := range zones {
@@ -512,7 +512,7 @@ func (b *Backends) Link(port ServicePort, zones []string) error {
 		negs = append(negs, neg)
 	}
 
-	backendService, err := b.cloud.GetAlphaGlobalBackendService(b.namer.BeName(port.Port))
+	backendService, err := b.cloud.GetAlphaGlobalBackendService(b.namer.Backend(port.Port))
 	if err != nil {
 		return err
 	}

pkg/backends/backends_test.go

@@ -89,7 +89,7 @@ func TestBackendPoolAdd(t *testing.T) {
 			if err != nil {
 				t.Fatalf("Did not find expect error when adding a nodeport: %v, err: %v", nodePort, err)
 			}
-			beName := namer.BeName(nodePort.Port)
+			beName := namer.Backend(nodePort.Port)
 
 			// Check that the new backend has the right port
 			be, err := f.GetGlobalBackendService(beName)
@@ -101,7 +101,7 @@ func TestBackendPoolAdd(t *testing.T) {
 			}
 
 			// Check that the instance group has the new port.
-			ig, err := fakeIGs.GetInstanceGroup(namer.IGName(), defaultZone)
+			ig, err := fakeIGs.GetInstanceGroup(namer.InstanceGroup(), defaultZone)
 			var found bool
 			for _, port := range ig.NamedPorts {
 				if port.Port == nodePort.Port {
@@ -139,7 +139,7 @@ func TestHealthCheckMigration(t *testing.T) {
 
 	// Create a legacy health check and insert it into the HC provider.
 	legacyHC := &compute.HttpHealthCheck{
-		Name:               namer.BeName(p.Port),
+		Name:               namer.Backend(p.Port),
 		RequestPath:        "/my-healthz-path",
 		Host:               "k8s.io",
 		Description:        "My custom HC",
@@ -175,7 +175,7 @@ func TestBackendPoolUpdate(t *testing.T) {
 
 	p := ServicePort{Port: 3000, Protocol: utils.ProtocolHTTP}
 	pool.Ensure([]ServicePort{p}, nil)
-	beName := namer.BeName(p.Port)
+	beName := namer.Backend(p.Port)
 
 	be, err := f.GetGlobalBackendService(beName)
 	if err != nil {
@@ -221,7 +221,7 @@ func TestBackendPoolChaosMonkey(t *testing.T) {
 
 	nodePort := ServicePort{Port: 8080, Protocol: utils.ProtocolHTTP}
 	pool.Ensure([]ServicePort{nodePort}, nil)
-	beName := namer.BeName(nodePort.Port)
+	beName := namer.Backend(nodePort.Port)
 
 	be, _ := f.GetGlobalBackendService(beName)
 
@@ -243,9 +243,9 @@ func TestBackendPoolChaosMonkey(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to find a backend with name %v: %v", beName, err)
 	}
-	gotGroup, err := fakeIGs.GetInstanceGroup(namer.IGName(), defaultZone)
+	gotGroup, err := fakeIGs.GetInstanceGroup(namer.InstanceGroup(), defaultZone)
 	if err != nil {
-		t.Fatalf("Failed to find instance group %v", namer.IGName())
+		t.Fatalf("Failed to find instance group %v", namer.InstanceGroup())
 	}
 	backendLinks := sets.NewString()
 	for _, be := range gotBackend.Backends {
@@ -307,7 +307,7 @@ func TestBackendPoolSync(t *testing.T) {
 
 	namer := &utils.Namer{}
 	// This backend should get deleted again since it is managed by this cluster.
-	f.CreateGlobalBackendService(&compute.BackendService{Name: namer.BeName(deletedPorts[0].Port)})
+	f.CreateGlobalBackendService(&compute.BackendService{Name: namer.Backend(deletedPorts[0].Port)})
 
 	// TODO: Avoid casting.
 	// Repopulate the pool with a cloud list, which now includes the 82 port
@@ -323,7 +323,7 @@ func TestBackendPoolSync(t *testing.T) {
 		currSet.Insert(b.Name)
 	}
 	// Port 81 still exists because it's an in-use service NodePort.
-	knownBe := namer.BeName(81)
+	knownBe := namer.Backend(81)
 	if !currSet.Has(knownBe) {
 		t.Fatalf("Expected %v to exist in backend pool", knownBe)
 	}
@@ -347,7 +347,7 @@ func TestBackendPoolDeleteLegacyHealthChecks(t *testing.T) {
 	bp.Init(NewFakeProbeProvider(probes))
 
 	// Create a legacy HTTP health check
-	beName := namer.BeName(80)
+	beName := namer.Backend(80)
 	if err := hcp.CreateHttpHealthCheck(&compute.HttpHealthCheck{
 		Name: beName,
 		Port: 80,
@@ -397,7 +397,7 @@ func TestBackendPoolShutdown(t *testing.T) {
 	// Add a backend-service and verify that it doesn't exist after Shutdown()
 	pool.Ensure([]ServicePort{{Port: 80}}, nil)
 	pool.Shutdown()
-	if _, err := f.GetGlobalBackendService(namer.BeName(80)); err == nil {
+	if _, err := f.GetGlobalBackendService(namer.Backend(80)); err == nil {
 		t.Fatalf("%v", err)
 	}
 }
@@ -411,7 +411,7 @@ func TestBackendInstanceGroupClobbering(t *testing.T) {
 	// This will add the instance group k8s-ig to the instance pool
 	pool.Ensure([]ServicePort{{Port: 80}}, nil)
 
-	be, err := f.GetGlobalBackendService(namer.BeName(80))
+	be, err := f.GetGlobalBackendService(namer.Backend(80))
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
@@ -428,7 +428,7 @@ func TestBackendInstanceGroupClobbering(t *testing.T) {
 
 	// Make sure repeated adds don't clobber the inserted instance group
 	pool.Ensure([]ServicePort{{Port: 80}}, nil)
-	be, err = f.GetGlobalBackendService(namer.BeName(80))
+	be, err = f.GetGlobalBackendService(namer.Backend(80))
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
@@ -470,7 +470,7 @@ func TestBackendCreateBalancingMode(t *testing.T) {
 		}
 
 		pool.Ensure([]ServicePort{nodePort}, nil)
-		be, err := f.GetGlobalBackendService(namer.BeName(nodePort.Port))
+		be, err := f.GetGlobalBackendService(namer.Backend(nodePort.Port))
 		if err != nil {
 			t.Fatalf("%v", err)
 		}
@@ -542,7 +542,7 @@ func TestLinkBackendServiceToNEG(t *testing.T) {
 	}
 
 	for _, zone := range zones {
-		err := fakeNEG.CreateNetworkEndpointGroup(&computealpha.NetworkEndpointGroup{Name: namer.NEGName(namespace, name, port)}, zone)
+		err := fakeNEG.CreateNetworkEndpointGroup(&computealpha.NetworkEndpointGroup{Name: namer.NEG(namespace, name, port)}, zone)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -552,7 +552,7 @@ func TestLinkBackendServiceToNEG(t *testing.T) {
 		t.Fatalf("Failed to link backend service to NEG: %v", err)
 	}
 
-	bs, err := f.GetGlobalBackendService(namer.BeName(svcPort.Port))
+	bs, err := f.GetGlobalBackendService(namer.Backend(svcPort.Port))
 	if err != nil {
 		t.Fatalf("Failed to retrieve backend service: %v", err)
 	}

pkg/controller/cluster_manager.go

@@ -195,7 +195,7 @@ func (c *ClusterManager) GC(lbNames []string, nodePorts []backends.ServicePort)
 	// TODO(ingress#120): Move this to the backend pool so it mirrors creation
 	var igErr error
 	if len(lbNames) == 0 {
-		igName := c.ClusterNamer.IGName()
+		igName := c.ClusterNamer.InstanceGroup()
 		glog.Infof("Deleting instance group %v", igName)
 		igErr = c.instancePool.DeleteInstanceGroup(igName)
 	}

pkg/controller/controller_test.go

@@ -161,7 +161,7 @@ func (p *nodePortManager) toNodePortSvcNames(inputMap map[string]utils.FakeIngre
 	for host, rules := range inputMap {
 		ruleMap := utils.FakeIngressRuleValueMap{}
 		for path, svc := range rules {
-			ruleMap[path] = p.namer.BeName(int64(p.portMap[svc]))
+			ruleMap[path] = p.namer.Backend(int64(p.portMap[svc]))
 		}
 		expectedMap[host] = ruleMap
 	}
@@ -247,8 +247,8 @@ func TestLbCreateDelete(t *testing.T) {
 	unexpected := []int{pm.portMap["foo2svc"], pm.portMap["bar2svc"]}
 	expected := []int{pm.portMap["foo1svc"], pm.portMap["bar1svc"]}
 	firewallPorts := sets.NewString()
-	pm.namer.SetFirewallName(testFirewallName)
-	firewallName := pm.namer.FrName(pm.namer.FrSuffix())
+	pm.namer.SetFirewall(testFirewallName)
+	firewallName := pm.namer.FirewallRule()
 
 	if firewallRule, err := cm.firewallPool.(*firewalls.FirewallRules).GetFirewall(firewallName); err != nil {
 		t.Fatalf("%v", err)

pkg/firewalls/firewalls.go

@@ -57,11 +57,9 @@ func (fr *FirewallRules) Sync(nodePorts []int64, nodeNames []string) error {
 	if len(nodePorts) == 0 {
 		return fr.Shutdown()
 	}
-	// Firewall rule prefix must match that inserted by the gce library.
-	suffix := fr.namer.FrSuffix()
 	// TODO: Fix upstream gce cloudprovider lib so GET also takes the suffix
 	// instead of the whole name.
-	name := fr.namer.FrName(suffix)
+	name := fr.namer.FirewallRule()
 	rule, _ := fr.cloud.GetFirewall(name)
 
 	firewall, err := fr.createFirewallObject(name, "GCE L7 firewall rule", nodePorts, nodeNames)
@@ -100,7 +98,7 @@ func (fr *FirewallRules) Sync(nodePorts []int64, nodeNames []string) error {
 
 // Shutdown shuts down this firewall rules manager.
 func (fr *FirewallRules) Shutdown() error {
-	name := fr.namer.FrName(fr.namer.FrSuffix())
+	name := fr.namer.FirewallRule()
 	glog.Infof("Deleting firewall %v", name)
 	return fr.deleteFirewall(name)
 }

pkg/firewalls/firewalls_test.go

@@ -29,7 +29,7 @@ func TestSyncFirewallPool(t *testing.T) {
 	namer := utils.NewNamer("ABC", "XYZ")
 	fwp := NewFakeFirewallsProvider(false, false)
 	fp := NewFirewallPool(fwp, namer)
-	ruleName := namer.FrName(namer.FrSuffix())
+	ruleName := namer.FirewallRule()
 
 	// Test creating a firewall rule via Sync
 	nodePorts := []int64{80, 443, 3000}
@@ -48,7 +48,7 @@ func TestSyncFirewallPool(t *testing.T) {
 	}
 	verifyFirewallRule(fwp, ruleName, nodePorts, nodes, l7SrcRanges, t)
 
-	firewall, err := fp.(*FirewallRules).createFirewallObject(namer.FrName(namer.FrSuffix()), "", nodePorts, nodes)
+	firewall, err := fp.(*FirewallRules).createFirewallObject(namer.FirewallRule(), "", nodePorts, nodes)
 	if err != nil {
 		t.Errorf("unexpected err when creating firewall object, err: %v", err)
 	}
@@ -93,7 +93,7 @@ func TestSyncOnXPNWithPermission(t *testing.T) {
 	namer := utils.NewNamer("ABC", "XYZ")
 	fwp := NewFakeFirewallsProvider(true, false)
 	fp := NewFirewallPool(fwp, namer)
-	ruleName := namer.FrName(namer.FrSuffix())
+	ruleName := namer.FirewallRule()
 
 	// Test creating a firewall rule via Sync
 	nodePorts := []int64{80, 443, 3000}
@@ -112,7 +112,7 @@ func TestSyncOnXPNReadOnly(t *testing.T) {
 	namer := utils.NewNamer("ABC", "XYZ")
 	fwp := NewFakeFirewallsProvider(true, true)
 	fp := NewFirewallPool(fwp, namer)
-	ruleName := namer.FrName(namer.FrSuffix())
+	ruleName := namer.FirewallRule()
 
 	// Test creating a firewall rule via Sync
 	nodePorts := []int64{80, 443, 3000}

pkg/healthchecks/healthchecks.go

@@ -84,7 +84,7 @@ func (h *HealthChecks) New(port int64, protocol utils.AppProtocol, enableNEG boo
 	}
 	// port is the key for retriving existing health-check
 	// TODO: rename backend-service and health-check to not use port as key
-	hc.Name = h.namer.BeName(port)
+	hc.Name = h.namer.Backend(port)
 	hc.Port = port
 	return hc
 }
@@ -179,7 +179,7 @@ func (h *HealthChecks) getHealthCheckLink(port int64) (string, error) {
 
 // Delete deletes the health check by port.
 func (h *HealthChecks) Delete(port int64) error {
-	name := h.namer.BeName(port)
+	name := h.namer.Backend(port)
 	glog.V(2).Infof("Deleting health check %v", name)
 	return h.cloud.DeleteHealthCheck(name)
 }
@@ -188,7 +188,7 @@ func (h *HealthChecks) Delete(port int64) error {
 func (h *HealthChecks) Get(port int64, alpha bool) (*HealthCheck, error) {
 	var hc *computealpha.HealthCheck
 	var err error
-	name := h.namer.BeName(port)
+	name := h.namer.Backend(port)
 	if alpha {
 		hc, err = h.cloud.GetAlphaHealthCheck(name)
 	} else {
@@ -203,13 +203,13 @@ func (h *HealthChecks) Get(port int64, alpha bool) (*HealthCheck, error) {
 
 // GetLegacy deletes legacy HTTP health checks
 func (h *HealthChecks) GetLegacy(port int64) (*compute.HttpHealthCheck, error) {
-	name := h.namer.BeName(port)
+	name := h.namer.Backend(port)
 	return h.cloud.GetHttpHealthCheck(name)
 }
 
 // DeleteLegacy deletes legacy HTTP health checks
 func (h *HealthChecks) DeleteLegacy(port int64) error {
-	name := h.namer.BeName(port)
+	name := h.namer.Backend(port)
 	glog.V(2).Infof("Deleting legacy HTTP health check %v", name)
 	return h.cloud.DeleteHttpHealthCheck(name)
 }