Fix services namespace clash.

pkg/proxy/config/config.go

@@ -20,6 +20,7 @@ import (
 	"sync"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/config"
 	"github.com/golang/glog"
 )
@@ -81,7 +82,7 @@ type EndpointsConfig struct {
 // It immediately runs the created EndpointsConfig.
 func NewEndpointsConfig() *EndpointsConfig {
 	updates := make(chan struct{})
-	store := &endpointsStore{updates: updates, endpoints: make(map[string]map[string]api.Endpoints)}
+	store := &endpointsStore{updates: updates, endpoints: make(map[string]map[types.NamespacedName]api.Endpoints)}
 	mux := config.NewMux(store)
 	bcaster := config.NewBroadcaster()
 	go watchForUpdates(bcaster, store, updates)
@@ -112,7 +113,7 @@ func (c *EndpointsConfig) Config() []api.Endpoints {
 
 type endpointsStore struct {
 	endpointLock sync.RWMutex
-	endpoints    map[string]map[string]api.Endpoints
+	endpoints    map[string]map[types.NamespacedName]api.Endpoints
 	updates      chan<- struct{}
 }
 
@@ -120,26 +121,29 @@ func (s *endpointsStore) Merge(source string, change interface{}) error {
 	s.endpointLock.Lock()
 	endpoints := s.endpoints[source]
 	if endpoints == nil {
-		endpoints = make(map[string]api.Endpoints)
+		endpoints = make(map[types.NamespacedName]api.Endpoints)
 	}
 	update := change.(EndpointsUpdate)
 	switch update.Op {
 	case ADD:
 		glog.V(4).Infof("Adding new endpoint from source %s : %+v", source, update.Endpoints)
 		for _, value := range update.Endpoints {
-			endpoints[value.Name] = value
+			name := types.NamespacedName{value.Namespace, value.Name}
+			endpoints[name] = value
 		}
 	case REMOVE:
 		glog.V(4).Infof("Removing an endpoint %+v", update)
 		for _, value := range update.Endpoints {
-			delete(endpoints, value.Name)
+			name := types.NamespacedName{value.Namespace, value.Name}
+			delete(endpoints, name)
 		}
 	case SET:
 		glog.V(4).Infof("Setting endpoints %+v", update)
 		// Clear the old map entries by just creating a new map
-		endpoints = make(map[string]api.Endpoints)
+		endpoints = make(map[types.NamespacedName]api.Endpoints)
 		for _, value := range update.Endpoints {
-			endpoints[value.Name] = value
+			name := types.NamespacedName{value.Namespace, value.Name}
+			endpoints[name] = value
 		}
 	default:
 		glog.V(4).Infof("Received invalid update type: %v", update)
@@ -176,7 +180,7 @@ type ServiceConfig struct {
 // It immediately runs the created ServiceConfig.
 func NewServiceConfig() *ServiceConfig {
 	updates := make(chan struct{})
-	store := &serviceStore{updates: updates, services: make(map[string]map[string]api.Service)}
+	store := &serviceStore{updates: updates, services: make(map[string]map[types.NamespacedName]api.Service)}
 	mux := config.NewMux(store)
 	bcaster := config.NewBroadcaster()
 	go watchForUpdates(bcaster, store, updates)
@@ -207,7 +211,7 @@ func (c *ServiceConfig) Config() []api.Service {
 
 type serviceStore struct {
 	serviceLock sync.RWMutex
-	services    map[string]map[string]api.Service
+	services    map[string]map[types.NamespacedName]api.Service
 	updates     chan<- struct{}
 }
 
@@ -215,26 +219,29 @@ func (s *serviceStore) Merge(source string, change interface{}) error {
 	s.serviceLock.Lock()
 	services := s.services[source]
 	if services == nil {
-		services = make(map[string]api.Service)
+		services = make(map[types.NamespacedName]api.Service)
 	}
 	update := change.(ServiceUpdate)
 	switch update.Op {
 	case ADD:
 		glog.V(4).Infof("Adding new service from source %s : %+v", source, update.Services)
 		for _, value := range update.Services {
-			services[value.Name] = value
+			name := types.NamespacedName{value.Namespace, value.Name}
+			services[name] = value
 		}
 	case REMOVE:
 		glog.V(4).Infof("Removing a service %+v", update)
 		for _, value := range update.Services {
-			delete(services, value.Name)
+			name := types.NamespacedName{value.Namespace, value.Name}
+			delete(services, name)
 		}
 	case SET:
 		glog.V(4).Infof("Setting services %+v", update)
 		// Clear the old map entries by just creating a new map
-		services = make(map[string]api.Service)
+		services = make(map[types.NamespacedName]api.Service)
 		for _, value := range update.Services {
-			services[value.Name] = value
+			name := types.NamespacedName{value.Namespace, value.Name}
+			services[name] = value
 		}
 	default:
 		glog.V(4).Infof("Received invalid update type: %v", update)

pkg/proxy/config/config_test.go

@@ -136,7 +136,7 @@ func TestNewServiceAddedAndNotified(t *testing.T) {
 	handler := NewServiceHandlerMock()
 	handler.Wait(1)
 	config.RegisterHandler(handler)
-	serviceUpdate := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
+	serviceUpdate := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
 	channel <- serviceUpdate
 	handler.ValidateServices(t, serviceUpdate.Services)
 
@@ -147,24 +147,24 @@ func TestServiceAddedRemovedSetAndNotified(t *testing.T) {
 	channel := config.Channel("one")
 	handler := NewServiceHandlerMock()
 	config.RegisterHandler(handler)
-	serviceUpdate := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
+	serviceUpdate := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
 	handler.Wait(1)
 	channel <- serviceUpdate
 	handler.ValidateServices(t, serviceUpdate.Services)
 
-	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
+	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
 	handler.Wait(1)
 	channel <- serviceUpdate2
 	services := []api.Service{serviceUpdate2.Services[0], serviceUpdate.Services[0]}
 	handler.ValidateServices(t, services)
 
-	serviceUpdate3 := CreateServiceUpdate(REMOVE, api.Service{ObjectMeta: api.ObjectMeta{Name: "foo"}})
+	serviceUpdate3 := CreateServiceUpdate(REMOVE, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"}})
 	handler.Wait(1)
 	channel <- serviceUpdate3
 	services = []api.Service{serviceUpdate2.Services[0]}
 	handler.ValidateServices(t, services)
 
-	serviceUpdate4 := CreateServiceUpdate(SET, api.Service{ObjectMeta: api.ObjectMeta{Name: "foobar"}, Spec: api.ServiceSpec{Port: 99}})
+	serviceUpdate4 := CreateServiceUpdate(SET, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foobar"}, Spec: api.ServiceSpec{Port: 99}})
 	handler.Wait(1)
 	channel <- serviceUpdate4
 	services = []api.Service{serviceUpdate4.Services[0]}
@@ -180,8 +180,8 @@ func TestNewMultipleSourcesServicesAddedAndNotified(t *testing.T) {
 	}
 	handler := NewServiceHandlerMock()
 	config.RegisterHandler(handler)
-	serviceUpdate1 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
-	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
+	serviceUpdate1 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
+	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
 	handler.Wait(2)
 	channelOne <- serviceUpdate1
 	channelTwo <- serviceUpdate2
@@ -197,8 +197,8 @@ func TestNewMultipleSourcesServicesMultipleHandlersAddedAndNotified(t *testing.T
 	handler2 := NewServiceHandlerMock()
 	config.RegisterHandler(handler)
 	config.RegisterHandler(handler2)
-	serviceUpdate1 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
-	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
+	serviceUpdate1 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, Spec: api.ServiceSpec{Port: 10}})
+	serviceUpdate2 := CreateServiceUpdate(ADD, api.Service{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, Spec: api.ServiceSpec{Port: 20}})
 	handler.Wait(2)
 	handler2.Wait(2)
 	channelOne <- serviceUpdate1
@@ -217,11 +217,11 @@ func TestNewMultipleSourcesEndpointsMultipleHandlersAddedAndNotified(t *testing.
 	config.RegisterHandler(handler)
 	config.RegisterHandler(handler2)
 	endpointsUpdate1 := CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "foo"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint1"}, {IP: "endpoint2"}},
 	})
 	endpointsUpdate2 := CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "bar"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint3"}, {IP: "endpoint4"}},
 	})
 	handler.Wait(2)
@@ -243,11 +243,11 @@ func TestNewMultipleSourcesEndpointsMultipleHandlersAddRemoveSetAndNotified(t *t
 	config.RegisterHandler(handler)
 	config.RegisterHandler(handler2)
 	endpointsUpdate1 := CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "foo"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint1"}, {IP: "endpoint2"}},
 	})
 	endpointsUpdate2 := CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "bar"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint3"}, {IP: "endpoint4"}},
 	})
 	handler.Wait(2)
@@ -261,7 +261,7 @@ func TestNewMultipleSourcesEndpointsMultipleHandlersAddRemoveSetAndNotified(t *t
 
 	// Add one more
 	endpointsUpdate3 := CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "foobar"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foobar"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint5"}, {IP: "endpoint6"}},
 	})
 	handler.Wait(1)
@@ -273,7 +273,7 @@ func TestNewMultipleSourcesEndpointsMultipleHandlersAddRemoveSetAndNotified(t *t
 
 	// Update the "foo" service with new endpoints
 	endpointsUpdate1 = CreateEndpointsUpdate(ADD, api.Endpoints{
-		ObjectMeta: api.ObjectMeta{Name: "foo"},
+		ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "foo"},
 		Endpoints:  []api.Endpoint{{IP: "endpoint7"}},
 	})
 	handler.Wait(1)
@@ -284,7 +284,7 @@ func TestNewMultipleSourcesEndpointsMultipleHandlersAddRemoveSetAndNotified(t *t
 	handler2.ValidateEndpoints(t, endpoints)
 
 	// Remove "bar" service
-	endpointsUpdate2 = CreateEndpointsUpdate(REMOVE, api.Endpoints{ObjectMeta: api.ObjectMeta{Name: "bar"}})
+	endpointsUpdate2 = CreateEndpointsUpdate(REMOVE, api.Endpoints{ObjectMeta: api.ObjectMeta{Namespace: "testnamespace", Name: "bar"}})
 	handler.Wait(1)
 	handler2.Wait(1)
 	channelTwo <- endpointsUpdate2

pkg/proxy/loadbalancer.go

@@ -20,13 +20,14 @@ import (
 	"net"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
 )
 
 // LoadBalancer is an interface for distributing incoming requests to service endpoints.
 type LoadBalancer interface {
 	// NextEndpoint returns the endpoint to handle a request for the given
 	// service and source address.
-	NextEndpoint(service string, srcAddr net.Addr) (string, error)
-	NewService(service string, sessionAffinityType api.AffinityType, stickyMaxAgeMinutes int) error
-	CleanupStaleStickySessions(service string)
+	NextEndpoint(service types.NamespacedName, srcAddr net.Addr) (string, error)
+	NewService(service types.NamespacedName, sessionAffinityType api.AffinityType, stickyMaxAgeMinutes int) error
+	CleanupStaleStickySessions(service types.NamespacedName)
 }

pkg/proxy/roundrobin.go

@@ -26,6 +26,7 @@ import (
 	"time"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/types"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util/slice"
 	"github.com/golang/glog"
 )
@@ -49,13 +50,10 @@ type affinityPolicy struct {
 	ttlMinutes   int
 }
 
-// balancerKey is a string that the balancer uses to key stored state.
-type balancerKey string
-
 // LoadBalancerRR is a round-robin load balancer.
 type LoadBalancerRR struct {
 	lock     sync.RWMutex
-	services map[balancerKey]*balancerState
+	services map[types.NamespacedName]*balancerState
 }
 
 type balancerState struct {
@@ -75,11 +73,11 @@ func newAffinityPolicy(affinityType api.AffinityType, ttlMinutes int) *affinityP
 // NewLoadBalancerRR returns a new LoadBalancerRR.
 func NewLoadBalancerRR() *LoadBalancerRR {
 	return &LoadBalancerRR{
-		services: map[balancerKey]*balancerState{},
+		services: map[types.NamespacedName]*balancerState{},
 	}
 }
 
-func (lb *LoadBalancerRR) NewService(service string, affinityType api.AffinityType, ttlMinutes int) error {
+func (lb *LoadBalancerRR) NewService(service types.NamespacedName, affinityType api.AffinityType, ttlMinutes int) error {
 	lb.lock.Lock()
 	defer lb.lock.Unlock()
 
@@ -88,17 +86,16 @@ func (lb *LoadBalancerRR) NewService(service string, affinityType api.AffinityTy
 }
 
 // This assumes that lb.lock is already held.
-func (lb *LoadBalancerRR) newServiceInternal(service string, affinityType api.AffinityType, ttlMinutes int) *balancerState {
+func (lb *LoadBalancerRR) newServiceInternal(service types.NamespacedName, affinityType api.AffinityType, ttlMinutes int) *balancerState {
 	if ttlMinutes == 0 {
 		ttlMinutes = 180 //default to 3 hours if not specified.  Should 0 be unlimeted instead????
 	}
 
-	key := balancerKey(service)
-	if _, exists := lb.services[key]; !exists {
-		lb.services[key] = &balancerState{affinity: *newAffinityPolicy(affinityType, ttlMinutes)}
+	if _, exists := lb.services[service]; !exists {
+		lb.services[service] = &balancerState{affinity: *newAffinityPolicy(affinityType, ttlMinutes)}
 		glog.V(4).Infof("LoadBalancerRR service %q did not exist, created", service)
 	}
-	return lb.services[key]
+	return lb.services[service]
 }
 
 // return true if this service is using some form of session affinity.
@@ -112,13 +109,13 @@ func isSessionAffinity(affinity *affinityPolicy) bool {
 
 // NextEndpoint returns a service endpoint.
 // The service endpoint is chosen using the round-robin algorithm.
-func (lb *LoadBalancerRR) NextEndpoint(service string, srcAddr net.Addr) (string, error) {
+func (lb *LoadBalancerRR) NextEndpoint(service types.NamespacedName, srcAddr net.Addr) (string, error) {
 	// Coarse locking is simple.  We can get more fine-grained if/when we
 	// can prove it matters.
 	lb.lock.Lock()
 	defer lb.lock.Unlock()
 
-	key := balancerKey(service)
+	key := service
 	state, exists := lb.services[key]
 	if !exists || state == nil {
 		return "", ErrMissingServiceEntry
@@ -185,7 +182,7 @@ func filterValidEndpoints(endpoints []api.Endpoint) []string {
 }
 
 // Remove any session affinity records associated to a particular endpoint (for example when a pod goes down).
-func removeSessionAffinityByEndpoint(state *balancerState, service balancerKey, endpoint string) {
+func removeSessionAffinityByEndpoint(state *balancerState, service types.NamespacedName, endpoint string) {
 	for _, affinity := range state.affinity.affinityMap {
 		if affinity.endpoint == endpoint {
 			glog.V(4).Infof("Removing client: %s from affinityMap for service %q", affinity.endpoint, service)
@@ -197,7 +194,7 @@ func removeSessionAffinityByEndpoint(state *balancerState, service balancerKey,
 // Loop through the valid endpoints and then the endpoints associated with the Load Balancer.
 // Then remove any session affinity records that are not in both lists.
 // This assumes the lb.lock is held.
-func (lb *LoadBalancerRR) updateAffinityMap(service balancerKey, newEndpoints []string) {
+func (lb *LoadBalancerRR) updateAffinityMap(service types.NamespacedName, newEndpoints []string) {
 	allEndpoints := map[string]int{}
 	for _, newEndpoint := range newEndpoints {
 		allEndpoints[newEndpoint] = 1
@@ -221,13 +218,14 @@ func (lb *LoadBalancerRR) updateAffinityMap(service balancerKey, newEndpoints []
 // Registered endpoints are updated if found in the update set or
 // unregistered if missing from the update set.
 func (lb *LoadBalancerRR) OnUpdate(allEndpoints []api.Endpoints) {
-	registeredEndpoints := make(map[balancerKey]bool)
+	registeredEndpoints := make(map[types.NamespacedName]bool)
 	lb.lock.Lock()
 	defer lb.lock.Unlock()
 
 	// Update endpoints for services.
 	for _, svcEndpoints := range allEndpoints {
-		key := balancerKey(svcEndpoints.Name)
+		name := types.NamespacedName{svcEndpoints.Namespace, svcEndpoints.Name}
+		key := name
 		state, exists := lb.services[key]
 		curEndpoints := []string{}
 		if state != nil {
@@ -240,7 +238,7 @@ func (lb *LoadBalancerRR) OnUpdate(allEndpoints []api.Endpoints) {
 			// On update can be called without NewService being called externally.
 			// To be safe we will call it here.  A new service will only be created
 			// if one does not already exist.
-			state = lb.newServiceInternal(svcEndpoints.Name, api.AffinityTypeNone, 0)
+			state = lb.newServiceInternal(name, api.AffinityTypeNone, 0)
 			state.endpoints = slice.ShuffleStrings(newEndpoints)
 
 			// Reset the round-robin index.
@@ -268,11 +266,11 @@ func slicesEquiv(lhs, rhs []string) bool {
 	return false
 }
 
-func (lb *LoadBalancerRR) CleanupStaleStickySessions(service string) {
+func (lb *LoadBalancerRR) CleanupStaleStickySessions(service types.NamespacedName) {
 	lb.lock.Lock()
 	defer lb.lock.Unlock()
 
-	key := balancerKey(service)
+	key := service
 	state, exists := lb.services[key]
 	if !exists {
 		glog.Warning("CleanupStaleStickySessions called for non-existent balancer key %q", service)

pkg/types/namespacedname.go

+/*
+Copyright 2015 Google Inc. All rights reserved.
+
+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 types
+
+// NamespacedName comprises a resource name, with a mandatory namespace,
+// rendered as "<namespace>/<name>".  Being a type captures intent and
+// helps make sure that UIDs, namespaced names and non-namespaced names
+// do not get conflated in code.  For most use cases, namespace and name
+// will already have been format validated at the API entry point, so we
+// don't do that here.  Where that's not the case (e.g. in testing),
+// consider using NamespacedNameOrDie() in testing.go in this package.
+
+type NamespacedName struct {
+	Namespace string
+	Name      string
+}
+
+// String returns the general purpose string representation
+func (n NamespacedName) String() string {
+	return n.Namespace + "/" + n.Name
+}

pkg/types/testing.go

+/*
+Copyright 2015 Google Inc. All rights reserved.
+
+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 types
+
+import "fmt"
+
+func NewNamespacedNameOrDie(namespace, name string) (ret NamespacedName) {
+	if len(namespace) == 0 || len(name) == 0 {
+		panic(fmt.Sprintf("invalid call to NewNamespacedNameOrDie(%q, %q)", namespace, name))
+	}
+	return NamespacedName{namespace, name}
+}

test/e2e/service.go

@@ -18,6 +18,7 @@ package e2e
 
 import (
 	"fmt"
+	"sort"
 	"time"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
@@ -178,8 +179,8 @@ var _ = Describe("Services", func() {
 		Expect(foundRO).To(Equal(true))
 	})
 
-	It("should serve basic a endpoint from pods", func(done Done) {
-		serviceName := "endpoint-test"
+	It("should serve a basic endpoint from pods", func(done Done) {
+		serviceName := "endpoint-test2"
 		ns := api.NamespaceDefault
 		labels := map[string]string{
 			"foo": "bar",
@@ -243,9 +244,59 @@ var _ = Describe("Services", func() {
 		defer func() {
 			close(done)
 		}()
-	}, 120.0)
+	}, 240.0)
+	It("should correctly serve identically named services in different namespaces on different external IP addresses", func(done Done) {
+		serviceNames := []string{"services-namespace-test0"} // Could add more here, but then it takes longer.
+		namespaces := []string{"namespace0", "namespace1"}   // As above.
+		labels := map[string]string{
+			"key0": "value0",
+			"key1": "value1",
+		}
+		service := &api.Service{
+			ObjectMeta: api.ObjectMeta{},
+			Spec: api.ServiceSpec{
+				Port:                       80,
+				Selector:                   labels,
+				ContainerPort:              util.NewIntOrStringFromInt(80),
+				CreateExternalLoadBalancer: true,
+			},
+		}
+		publicIPs := []string{}
+		// We defer Gingko pieces that may Fail, so clean up at the end.
+		defer func() {
+			close(done)
+		}()
+		for _, namespace := range namespaces {
+			for _, serviceName := range serviceNames {
+				service.ObjectMeta.Name = serviceName
+				service.ObjectMeta.Namespace = namespace
+				By("creating service " + serviceName + " in namespace " + namespace)
+				result, err := c.Services(namespace).Create(service)
+				Expect(err).NotTo(HaveOccurred())
+				defer func(namespace, serviceName string) { // clean up when we're done
+					By("deleting service " + serviceName + " in namespace " + namespace)
+					err := c.Services(namespace).Delete(serviceName)
+					Expect(err).NotTo(HaveOccurred())
+				}(namespace, serviceName)
+				publicIPs = append(publicIPs, result.Spec.PublicIPs...) // Save 'em to check uniqueness
+			}
+		}
+		validateUniqueOrFail(publicIPs)
+	}, 240.0)
 })
 
+func validateUniqueOrFail(s []string) {
+	By(fmt.Sprintf("validating unique: %v", s))
+	sort.Strings(s)
+	var prev string
+	for i, elem := range s {
+		if i > 0 && elem == prev {
+			Fail("duplicate found: " + elem)
+		}
+		prev = elem
+	}
+}
+
 func validateIPsOrFail(c *client.Client, ns string, expectedPort int, expectedEndpoints []string, endpoints *api.Endpoints) {
 	ips := util.StringSet{}
 	for _, ep := range endpoints.Endpoints {
@@ -263,7 +314,10 @@ func validateIPsOrFail(c *client.Client, ns string, expectedPort int, expectedEn
 		if !ips.Has(pod.Status.PodIP) {
 			Failf("ip validation failed, expected: %v, saw: %v", ips, pod.Status.PodIP)
 		}
+		By(fmt.Sprintf(""))
 	}
+	By(fmt.Sprintf("successfully validated IPs %v against expected endpoints %v port %d on namespace %s", ips, expectedEndpoints, expectedPort, ns))
+
 }
 
 func validateEndpointsOrFail(c *client.Client, ns, serviceName string, expectedPort int, expectedEndpoints []string) {
@@ -274,17 +328,18 @@ func validateEndpointsOrFail(c *client.Client, ns, serviceName string, expectedP
 				validateIPsOrFail(c, ns, expectedPort, expectedEndpoints, endpoints)
 				return
 			} else {
-				By(fmt.Sprintf("Unexpected endpoints: %v, expected %v", endpoints.Endpoints, expectedEndpoints))
+				By(fmt.Sprintf("Unexpected number of endpoints: found %v, expected %v (ignoring for 1 second)", endpoints.Endpoints, expectedEndpoints))
 			}
 		} else {
-			By(fmt.Sprintf("Failed to get endpoints: %v (ignoring for 1s)", err))
+			By(fmt.Sprintf("Failed to get endpoints: %v (ignoring for 1 second)", err))
 		}
 		time.Sleep(time.Second)
 	}
+	By(fmt.Sprintf("successfully validated endpoints %v port %d on service %s/%s", expectedEndpoints, expectedPort, ns, serviceName))
 }
 
 func addEndpointPodOrFail(c *client.Client, ns, name string, labels map[string]string) {
-	By(fmt.Sprintf("Adding pod %v", name))
+	By(fmt.Sprintf("Adding pod %v in namespace %v", name, ns))
 	pod := &api.Pod{
 		ObjectMeta: api.ObjectMeta{
 			Name:   name,