diff --git a/cmd/kube-proxy/app/server.go b/cmd/kube-proxy/app/server.go index 5e6cde8708..e25d5fac04 100644 --- a/cmd/kube-proxy/app/server.go +++ b/cmd/kube-proxy/app/server.go @@ -41,7 +41,8 @@ import ( "k8s.io/apiserver/pkg/server/routes" utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/apiserver/pkg/util/flag" - clientgoclientset "k8s.io/client-go/kubernetes" + informers "k8s.io/client-go/informers" + clientset "k8s.io/client-go/kubernetes" v1core "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd" @@ -49,8 +50,6 @@ import ( "k8s.io/client-go/tools/record" "k8s.io/kubernetes/pkg/apis/componentconfig" api "k8s.io/kubernetes/pkg/apis/core" - clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" - informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion" "k8s.io/kubernetes/pkg/kubelet/qos" "k8s.io/kubernetes/pkg/master/ports" "k8s.io/kubernetes/pkg/proxy" @@ -434,7 +433,7 @@ func createClients(config kubeproxyconfig.ClientConnectionConfiguration, masterO return nil, nil, err } - eventClient, err := clientgoclientset.NewForConfig(kubeConfig) + eventClient, err := clientset.NewForConfig(kubeConfig) if err != nil { return nil, nil, err } @@ -550,11 +549,11 @@ func (s *ProxyServer) Run() error { // Note: RegisterHandler() calls need to happen before creation of Sources because sources // only notify on changes, and the initial update (on process start) may be lost if no handlers // are registered yet. - serviceConfig := config.NewServiceConfig(informerFactory.Core().InternalVersion().Services(), s.ConfigSyncPeriod) + serviceConfig := config.NewServiceConfig(informerFactory.Core().V1().Services(), s.ConfigSyncPeriod) serviceConfig.RegisterEventHandler(s.ServiceEventHandler) go serviceConfig.Run(wait.NeverStop) - endpointsConfig := config.NewEndpointsConfig(informerFactory.Core().InternalVersion().Endpoints(), s.ConfigSyncPeriod) + endpointsConfig := config.NewEndpointsConfig(informerFactory.Core().V1().Endpoints(), s.ConfigSyncPeriod) endpointsConfig.RegisterEventHandler(s.EndpointsEventHandler) go endpointsConfig.Run(wait.NeverStop) @@ -600,12 +599,12 @@ func getConntrackMax(config kubeproxyconfig.KubeProxyConntrackConfiguration) (in func getNodeIP(client clientset.Interface, hostname string) net.IP { var nodeIP net.IP - node, err := client.Core().Nodes().Get(hostname, metav1.GetOptions{}) + node, err := client.CoreV1().Nodes().Get(hostname, metav1.GetOptions{}) if err != nil { glog.Warningf("Failed to retrieve node info: %v", err) return nil } - nodeIP, err = utilnode.InternalGetNodeHostIP(node) + nodeIP, err = utilnode.GetNodeHostIP(node) if err != nil { glog.Warningf("Failed to retrieve node IP: %v", err) return nil diff --git a/cmd/kubemark/hollow-node.go b/cmd/kubemark/hollow-node.go index 8044c1a7d4..972c5161d4 100644 --- a/cmd/kubemark/hollow-node.go +++ b/cmd/kubemark/hollow-node.go @@ -36,7 +36,6 @@ import ( "k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/record" "k8s.io/kubernetes/pkg/api/legacyscheme" - "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" _ "k8s.io/kubernetes/pkg/client/metrics/prometheus" // for client metric registration cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing" "k8s.io/kubernetes/pkg/kubelet/cm" @@ -152,10 +151,6 @@ func run(config *HollowNodeConfig) { if err != nil { glog.Fatalf("Failed to create a ClientSet: %v. Exiting.", err) } - internalClientset, err := internalclientset.NewForConfig(clientConfig) - if err != nil { - glog.Fatalf("Failed to create an internal ClientSet: %v. Exiting.", err) - } if config.Morph == "kubelet" { cadvisorInterface := &cadvisortest.Fake{ @@ -196,7 +191,7 @@ func run(config *HollowNodeConfig) { hollowProxy, err := kubemark.NewHollowProxyOrDie( config.NodeName, - internalClientset, + client, client.CoreV1(), iptInterface, sysctl, diff --git a/pkg/kubemark/hollow_proxy.go b/pkg/kubemark/hollow_proxy.go index a09e130d4d..8af54ae176 100644 --- a/pkg/kubemark/hollow_proxy.go +++ b/pkg/kubemark/hollow_proxy.go @@ -24,11 +24,10 @@ import ( "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + clientset "k8s.io/client-go/kubernetes" v1core "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/client-go/tools/record" proxyapp "k8s.io/kubernetes/cmd/kube-proxy/app" - api "k8s.io/kubernetes/pkg/apis/core" - clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" "k8s.io/kubernetes/pkg/proxy" proxyconfig "k8s.io/kubernetes/pkg/proxy/config" "k8s.io/kubernetes/pkg/proxy/iptables" @@ -51,14 +50,14 @@ func (*FakeProxier) Sync() {} func (*FakeProxier) SyncLoop() { select {} } -func (*FakeProxier) OnServiceAdd(service *api.Service) {} -func (*FakeProxier) OnServiceUpdate(oldService, service *api.Service) {} -func (*FakeProxier) OnServiceDelete(service *api.Service) {} -func (*FakeProxier) OnServiceSynced() {} -func (*FakeProxier) OnEndpointsAdd(endpoints *api.Endpoints) {} -func (*FakeProxier) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) {} -func (*FakeProxier) OnEndpointsDelete(endpoints *api.Endpoints) {} -func (*FakeProxier) OnEndpointsSynced() {} +func (*FakeProxier) OnServiceAdd(service *v1.Service) {} +func (*FakeProxier) OnServiceUpdate(oldService, service *v1.Service) {} +func (*FakeProxier) OnServiceDelete(service *v1.Service) {} +func (*FakeProxier) OnServiceSynced() {} +func (*FakeProxier) OnEndpointsAdd(endpoints *v1.Endpoints) {} +func (*FakeProxier) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) {} +func (*FakeProxier) OnEndpointsDelete(endpoints *v1.Endpoints) {} +func (*FakeProxier) OnEndpointsSynced() {} func NewHollowProxyOrDie( nodeName string, @@ -142,12 +141,12 @@ func (hp *HollowProxy) Run() { func getNodeIP(client clientset.Interface, hostname string) net.IP { var nodeIP net.IP - node, err := client.Core().Nodes().Get(hostname, metav1.GetOptions{}) + node, err := client.CoreV1().Nodes().Get(hostname, metav1.GetOptions{}) if err != nil { glog.Warningf("Failed to retrieve node info: %v", err) return nil } - nodeIP, err = utilnode.InternalGetNodeHostIP(node) + nodeIP, err = utilnode.GetNodeHostIP(node) if err != nil { glog.Warningf("Failed to retrieve node IP: %v", err) return nil diff --git a/pkg/proxy/config/api_test.go b/pkg/proxy/config/api_test.go index 234129b18f..340a651fc3 100644 --- a/pkg/proxy/config/api_test.go +++ b/pkg/proxy/config/api_test.go @@ -22,25 +22,25 @@ import ( "testing" "time" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/watch" + informers "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" ktesting "k8s.io/client-go/testing" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" - informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion" ) func TestNewServicesSourceApi_UpdatesAndMultipleServices(t *testing.T) { - service1v1 := &api.Service{ + service1v1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "s1"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}} - service1v2 := &api.Service{ + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}} + service1v2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "s1"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 20}}}} - service2 := &api.Service{ + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 20}}}} + service2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "s2"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 30}}}} + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 30}}}} // Setup fake api client. client := fake.NewSimpleClientset() @@ -54,59 +54,59 @@ func TestNewServicesSourceApi_UpdatesAndMultipleServices(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - serviceConfig := NewServiceConfig(sharedInformers.Core().InternalVersion().Services(), time.Minute) + serviceConfig := NewServiceConfig(sharedInformers.Core().V1().Services(), time.Minute) serviceConfig.RegisterEventHandler(handler) go sharedInformers.Start(stopCh) go serviceConfig.Run(stopCh) // Add the first service fakeWatch.Add(service1v1) - handler.ValidateServices(t, []*api.Service{service1v1}) + handler.ValidateServices(t, []*v1.Service{service1v1}) // Add another service fakeWatch.Add(service2) - handler.ValidateServices(t, []*api.Service{service1v1, service2}) + handler.ValidateServices(t, []*v1.Service{service1v1, service2}) // Modify service1 fakeWatch.Modify(service1v2) - handler.ValidateServices(t, []*api.Service{service1v2, service2}) + handler.ValidateServices(t, []*v1.Service{service1v2, service2}) // Delete service1 fakeWatch.Delete(service1v2) - handler.ValidateServices(t, []*api.Service{service2}) + handler.ValidateServices(t, []*v1.Service{service2}) // Delete service2 fakeWatch.Delete(service2) - handler.ValidateServices(t, []*api.Service{}) + handler.ValidateServices(t, []*v1.Service{}) } func TestNewEndpointsSourceApi_UpdatesAndMultipleEndpoints(t *testing.T) { - endpoints1v1 := &api.Endpoints{ + endpoints1v1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "e1"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{ + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{ {IP: "1.2.3.4"}, }, - Ports: []api.EndpointPort{{Port: 8080, Protocol: "TCP"}}, + Ports: []v1.EndpointPort{{Port: 8080, Protocol: "TCP"}}, }}, } - endpoints1v2 := &api.Endpoints{ + endpoints1v2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "e1"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{ + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{ {IP: "1.2.3.4"}, {IP: "4.3.2.1"}, }, - Ports: []api.EndpointPort{{Port: 8080, Protocol: "TCP"}}, + Ports: []v1.EndpointPort{{Port: 8080, Protocol: "TCP"}}, }}, } - endpoints2 := &api.Endpoints{ + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "e2"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{ + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{ {IP: "5.6.7.8"}, }, - Ports: []api.EndpointPort{{Port: 80, Protocol: "TCP"}}, + Ports: []v1.EndpointPort{{Port: 80, Protocol: "TCP"}}, }}, } @@ -122,37 +122,37 @@ func TestNewEndpointsSourceApi_UpdatesAndMultipleEndpoints(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - endpointsConfig := NewEndpointsConfig(sharedInformers.Core().InternalVersion().Endpoints(), time.Minute) + endpointsConfig := NewEndpointsConfig(sharedInformers.Core().V1().Endpoints(), time.Minute) endpointsConfig.RegisterEventHandler(handler) go sharedInformers.Start(stopCh) go endpointsConfig.Run(stopCh) // Add the first endpoints fakeWatch.Add(endpoints1v1) - handler.ValidateEndpoints(t, []*api.Endpoints{endpoints1v1}) + handler.ValidateEndpoints(t, []*v1.Endpoints{endpoints1v1}) // Add another endpoints fakeWatch.Add(endpoints2) - handler.ValidateEndpoints(t, []*api.Endpoints{endpoints1v1, endpoints2}) + handler.ValidateEndpoints(t, []*v1.Endpoints{endpoints1v1, endpoints2}) // Modify endpoints1 fakeWatch.Modify(endpoints1v2) - handler.ValidateEndpoints(t, []*api.Endpoints{endpoints1v2, endpoints2}) + handler.ValidateEndpoints(t, []*v1.Endpoints{endpoints1v2, endpoints2}) // Delete endpoints1 fakeWatch.Delete(endpoints1v2) - handler.ValidateEndpoints(t, []*api.Endpoints{endpoints2}) + handler.ValidateEndpoints(t, []*v1.Endpoints{endpoints2}) // Delete endpoints2 fakeWatch.Delete(endpoints2) - handler.ValidateEndpoints(t, []*api.Endpoints{}) + handler.ValidateEndpoints(t, []*v1.Endpoints{}) } -func newSvcHandler(t *testing.T, svcs []*api.Service, done func()) ServiceHandler { +func newSvcHandler(t *testing.T, svcs []*v1.Service, done func()) ServiceHandler { shm := &ServiceHandlerMock{ - state: make(map[types.NamespacedName]*api.Service), + state: make(map[types.NamespacedName]*v1.Service), } - shm.process = func(services []*api.Service) { + shm.process = func(services []*v1.Service) { defer done() if !reflect.DeepEqual(services, svcs) { t.Errorf("Unexpected services: %#v, expected: %#v", services, svcs) @@ -161,11 +161,11 @@ func newSvcHandler(t *testing.T, svcs []*api.Service, done func()) ServiceHandle return shm } -func newEpsHandler(t *testing.T, eps []*api.Endpoints, done func()) EndpointsHandler { +func newEpsHandler(t *testing.T, eps []*v1.Endpoints, done func()) EndpointsHandler { ehm := &EndpointsHandlerMock{ - state: make(map[types.NamespacedName]*api.Endpoints), + state: make(map[types.NamespacedName]*v1.Endpoints), } - ehm.process = func(endpoints []*api.Endpoints) { + ehm.process = func(endpoints []*v1.Endpoints) { defer done() if !reflect.DeepEqual(eps, endpoints) { t.Errorf("Unexpected endpoints: %#v, expected: %#v", endpoints, eps) @@ -175,18 +175,18 @@ func newEpsHandler(t *testing.T, eps []*api.Endpoints, done func()) EndpointsHan } func TestInitialSync(t *testing.T) { - svc1 := &api.Service{ + svc1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}, } - svc2 := &api.Service{ + svc2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}, } - eps1 := &api.Endpoints{ + eps1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, } - eps2 := &api.Endpoints{ + eps2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, } @@ -198,11 +198,11 @@ func TestInitialSync(t *testing.T) { client := fake.NewSimpleClientset(svc1, svc2, eps2, eps1) sharedInformers := informers.NewSharedInformerFactory(client, 0) - svcConfig := NewServiceConfig(sharedInformers.Core().InternalVersion().Services(), 0) - epsConfig := NewEndpointsConfig(sharedInformers.Core().InternalVersion().Endpoints(), 0) - svcHandler := newSvcHandler(t, []*api.Service{svc2, svc1}, wg.Done) + svcConfig := NewServiceConfig(sharedInformers.Core().V1().Services(), 0) + epsConfig := NewEndpointsConfig(sharedInformers.Core().V1().Endpoints(), 0) + svcHandler := newSvcHandler(t, []*v1.Service{svc2, svc1}, wg.Done) svcConfig.RegisterEventHandler(svcHandler) - epsHandler := newEpsHandler(t, []*api.Endpoints{eps2, eps1}, wg.Done) + epsHandler := newEpsHandler(t, []*v1.Endpoints{eps2, eps1}, wg.Done) epsConfig.RegisterEventHandler(epsHandler) stopCh := make(chan struct{}) diff --git a/pkg/proxy/config/config.go b/pkg/proxy/config/config.go index 33e0bd169e..0a2bd65f3e 100644 --- a/pkg/proxy/config/config.go +++ b/pkg/proxy/config/config.go @@ -21,11 +21,11 @@ import ( "time" "github.com/golang/glog" + "k8s.io/api/core/v1" utilruntime "k8s.io/apimachinery/pkg/util/runtime" + coreinformers "k8s.io/client-go/informers/core/v1" + listers "k8s.io/client-go/listers/core/v1" "k8s.io/client-go/tools/cache" - api "k8s.io/kubernetes/pkg/apis/core" - coreinformers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion/core/internalversion" - listers "k8s.io/kubernetes/pkg/client/listers/core/internalversion" "k8s.io/kubernetes/pkg/controller" ) @@ -34,13 +34,13 @@ import ( type ServiceHandler interface { // OnServiceAdd is called whenever creation of new service object // is observed. - OnServiceAdd(service *api.Service) + OnServiceAdd(service *v1.Service) // OnServiceUpdate is called whenever modification of an existing // service object is observed. - OnServiceUpdate(oldService, service *api.Service) + OnServiceUpdate(oldService, service *v1.Service) // OnServiceDelete is called whenever deletion of an existing service // object is observed. - OnServiceDelete(service *api.Service) + OnServiceDelete(service *v1.Service) // OnServiceSynced is called once all the initial even handlers were // called and the state is fully propagated to local cache. OnServiceSynced() @@ -51,13 +51,13 @@ type ServiceHandler interface { type EndpointsHandler interface { // OnEndpointsAdd is called whenever creation of new endpoints object // is observed. - OnEndpointsAdd(endpoints *api.Endpoints) + OnEndpointsAdd(endpoints *v1.Endpoints) // OnEndpointsUpdate is called whenever modification of an existing // endpoints object is observed. - OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) + OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) // OnEndpointsDelete is called whever deletion of an existing endpoints // object is observed. - OnEndpointsDelete(endpoints *api.Endpoints) + OnEndpointsDelete(endpoints *v1.Endpoints) // OnEndpointsSynced is called once all the initial event handlers were // called and the state is fully propagated to local cache. OnEndpointsSynced() @@ -115,7 +115,7 @@ func (c *EndpointsConfig) Run(stopCh <-chan struct{}) { } func (c *EndpointsConfig) handleAddEndpoints(obj interface{}) { - endpoints, ok := obj.(*api.Endpoints) + endpoints, ok := obj.(*v1.Endpoints) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return @@ -127,12 +127,12 @@ func (c *EndpointsConfig) handleAddEndpoints(obj interface{}) { } func (c *EndpointsConfig) handleUpdateEndpoints(oldObj, newObj interface{}) { - oldEndpoints, ok := oldObj.(*api.Endpoints) + oldEndpoints, ok := oldObj.(*v1.Endpoints) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", oldObj)) return } - endpoints, ok := newObj.(*api.Endpoints) + endpoints, ok := newObj.(*v1.Endpoints) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", newObj)) return @@ -144,14 +144,14 @@ func (c *EndpointsConfig) handleUpdateEndpoints(oldObj, newObj interface{}) { } func (c *EndpointsConfig) handleDeleteEndpoints(obj interface{}) { - endpoints, ok := obj.(*api.Endpoints) + endpoints, ok := obj.(*v1.Endpoints) if !ok { tombstone, ok := obj.(cache.DeletedFinalStateUnknown) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return } - if endpoints, ok = tombstone.Obj.(*api.Endpoints); !ok { + if endpoints, ok = tombstone.Obj.(*v1.Endpoints); !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return } @@ -215,7 +215,7 @@ func (c *ServiceConfig) Run(stopCh <-chan struct{}) { } func (c *ServiceConfig) handleAddService(obj interface{}) { - service, ok := obj.(*api.Service) + service, ok := obj.(*v1.Service) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return @@ -227,12 +227,12 @@ func (c *ServiceConfig) handleAddService(obj interface{}) { } func (c *ServiceConfig) handleUpdateService(oldObj, newObj interface{}) { - oldService, ok := oldObj.(*api.Service) + oldService, ok := oldObj.(*v1.Service) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", oldObj)) return } - service, ok := newObj.(*api.Service) + service, ok := newObj.(*v1.Service) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", newObj)) return @@ -244,14 +244,14 @@ func (c *ServiceConfig) handleUpdateService(oldObj, newObj interface{}) { } func (c *ServiceConfig) handleDeleteService(obj interface{}) { - service, ok := obj.(*api.Service) + service, ok := obj.(*v1.Service) if !ok { tombstone, ok := obj.(cache.DeletedFinalStateUnknown) if !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return } - if service, ok = tombstone.Obj.(*api.Service); !ok { + if service, ok = tombstone.Obj.(*v1.Service); !ok { utilruntime.HandleError(fmt.Errorf("unexpected object type: %v", obj)) return } diff --git a/pkg/proxy/config/config_test.go b/pkg/proxy/config/config_test.go index e6a3a6cb53..531b3b1a08 100644 --- a/pkg/proxy/config/config_test.go +++ b/pkg/proxy/config/config_test.go @@ -23,17 +23,17 @@ import ( "testing" "time" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/watch" + informers "k8s.io/client-go/informers" + "k8s.io/client-go/kubernetes/fake" ktesting "k8s.io/client-go/testing" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" - informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion" ) -type sortedServices []*api.Service +type sortedServices []*v1.Service func (s sortedServices) Len() int { return len(s) @@ -48,24 +48,24 @@ func (s sortedServices) Less(i, j int) bool { type ServiceHandlerMock struct { lock sync.Mutex - state map[types.NamespacedName]*api.Service + state map[types.NamespacedName]*v1.Service synced bool - updated chan []*api.Service - process func([]*api.Service) + updated chan []*v1.Service + process func([]*v1.Service) } func NewServiceHandlerMock() *ServiceHandlerMock { shm := &ServiceHandlerMock{ - state: make(map[types.NamespacedName]*api.Service), - updated: make(chan []*api.Service, 5), + state: make(map[types.NamespacedName]*v1.Service), + updated: make(chan []*v1.Service, 5), } - shm.process = func(services []*api.Service) { + shm.process = func(services []*v1.Service) { shm.updated <- services } return shm } -func (h *ServiceHandlerMock) OnServiceAdd(service *api.Service) { +func (h *ServiceHandlerMock) OnServiceAdd(service *v1.Service) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} @@ -73,7 +73,7 @@ func (h *ServiceHandlerMock) OnServiceAdd(service *api.Service) { h.sendServices() } -func (h *ServiceHandlerMock) OnServiceUpdate(oldService, service *api.Service) { +func (h *ServiceHandlerMock) OnServiceUpdate(oldService, service *v1.Service) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} @@ -81,7 +81,7 @@ func (h *ServiceHandlerMock) OnServiceUpdate(oldService, service *api.Service) { h.sendServices() } -func (h *ServiceHandlerMock) OnServiceDelete(service *api.Service) { +func (h *ServiceHandlerMock) OnServiceDelete(service *v1.Service) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} @@ -100,7 +100,7 @@ func (h *ServiceHandlerMock) sendServices() { if !h.synced { return } - services := make([]*api.Service, 0, len(h.state)) + services := make([]*v1.Service, 0, len(h.state)) for _, svc := range h.state { services = append(services, svc) } @@ -108,11 +108,11 @@ func (h *ServiceHandlerMock) sendServices() { h.process(services) } -func (h *ServiceHandlerMock) ValidateServices(t *testing.T, expectedServices []*api.Service) { +func (h *ServiceHandlerMock) ValidateServices(t *testing.T, expectedServices []*v1.Service) { // We might get 1 or more updates for N service updates, because we // over write older snapshots of services from the producer go-routine // if the consumer falls behind. - var services []*api.Service + var services []*v1.Service for { select { case services = <-h.updated: @@ -128,7 +128,7 @@ func (h *ServiceHandlerMock) ValidateServices(t *testing.T, expectedServices []* } } -type sortedEndpoints []*api.Endpoints +type sortedEndpoints []*v1.Endpoints func (s sortedEndpoints) Len() int { return len(s) @@ -143,24 +143,24 @@ func (s sortedEndpoints) Less(i, j int) bool { type EndpointsHandlerMock struct { lock sync.Mutex - state map[types.NamespacedName]*api.Endpoints + state map[types.NamespacedName]*v1.Endpoints synced bool - updated chan []*api.Endpoints - process func([]*api.Endpoints) + updated chan []*v1.Endpoints + process func([]*v1.Endpoints) } func NewEndpointsHandlerMock() *EndpointsHandlerMock { ehm := &EndpointsHandlerMock{ - state: make(map[types.NamespacedName]*api.Endpoints), - updated: make(chan []*api.Endpoints, 5), + state: make(map[types.NamespacedName]*v1.Endpoints), + updated: make(chan []*v1.Endpoints, 5), } - ehm.process = func(endpoints []*api.Endpoints) { + ehm.process = func(endpoints []*v1.Endpoints) { ehm.updated <- endpoints } return ehm } -func (h *EndpointsHandlerMock) OnEndpointsAdd(endpoints *api.Endpoints) { +func (h *EndpointsHandlerMock) OnEndpointsAdd(endpoints *v1.Endpoints) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} @@ -168,7 +168,7 @@ func (h *EndpointsHandlerMock) OnEndpointsAdd(endpoints *api.Endpoints) { h.sendEndpoints() } -func (h *EndpointsHandlerMock) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (h *EndpointsHandlerMock) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} @@ -176,7 +176,7 @@ func (h *EndpointsHandlerMock) OnEndpointsUpdate(oldEndpoints, endpoints *api.En h.sendEndpoints() } -func (h *EndpointsHandlerMock) OnEndpointsDelete(endpoints *api.Endpoints) { +func (h *EndpointsHandlerMock) OnEndpointsDelete(endpoints *v1.Endpoints) { h.lock.Lock() defer h.lock.Unlock() namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} @@ -195,7 +195,7 @@ func (h *EndpointsHandlerMock) sendEndpoints() { if !h.synced { return } - endpoints := make([]*api.Endpoints, 0, len(h.state)) + endpoints := make([]*v1.Endpoints, 0, len(h.state)) for _, eps := range h.state { endpoints = append(endpoints, eps) } @@ -203,11 +203,11 @@ func (h *EndpointsHandlerMock) sendEndpoints() { h.process(endpoints) } -func (h *EndpointsHandlerMock) ValidateEndpoints(t *testing.T, expectedEndpoints []*api.Endpoints) { +func (h *EndpointsHandlerMock) ValidateEndpoints(t *testing.T, expectedEndpoints []*v1.Endpoints) { // We might get 1 or more updates for N endpoint updates, because we // over write older snapshots of endpoints from the producer go-routine // if the consumer falls behind. Unittests will hard timeout in 5m. - var endpoints []*api.Endpoints + var endpoints []*v1.Endpoints for { select { case endpoints = <-h.updated: @@ -233,18 +233,18 @@ func TestNewServiceAddedAndNotified(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - config := NewServiceConfig(sharedInformers.Core().InternalVersion().Services(), time.Minute) + config := NewServiceConfig(sharedInformers.Core().V1().Services(), time.Minute) handler := NewServiceHandlerMock() config.RegisterEventHandler(handler) go sharedInformers.Start(stopCh) go config.Run(stopCh) - service := &api.Service{ + service := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}, } fakeWatch.Add(service) - handler.ValidateServices(t, []*api.Service{service}) + handler.ValidateServices(t, []*v1.Service{service}) } func TestServiceAddedRemovedSetAndNotified(t *testing.T) { @@ -257,29 +257,29 @@ func TestServiceAddedRemovedSetAndNotified(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - config := NewServiceConfig(sharedInformers.Core().InternalVersion().Services(), time.Minute) + config := NewServiceConfig(sharedInformers.Core().V1().Services(), time.Minute) handler := NewServiceHandlerMock() config.RegisterEventHandler(handler) go sharedInformers.Start(stopCh) go config.Run(stopCh) - service1 := &api.Service{ + service1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}, } fakeWatch.Add(service1) - handler.ValidateServices(t, []*api.Service{service1}) + handler.ValidateServices(t, []*v1.Service{service1}) - service2 := &api.Service{ + service2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 20}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 20}}}, } fakeWatch.Add(service2) - services := []*api.Service{service2, service1} + services := []*v1.Service{service2, service1} handler.ValidateServices(t, services) fakeWatch.Delete(service1) - services = []*api.Service{service2} + services = []*v1.Service{service2} handler.ValidateServices(t, services) } @@ -293,7 +293,7 @@ func TestNewServicesMultipleHandlersAddedAndNotified(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - config := NewServiceConfig(sharedInformers.Core().InternalVersion().Services(), time.Minute) + config := NewServiceConfig(sharedInformers.Core().V1().Services(), time.Minute) handler := NewServiceHandlerMock() handler2 := NewServiceHandlerMock() config.RegisterEventHandler(handler) @@ -301,18 +301,18 @@ func TestNewServicesMultipleHandlersAddedAndNotified(t *testing.T) { go sharedInformers.Start(stopCh) go config.Run(stopCh) - service1 := &api.Service{ + service1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 10}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 10}}}, } - service2 := &api.Service{ + service2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, - Spec: api.ServiceSpec{Ports: []api.ServicePort{{Protocol: "TCP", Port: 20}}}, + Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Protocol: "TCP", Port: 20}}}, } fakeWatch.Add(service1) fakeWatch.Add(service2) - services := []*api.Service{service2, service1} + services := []*v1.Service{service2, service1} handler.ValidateServices(t, services) handler2.ValidateServices(t, services) } @@ -327,7 +327,7 @@ func TestNewEndpointsMultipleHandlersAddedAndNotified(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - config := NewEndpointsConfig(sharedInformers.Core().InternalVersion().Endpoints(), time.Minute) + config := NewEndpointsConfig(sharedInformers.Core().V1().Endpoints(), time.Minute) handler := NewEndpointsHandlerMock() handler2 := NewEndpointsHandlerMock() config.RegisterEventHandler(handler) @@ -335,24 +335,24 @@ func TestNewEndpointsMultipleHandlersAddedAndNotified(t *testing.T) { go sharedInformers.Start(stopCh) go config.Run(stopCh) - endpoints1 := &api.Endpoints{ + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "1.1.1.1"}, {IP: "2.2.2.2"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "1.1.1.1"}, {IP: "2.2.2.2"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } - endpoints2 := &api.Endpoints{ + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "3.3.3.3"}, {IP: "4.4.4.4"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "3.3.3.3"}, {IP: "4.4.4.4"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } fakeWatch.Add(endpoints1) fakeWatch.Add(endpoints2) - endpoints := []*api.Endpoints{endpoints2, endpoints1} + endpoints := []*v1.Endpoints{endpoints2, endpoints1} handler.ValidateEndpoints(t, endpoints) handler2.ValidateEndpoints(t, endpoints) } @@ -367,7 +367,7 @@ func TestNewEndpointsMultipleHandlersAddRemoveSetAndNotified(t *testing.T) { sharedInformers := informers.NewSharedInformerFactory(client, time.Minute) - config := NewEndpointsConfig(sharedInformers.Core().InternalVersion().Endpoints(), time.Minute) + config := NewEndpointsConfig(sharedInformers.Core().V1().Endpoints(), time.Minute) handler := NewEndpointsHandlerMock() handler2 := NewEndpointsHandlerMock() config.RegisterEventHandler(handler) @@ -375,56 +375,56 @@ func TestNewEndpointsMultipleHandlersAddRemoveSetAndNotified(t *testing.T) { go sharedInformers.Start(stopCh) go config.Run(stopCh) - endpoints1 := &api.Endpoints{ + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "1.1.1.1"}, {IP: "2.2.2.2"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "1.1.1.1"}, {IP: "2.2.2.2"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } - endpoints2 := &api.Endpoints{ + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "bar"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "3.3.3.3"}, {IP: "4.4.4.4"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "3.3.3.3"}, {IP: "4.4.4.4"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } fakeWatch.Add(endpoints1) fakeWatch.Add(endpoints2) - endpoints := []*api.Endpoints{endpoints2, endpoints1} + endpoints := []*v1.Endpoints{endpoints2, endpoints1} handler.ValidateEndpoints(t, endpoints) handler2.ValidateEndpoints(t, endpoints) // Add one more - endpoints3 := &api.Endpoints{ + endpoints3 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foobar"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "5.5.5.5"}, {IP: "6.6.6.6"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "5.5.5.5"}, {IP: "6.6.6.6"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } fakeWatch.Add(endpoints3) - endpoints = []*api.Endpoints{endpoints2, endpoints1, endpoints3} + endpoints = []*v1.Endpoints{endpoints2, endpoints1, endpoints3} handler.ValidateEndpoints(t, endpoints) handler2.ValidateEndpoints(t, endpoints) // Update the "foo" service with new endpoints - endpoints1v2 := &api.Endpoints{ + endpoints1v2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: "testnamespace", Name: "foo"}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "7.7.7.7"}}, - Ports: []api.EndpointPort{{Port: 80}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "7.7.7.7"}}, + Ports: []v1.EndpointPort{{Port: 80}}, }}, } fakeWatch.Modify(endpoints1v2) - endpoints = []*api.Endpoints{endpoints2, endpoints1v2, endpoints3} + endpoints = []*v1.Endpoints{endpoints2, endpoints1v2, endpoints3} handler.ValidateEndpoints(t, endpoints) handler2.ValidateEndpoints(t, endpoints) // Remove "bar" endpoints fakeWatch.Delete(endpoints2) - endpoints = []*api.Endpoints{endpoints1v2, endpoints3} + endpoints = []*v1.Endpoints{endpoints1v2, endpoints3} handler.ValidateEndpoints(t, endpoints) handler2.ValidateEndpoints(t, endpoints) } diff --git a/pkg/proxy/endpoints.go b/pkg/proxy/endpoints.go index 36f53c9899..06c7d3ad5a 100644 --- a/pkg/proxy/endpoints.go +++ b/pkg/proxy/endpoints.go @@ -24,10 +24,10 @@ import ( "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/tools/record" - api "k8s.io/kubernetes/pkg/apis/core" utilproxy "k8s.io/kubernetes/pkg/proxy/util" utilnet "k8s.io/kubernetes/pkg/util/net" ) @@ -113,7 +113,7 @@ func NewEndpointChangeTracker(hostname string, makeEndpointInfo makeEndpointFunc // - pass as the pair. // Delete item // - pass as the pair. -func (ect *EndpointChangeTracker) Update(previous, current *api.Endpoints) bool { +func (ect *EndpointChangeTracker) Update(previous, current *v1.Endpoints) bool { endpoints := current if endpoints == nil { endpoints = previous @@ -184,7 +184,7 @@ type EndpointsMap map[ServicePortName][]Endpoint // This function is used for incremental updated of endpointsMap. // // NOTE: endpoints object should NOT be modified. -func (ect *EndpointChangeTracker) endpointsToEndpointsMap(endpoints *api.Endpoints) EndpointsMap { +func (ect *EndpointChangeTracker) endpointsToEndpointsMap(endpoints *v1.Endpoints) EndpointsMap { if endpoints == nil { return nil } diff --git a/pkg/proxy/endpoints_test.go b/pkg/proxy/endpoints_test.go index c04f3aa498..24fb61ad96 100644 --- a/pkg/proxy/endpoints_test.go +++ b/pkg/proxy/endpoints_test.go @@ -22,21 +22,21 @@ import ( "github.com/davecgh/go-spew/spew" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" - api "k8s.io/kubernetes/pkg/apis/core" ) -func (proxier *FakeProxier) addEndpoints(endpoints *api.Endpoints) { +func (proxier *FakeProxier) addEndpoints(endpoints *v1.Endpoints) { proxier.endpointsChanges.Update(nil, endpoints) } -func (proxier *FakeProxier) updateEndpoints(oldEndpoints, endpoints *api.Endpoints) { +func (proxier *FakeProxier) updateEndpoints(oldEndpoints, endpoints *v1.Endpoints) { proxier.endpointsChanges.Update(oldEndpoints, endpoints) } -func (proxier *FakeProxier) deleteEndpoints(endpoints *api.Endpoints) { +func (proxier *FakeProxier) deleteEndpoints(endpoints *v1.Endpoints) { proxier.endpointsChanges.Update(endpoints, nil) } @@ -118,8 +118,8 @@ func TestGetLocalEndpointIPs(t *testing.T) { } } -func makeTestEndpoints(namespace, name string, eptFunc func(*api.Endpoints)) *api.Endpoints { - ept := &api.Endpoints{ +func makeTestEndpoints(namespace, name string, eptFunc func(*v1.Endpoints)) *v1.Endpoints { + ept := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, @@ -138,24 +138,24 @@ func TestEndpointsToEndpointsMap(t *testing.T) { testCases := []struct { desc string - newEndpoints *api.Endpoints + newEndpoints *v1.Endpoints expected map[ServicePortName][]*BaseEndpointInfo isIPv6Mode *bool }{ { desc: "nothing", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) {}), + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) {}), expected: map[ServicePortName][]*BaseEndpointInfo{}, }, { desc: "no changes, unnamed port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "", Port: 11, }}, @@ -170,13 +170,13 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "no changes, named port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "port", Port: 11, }}, @@ -191,13 +191,13 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "new port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }, @@ -211,20 +211,20 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "remove port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) {}), + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) {}), expected: map[ServicePortName][]*BaseEndpointInfo{}, }, { desc: "new IP and port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "2.2.2.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p1", Port: 11, }, { @@ -247,13 +247,13 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "remove IP and port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p1", Port: 11, }}, @@ -268,13 +268,13 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "rename port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p2", Port: 11, }}, @@ -289,13 +289,13 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "renumber port", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p1", Port: 22, }}, @@ -310,15 +310,15 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "should omit IPv6 address in IPv4 mode", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "2001:db8:85a3:0:0:8a2e:370:7334", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p1", Port: 11, }, { @@ -340,15 +340,15 @@ func TestEndpointsToEndpointsMap(t *testing.T) { }, { desc: "should omit IPv4 address in IPv6 mode", - newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + newEndpoints: makeTestEndpoints("ns1", "ep1", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "2001:db8:85a3:0:0:8a2e:370:7334", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p1", Port: 11, }, { @@ -396,84 +396,84 @@ func TestEndpointsToEndpointsMap(t *testing.T) { func TestUpdateEndpointsMap(t *testing.T) { var nodeName = testHostname - emptyEndpoint := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{} + emptyEndpoint := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{} } - unnamedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - unnamedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - namedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPortRenamed := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenamed := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11-2", Port: 11, }}, }} } - namedPortRenumbered := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenumbered := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 22, }}, }} } - namedPortsLocalNoLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortsLocalNoLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -482,52 +482,52 @@ func TestUpdateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsets := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsets := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsWithLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsWithLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsMultiplePortsLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsMultiplePortsLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -535,24 +535,24 @@ func TestUpdateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }}, }} } - multipleSubsetsIPsPorts1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -560,13 +560,13 @@ func TestUpdateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }, { IP: "1.1.1.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }, { @@ -575,15 +575,15 @@ func TestUpdateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsetsIPsPorts2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.1", }, { IP: "2.2.2.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p21", Port: 21, }, { @@ -592,81 +592,81 @@ func TestUpdateEndpointsMap(t *testing.T) { }}, }} } - complexBefore1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - complexBefore2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.2", NodeName: &nodeName, }, { IP: "2.2.2.22", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p22", Port: 22, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.3", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p23", Port: 23, }}, }} } - complexBefore4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }, { IP: "4.4.4.5", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.6", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p45", Port: 45, }}, }} } - complexAfter1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.11", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }, { @@ -675,24 +675,24 @@ func TestUpdateEndpointsMap(t *testing.T) { }}, }} } - complexAfter3 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter3 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "3.3.3.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p33", Port: 33, }}, }} } - complexAfter4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, @@ -703,8 +703,8 @@ func TestUpdateEndpointsMap(t *testing.T) { // previousEndpoints and currentEndpoints are used to call appropriate // handlers OnEndpoints* (based on whether corresponding values are nil // or non-nil) and must be of equal length. - previousEndpoints []*api.Endpoints - currentEndpoints []*api.Endpoints + previousEndpoints []*v1.Endpoints + currentEndpoints []*v1.Endpoints oldEndpoints map[ServicePortName][]*BaseEndpointInfo expectedResult map[ServicePortName][]*BaseEndpointInfo expectedStaleEndpoints []ServiceEndpoint @@ -719,10 +719,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[1]: no change, unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -740,10 +740,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[2]: no change, named port, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -763,10 +763,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[3]: no change, multiple subsets - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -790,10 +790,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[4]: no change, multiple subsets, multiple ports, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -825,11 +825,11 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[5]: no change, multiple endpoints, subsets, IPs, and ports - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, @@ -893,10 +893,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[6]: add an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ nil, }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{}, @@ -914,10 +914,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[7]: remove an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ nil, }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -934,10 +934,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[8]: add an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -964,10 +964,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[9]: remove an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -999,10 +999,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[10]: add a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsWithLocal), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -1027,10 +1027,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[11]: remove a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -1054,10 +1054,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[12]: rename a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenamed), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -1080,10 +1080,10 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[13]: renumber a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenumbered), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{ @@ -1104,13 +1104,13 @@ func TestUpdateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[14]: complex add and remove - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexBefore1), makeTestEndpoints("ns2", "ep2", complexBefore2), nil, makeTestEndpoints("ns4", "ep4", complexBefore4), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexAfter1), nil, makeTestEndpoints("ns3", "ep3", complexAfter3), @@ -1179,10 +1179,10 @@ func TestUpdateEndpointsMap(t *testing.T) { }, }, { // Case[15]: change from 0 endpoint address to 1 unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", emptyEndpoint), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[ServicePortName][]*BaseEndpointInfo{}, diff --git a/pkg/proxy/iptables/proxier.go b/pkg/proxy/iptables/proxier.go index d6157e4127..470916ce70 100644 --- a/pkg/proxy/iptables/proxier.go +++ b/pkg/proxy/iptables/proxier.go @@ -38,7 +38,6 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/tools/record" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/proxy/healthcheck" "k8s.io/kubernetes/pkg/proxy/metrics" @@ -149,7 +148,7 @@ type serviceInfo struct { } // returns a new proxy.ServicePort which abstracts a serviceInfo -func newServiceInfo(port *api.ServicePort, service *api.Service, baseInfo *proxy.BaseServiceInfo) proxy.ServicePort { +func newServiceInfo(port *v1.ServicePort, service *v1.Service, baseInfo *proxy.BaseServiceInfo) proxy.ServicePort { info := &serviceInfo{BaseServiceInfo: baseInfo} // Store the following for performance reasons. @@ -507,17 +506,17 @@ func (proxier *Proxier) isInitialized() bool { return atomic.LoadInt32(&proxier.initialized) > 0 } -func (proxier *Proxier) OnServiceAdd(service *api.Service) { +func (proxier *Proxier) OnServiceAdd(service *v1.Service) { proxier.OnServiceUpdate(nil, service) } -func (proxier *Proxier) OnServiceUpdate(oldService, service *api.Service) { +func (proxier *Proxier) OnServiceUpdate(oldService, service *v1.Service) { if proxier.serviceChanges.Update(oldService, service) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnServiceDelete(service *api.Service) { +func (proxier *Proxier) OnServiceDelete(service *v1.Service) { proxier.OnServiceUpdate(service, nil) } @@ -532,17 +531,17 @@ func (proxier *Proxier) OnServiceSynced() { proxier.syncProxyRules() } -func (proxier *Proxier) OnEndpointsAdd(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsAdd(endpoints *v1.Endpoints) { proxier.OnEndpointsUpdate(nil, endpoints) } -func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { if proxier.endpointsChanges.Update(oldEndpoints, endpoints) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnEndpointsDelete(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsDelete(endpoints *v1.Endpoints) { proxier.OnEndpointsUpdate(endpoints, nil) } @@ -602,7 +601,7 @@ func servicePortEndpointChainName(servicePortName string, protocol string, endpo // TODO: move it to util func (proxier *Proxier) deleteEndpointConnections(connectionMap []proxy.ServiceEndpoint) { for _, epSvcPair := range connectionMap { - if svcInfo, ok := proxier.serviceMap[epSvcPair.ServicePortName]; ok && svcInfo.GetProtocol() == api.ProtocolUDP { + if svcInfo, ok := proxier.serviceMap[epSvcPair.ServicePortName]; ok && svcInfo.GetProtocol() == v1.ProtocolUDP { endpointIP := utilproxy.IPPart(epSvcPair.Endpoint) err := conntrack.ClearEntriesForNAT(proxier.exec, svcInfo.ClusterIPString(), endpointIP, v1.ProtocolUDP) if err != nil { @@ -652,7 +651,7 @@ func (proxier *Proxier) syncProxyRules() { staleServices := serviceUpdateResult.UDPStaleClusterIP // merge stale services gathered from updateEndpointsMap for _, svcPortName := range endpointUpdateResult.StaleServiceNames { - if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.GetProtocol() == api.ProtocolUDP { + if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.GetProtocol() == v1.ProtocolUDP { glog.V(2).Infof("Stale udp service %v -> %s", svcPortName, svcInfo.ClusterIPString()) staleServices.Insert(svcInfo.ClusterIPString()) } @@ -869,7 +868,7 @@ func (proxier *Proxier) syncProxyRules() { Name: proxier.hostname, UID: types.UID(proxier.hostname), Namespace: "", - }, api.EventTypeWarning, err.Error(), msg) + }, v1.EventTypeWarning, err.Error(), msg) glog.Error(msg) continue } @@ -1103,7 +1102,7 @@ func (proxier *Proxier) syncProxyRules() { } // First write session affinity rules, if applicable. - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { for _, endpointChain := range endpointChains { args = append(args[:0], "-A", string(svcChain), @@ -1148,7 +1147,7 @@ func (proxier *Proxier) syncProxyRules() { "-s", utilproxy.ToCIDR(net.ParseIP(epIP)), "-j", string(KubeMarkMasqChain))...) // Update client-affinity lists. - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { args = append(args, "-m", "recent", "--name", string(endpointChain), "--set") } // DNAT to final destination. @@ -1199,7 +1198,7 @@ func (proxier *Proxier) syncProxyRules() { writeLine(proxier.natRules, args...) } else { // First write session affinity rules only over local endpoints, if applicable. - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { for _, endpointChain := range localEndpointChains { writeLine(proxier.natRules, "-A", string(svcXlbChain), diff --git a/pkg/proxy/iptables/proxier_test.go b/pkg/proxy/iptables/proxier_test.go index a2930e819a..c11cde9f0b 100644 --- a/pkg/proxy/iptables/proxier_test.go +++ b/pkg/proxy/iptables/proxier_test.go @@ -28,10 +28,10 @@ import ( "github.com/golang/glog" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/intstr" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" utilproxy "k8s.io/kubernetes/pkg/proxy/util" utilproxytest "k8s.io/kubernetes/pkg/proxy/util/testing" @@ -146,11 +146,11 @@ func TestGetChainLinesMultipleTables(t *testing.T) { checkAllLines(t, utiliptables.TableNAT, []byte(iptablesSave), expected) } -func newFakeServiceInfo(service proxy.ServicePortName, ip net.IP, port int, protocol api.Protocol, onlyNodeLocalEndpoints bool) *serviceInfo { +func newFakeServiceInfo(service proxy.ServicePortName, ip net.IP, port int, protocol v1.Protocol, onlyNodeLocalEndpoints bool) *serviceInfo { return &serviceInfo{ BaseServiceInfo: &proxy.BaseServiceInfo{ - SessionAffinityType: api.ServiceAffinityNone, // default - StickyMaxAgeSeconds: int(api.DefaultClientIPServiceAffinitySeconds), // default + SessionAffinityType: v1.ServiceAffinityNone, // default + StickyMaxAgeSeconds: int(v1.DefaultClientIPServiceAffinitySeconds), // default ClusterIP: ip, Port: port, Protocol: protocol, @@ -161,15 +161,15 @@ func newFakeServiceInfo(service proxy.ServicePortName, ip net.IP, port int, prot func TestDeleteEndpointConnections(t *testing.T) { const ( - UDP = api.ProtocolUDP - TCP = api.ProtocolTCP + UDP = v1.ProtocolUDP + TCP = v1.ProtocolTCP ) testCases := []struct { description string svcName string svcIP string svcPort int - protocol api.Protocol + protocol v1.Protocol endpoint string // IP:port endpoint epSvcPair proxy.ServiceEndpoint // Will be generated by test simulatedErr string @@ -564,19 +564,19 @@ func TestClusterIPReject(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} }), ) makeEndpointsMap(fp) fp.syncProxyRules() - svcChain := string(servicePortChainName(svcPortName.String(), strings.ToLower(string(api.ProtocolTCP)))) + svcChain := string(servicePortChainName(svcPortName.String(), strings.ToLower(string(v1.ProtocolTCP)))) svcRules := ipt.GetRules(svcChain) if len(svcRules) != 0 { errorf(fmt.Sprintf("Unexpected rule for chain %v service %v without endpoints", svcChain, svcPortName), svcRules, t) @@ -598,24 +598,24 @@ func TestClusterIPEndpointsJump(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} }), ) epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -626,8 +626,8 @@ func TestClusterIPEndpointsJump(t *testing.T) { fp.syncProxyRules() epStr := fmt.Sprintf("%s:%d", epIP, svcPort) - svcChain := string(servicePortChainName(svcPortName.String(), strings.ToLower(string(api.ProtocolTCP)))) - epChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(api.ProtocolTCP)), epStr)) + svcChain := string(servicePortChainName(svcPortName.String(), strings.ToLower(string(v1.ProtocolTCP)))) + epChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(v1.ProtocolTCP)), epStr)) kubeSvcRules := ipt.GetRules(string(kubeServicesChain)) if !hasJump(kubeSvcRules, svcChain, svcIP, svcPort) { @@ -657,16 +657,16 @@ func TestLoadBalancer(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "LoadBalancer" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: svcLBIP, }} }), @@ -674,12 +674,12 @@ func TestLoadBalancer(t *testing.T) { epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -689,7 +689,7 @@ func TestLoadBalancer(t *testing.T) { fp.syncProxyRules() - proto := strings.ToLower(string(api.ProtocolTCP)) + proto := strings.ToLower(string(v1.ProtocolTCP)) fwChain := string(serviceFirewallChainName(svcPortName.String(), proto)) svcChain := string(servicePortChainName(svcPortName.String(), proto)) @@ -716,13 +716,13 @@ func TestNodePort(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), @@ -730,12 +730,12 @@ func TestNodePort(t *testing.T) { epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -753,7 +753,7 @@ func TestNodePort(t *testing.T) { fp.syncProxyRules() - proto := strings.ToLower(string(api.ProtocolTCP)) + proto := strings.ToLower(string(v1.ProtocolTCP)) svcChain := string(servicePortChainName(svcPortName.String(), proto)) kubeNodePortRules := ipt.GetRules(string(kubeNodePortsChain)) @@ -774,14 +774,14 @@ func TestExternalIPsReject(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "ClusterIP" svc.Spec.ClusterIP = svcIP svc.Spec.ExternalIPs = []string{svcExternalIPs} - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, TargetPort: intstr.FromInt(svcPort), }} }), @@ -808,13 +808,13 @@ func TestNodePortReject(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), @@ -847,22 +847,22 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { svcSessionAffinityTimeout := int32(10800) makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "LoadBalancer" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: svcLBIP, }} - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal - svc.Spec.SessionAffinity = api.ServiceAffinityClientIP - svc.Spec.SessionAffinityConfig = &api.SessionAffinityConfig{ - ClientIP: &api.ClientIPConfig{TimeoutSeconds: &svcSessionAffinityTimeout}, + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP + svc.Spec.SessionAffinityConfig = &v1.SessionAffinityConfig{ + ClientIP: &v1.ClientIPConfig{TimeoutSeconds: &svcSessionAffinityTimeout}, } }), ) @@ -872,16 +872,16 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { epStrLocal := fmt.Sprintf("%s:%d", epIP1, svcPort) epStrNonLocal := fmt.Sprintf("%s:%d", epIP2, svcPort) makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP1, NodeName: nil, }, { IP: epIP2, NodeName: strPtr(testHostname), }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -891,12 +891,12 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { fp.syncProxyRules() - proto := strings.ToLower(string(api.ProtocolTCP)) + proto := strings.ToLower(string(v1.ProtocolTCP)) fwChain := string(serviceFirewallChainName(svcPortName.String(), proto)) lbChain := string(serviceLBChainName(svcPortName.String(), proto)) - nonLocalEpChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(api.ProtocolTCP)), epStrLocal)) - localEpChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(api.ProtocolTCP)), epStrNonLocal)) + nonLocalEpChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(v1.ProtocolTCP)), epStrLocal)) + localEpChain := string(servicePortEndpointChainName(svcPortName.String(), strings.ToLower(string(v1.ProtocolTCP)), epStrNonLocal)) kubeSvcRules := ipt.GetRules(string(kubeServicesChain)) if !hasJump(kubeSvcRules, fwChain, svcLBIP, svcPort) { @@ -948,16 +948,16 @@ func onlyLocalNodePorts(t *testing.T, fp *Proxier, ipt *iptablestest.FakeIPTable } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal }), ) @@ -966,16 +966,16 @@ func onlyLocalNodePorts(t *testing.T, fp *Proxier, ipt *iptablestest.FakeIPTable epStrLocal := fmt.Sprintf("%s:%d", epIP1, svcPort) epStrNonLocal := fmt.Sprintf("%s:%d", epIP2, svcPort) makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP1, NodeName: nil, }, { IP: epIP2, NodeName: strPtr(testHostname), }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -990,7 +990,7 @@ func onlyLocalNodePorts(t *testing.T, fp *Proxier, ipt *iptablestest.FakeIPTable fp.syncProxyRules() - proto := strings.ToLower(string(api.ProtocolTCP)) + proto := strings.ToLower(string(v1.ProtocolTCP)) lbChain := string(serviceLBChainName(svcPortName.String(), proto)) nonLocalEpChain := string(servicePortEndpointChainName(svcPortName.String(), proto, epStrLocal)) @@ -1026,22 +1026,22 @@ func onlyLocalNodePorts(t *testing.T, fp *Proxier, ipt *iptablestest.FakeIPTable } } -func makeTestService(namespace, name string, svcFunc func(*api.Service)) *api.Service { - svc := &api.Service{ +func makeTestService(namespace, name string, svcFunc func(*v1.Service)) *v1.Service { + svc := &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, Annotations: map[string]string{}, }, - Spec: api.ServiceSpec{}, - Status: api.ServiceStatus{}, + Spec: v1.ServiceSpec{}, + Status: v1.ServiceStatus{}, } svcFunc(svc) return svc } -func addTestPort(array []api.ServicePort, name string, protocol api.Protocol, port, nodeport int32, targetPort int) []api.ServicePort { - svcPort := api.ServicePort{ +func addTestPort(array []v1.ServicePort, name string, protocol v1.Protocol, port, nodeport int32, targetPort int) []v1.ServicePort { + svcPort := v1.ServicePort{ Name: name, Protocol: protocol, Port: port, @@ -1055,43 +1055,43 @@ func TestBuildServiceMapAddRemove(t *testing.T) { ipt := iptablestest.NewFake() fp := NewFakeProxier(ipt) - services := []*api.Service{ - makeTestService("somewhere-else", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + services := []*v1.Service{ + makeTestService("somewhere-else", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "UDP", 1235, 5321, 0) }), - makeTestService("somewhere-else", "node-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeNodePort + makeTestService("somewhere-else", "node-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.ClusterIP = "172.16.55.10" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "blahblah", "UDP", 345, 678, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "moreblahblah", "TCP", 344, 677, 0) }), - makeTestService("somewhere", "load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("somewhere", "load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.11" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar", "UDP", 8675, 30061, 7000) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8676, 30062, 7001) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.4"}, }, } }), - makeTestService("somewhere", "only-local-load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("somewhere", "only-local-load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.12" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar2", "UDP", 8677, 30063, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8678, 30064, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }), } @@ -1121,8 +1121,8 @@ func TestBuildServiceMapAddRemove(t *testing.T) { // Remove some stuff // oneService is a modification of services[0] with removed first port. - oneService := makeTestService("somewhere-else", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + oneService := makeTestService("somewhere-else", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "UDP", 1235, 5321, 0) }) @@ -1160,14 +1160,14 @@ func TestBuildServiceMapServiceHeadless(t *testing.T) { fp := NewFakeProxier(ipt) makeServiceMap(fp, - makeTestService("somewhere-else", "headless", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("somewhere-else", "headless", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone svc.Spec.Ports = addTestPort(svc.Spec.Ports, "rpc", "UDP", 1234, 0, 0) }), - makeTestService("somewhere-else", "headless-without-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("somewhere-else", "headless-without-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone }), ) @@ -1192,8 +1192,8 @@ func TestBuildServiceMapServiceTypeExternalName(t *testing.T) { fp := NewFakeProxier(ipt) makeServiceMap(fp, - makeTestService("somewhere-else", "external-name", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeExternalName + makeTestService("somewhere-else", "external-name", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeExternalName svc.Spec.ClusterIP = "172.16.55.4" // Should be ignored svc.Spec.ExternalName = "foo2.bar.com" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "blah", "UDP", 1235, 5321, 0) @@ -1217,24 +1217,24 @@ func TestBuildServiceMapServiceUpdate(t *testing.T) { ipt := iptablestest.NewFake() fp := NewFakeProxier(ipt) - servicev1 := makeTestService("somewhere", "some-service", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + servicev1 := makeTestService("somewhere", "some-service", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "TCP", 1235, 5321, 0) }) - servicev2 := makeTestService("somewhere", "some-service", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + servicev2 := makeTestService("somewhere", "some-service", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "TCP", 1235, 5321, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }) @@ -1294,8 +1294,8 @@ func TestBuildServiceMapServiceUpdate(t *testing.T) { } } -func makeTestEndpoints(namespace, name string, eptFunc func(*api.Endpoints)) *api.Endpoints { - ept := &api.Endpoints{ +func makeTestEndpoints(namespace, name string, eptFunc func(*v1.Endpoints)) *v1.Endpoints { + ept := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, @@ -1305,7 +1305,7 @@ func makeTestEndpoints(namespace, name string, eptFunc func(*api.Endpoints)) *ap return ept } -func makeEndpointsMap(proxier *Proxier, allEndpoints ...*api.Endpoints) { +func makeEndpointsMap(proxier *Proxier, allEndpoints ...*v1.Endpoints) { for i := range allEndpoints { proxier.OnEndpointsAdd(allEndpoints[i]) } @@ -1326,7 +1326,7 @@ func makeServicePortName(ns, name, port string) proxy.ServicePortName { } } -func makeServiceMap(proxier *Proxier, allServices ...*api.Service) { +func makeServiceMap(proxier *Proxier, allServices ...*v1.Service) { for i := range allServices { proxier.OnServiceAdd(allServices[i]) } @@ -1364,84 +1364,84 @@ func compareEndpointsMaps(t *testing.T, tci int, newMap proxy.EndpointsMap, expe func Test_updateEndpointsMap(t *testing.T) { var nodeName = testHostname - emptyEndpoint := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{} + emptyEndpoint := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{} } - unnamedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - unnamedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - namedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPortRenamed := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenamed := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11-2", Port: 11, }}, }} } - namedPortRenumbered := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenumbered := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 22, }}, }} } - namedPortsLocalNoLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortsLocalNoLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1450,52 +1450,52 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsets := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsets := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsWithLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsWithLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsMultiplePortsLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsMultiplePortsLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1503,24 +1503,24 @@ func Test_updateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }}, }} } - multipleSubsetsIPsPorts1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1528,13 +1528,13 @@ func Test_updateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }, { IP: "1.1.1.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }, { @@ -1543,15 +1543,15 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsetsIPsPorts2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.1", }, { IP: "2.2.2.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p21", Port: 21, }, { @@ -1560,81 +1560,81 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - complexBefore1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - complexBefore2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.2", NodeName: &nodeName, }, { IP: "2.2.2.22", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p22", Port: 22, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.3", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p23", Port: 23, }}, }} } - complexBefore4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }, { IP: "4.4.4.5", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.6", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p45", Port: 45, }}, }} } - complexAfter1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.11", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }, { @@ -1643,24 +1643,24 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - complexAfter3 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter3 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "3.3.3.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p33", Port: 33, }}, }} } - complexAfter4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, @@ -1671,8 +1671,8 @@ func Test_updateEndpointsMap(t *testing.T) { // previousEndpoints and currentEndpoints are used to call appropriate // handlers OnEndpoints* (based on whether corresponding values are nil // or non-nil) and must be of equal length. - previousEndpoints []*api.Endpoints - currentEndpoints []*api.Endpoints + previousEndpoints []*v1.Endpoints + currentEndpoints []*v1.Endpoints oldEndpoints map[proxy.ServicePortName][]*endpointsInfo expectedResult map[proxy.ServicePortName][]*endpointsInfo expectedStaleEndpoints []proxy.ServiceEndpoint @@ -1687,10 +1687,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[1]: no change, unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1708,10 +1708,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[2]: no change, named port, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1731,10 +1731,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[3]: no change, multiple subsets - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1758,10 +1758,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[4]: no change, multiple subsets, multiple ports, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1793,11 +1793,11 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[5]: no change, multiple endpoints, subsets, IPs, and ports - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, @@ -1861,10 +1861,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[6]: add an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ nil, }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{}, @@ -1882,10 +1882,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[7]: remove an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ nil, }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1902,10 +1902,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[8]: add an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1932,10 +1932,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[9]: remove an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1967,10 +1967,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[10]: add a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsWithLocal), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -1995,10 +1995,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[11]: remove a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -2022,10 +2022,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[12]: rename a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenamed), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -2048,10 +2048,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[13]: renumber a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenumbered), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{ @@ -2072,13 +2072,13 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[14]: complex add and remove - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexBefore1), makeTestEndpoints("ns2", "ep2", complexBefore2), nil, makeTestEndpoints("ns4", "ep4", complexBefore4), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexAfter1), nil, makeTestEndpoints("ns3", "ep3", complexAfter3), @@ -2147,10 +2147,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[15]: change from 0 endpoint address to 1 unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", emptyEndpoint), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[proxy.ServicePortName][]*endpointsInfo{}, diff --git a/pkg/proxy/ipvs/proxier.go b/pkg/proxy/ipvs/proxier.go index cd7431f5d8..35a6510181 100644 --- a/pkg/proxy/ipvs/proxier.go +++ b/pkg/proxy/ipvs/proxier.go @@ -30,12 +30,11 @@ import ( "github.com/golang/glog" - clientv1 "k8s.io/api/core/v1" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/tools/record" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/proxy/healthcheck" "k8s.io/kubernetes/pkg/proxy/metrics" @@ -397,7 +396,7 @@ type serviceInfo struct { } // returns a new proxy.ServicePort which abstracts a serviceInfo -func newServiceInfo(port *api.ServicePort, service *api.Service, baseInfo *proxy.BaseServiceInfo) proxy.ServicePort { +func newServiceInfo(port *v1.ServicePort, service *v1.Service, baseInfo *proxy.BaseServiceInfo) proxy.ServicePort { info := &serviceInfo{BaseServiceInfo: baseInfo} // Store the following for performance reasons. @@ -594,19 +593,19 @@ func (proxier *Proxier) isInitialized() bool { } // OnServiceAdd is called whenever creation of new service object is observed. -func (proxier *Proxier) OnServiceAdd(service *api.Service) { +func (proxier *Proxier) OnServiceAdd(service *v1.Service) { proxier.OnServiceUpdate(nil, service) } // OnServiceUpdate is called whenever modification of an existing service object is observed. -func (proxier *Proxier) OnServiceUpdate(oldService, service *api.Service) { +func (proxier *Proxier) OnServiceUpdate(oldService, service *v1.Service) { if proxier.serviceChanges.Update(oldService, service) && proxier.isInitialized() { proxier.syncRunner.Run() } } // OnServiceDelete is called whenever deletion of an existing service object is observed. -func (proxier *Proxier) OnServiceDelete(service *api.Service) { +func (proxier *Proxier) OnServiceDelete(service *v1.Service) { proxier.OnServiceUpdate(service, nil) } @@ -622,19 +621,19 @@ func (proxier *Proxier) OnServiceSynced() { } // OnEndpointsAdd is called whenever creation of new endpoints object is observed. -func (proxier *Proxier) OnEndpointsAdd(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsAdd(endpoints *v1.Endpoints) { proxier.OnEndpointsUpdate(nil, endpoints) } // OnEndpointsUpdate is called whenever modification of an existing endpoints object is observed. -func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { if proxier.endpointsChanges.Update(oldEndpoints, endpoints) && proxier.isInitialized() { proxier.syncRunner.Run() } } // OnEndpointsDelete is called whenever deletion of an existing endpoints object is observed. -func (proxier *Proxier) OnEndpointsDelete(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsDelete(endpoints *v1.Endpoints) { proxier.OnEndpointsUpdate(endpoints, nil) } @@ -678,7 +677,7 @@ func (proxier *Proxier) syncProxyRules() { staleServices := serviceUpdateResult.UDPStaleClusterIP // merge stale services gathered from updateEndpointsMap for _, svcPortName := range endpointUpdateResult.StaleServiceNames { - if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.GetProtocol() == api.ProtocolUDP { + if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.GetProtocol() == v1.ProtocolUDP { glog.V(2).Infof("Stale udp service %v -> %s", svcPortName, svcInfo.ClusterIPString()) staleServices.Insert(svcInfo.ClusterIPString()) } @@ -785,7 +784,7 @@ func (proxier *Proxier) syncProxyRules() { Scheduler: proxier.ipvsScheduler, } // Set session affinity flag and timeout for IPVS service - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { serv.Flags |= utilipvs.FlagPersistent serv.Timeout = uint32(svcInfo.StickyMaxAgeSeconds) } @@ -822,12 +821,12 @@ func (proxier *Proxier) syncProxyRules() { msg := fmt.Sprintf("can't open %s, skipping this externalIP: %v", lp.String(), err) proxier.recorder.Eventf( - &clientv1.ObjectReference{ + &v1.ObjectReference{ Kind: "Node", Name: proxier.hostname, UID: types.UID(proxier.hostname), Namespace: "", - }, api.EventTypeWarning, err.Error(), msg) + }, v1.EventTypeWarning, err.Error(), msg) glog.Error(msg) continue } @@ -856,7 +855,7 @@ func (proxier *Proxier) syncProxyRules() { Protocol: string(svcInfo.Protocol), Scheduler: proxier.ipvsScheduler, } - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { serv.Flags |= utilipvs.FlagPersistent serv.Timeout = uint32(svcInfo.StickyMaxAgeSeconds) } @@ -957,13 +956,13 @@ func (proxier *Proxier) syncProxyRules() { Protocol: string(svcInfo.Protocol), Scheduler: proxier.ipvsScheduler, } - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { serv.Flags |= utilipvs.FlagPersistent serv.Timeout = uint32(svcInfo.StickyMaxAgeSeconds) } if err := proxier.syncService(svcNameString, serv, true); err == nil { // check if service need skip endpoints that not in same host as kube-proxy - onlyLocal := svcInfo.SessionAffinityType == api.ServiceAffinityClientIP && svcInfo.OnlyNodeLocalEndpoints + onlyLocal := svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP && svcInfo.OnlyNodeLocalEndpoints activeIPVSServices[serv.String()] = true activeBindAddrs[serv.Address.String()] = true if err := proxier.syncEndpoint(svcName, onlyLocal, serv); err != nil { @@ -1013,7 +1012,7 @@ func (proxier *Proxier) syncProxyRules() { } if lp.Protocol == "udp" { isIPv6 := utilnet.IsIPv6(svcInfo.ClusterIP) - conntrack.ClearEntriesForPort(proxier.exec, lp.Port, isIPv6, clientv1.ProtocolUDP) + conntrack.ClearEntriesForPort(proxier.exec, lp.Port, isIPv6, v1.ProtocolUDP) } replacementPortsMap[lp] = socket } // We're holding the port, so it's OK to install ipvs rules. @@ -1087,7 +1086,7 @@ func (proxier *Proxier) syncProxyRules() { Protocol: string(svcInfo.Protocol), Scheduler: proxier.ipvsScheduler, } - if svcInfo.SessionAffinityType == api.ServiceAffinityClientIP { + if svcInfo.SessionAffinityType == v1.ServiceAffinityClientIP { serv.Flags |= utilipvs.FlagPersistent serv.Timeout = uint32(svcInfo.StickyMaxAgeSeconds) } @@ -1173,7 +1172,7 @@ func (proxier *Proxier) syncProxyRules() { // Finish housekeeping. // TODO: these could be made more consistent. for _, svcIP := range staleServices.UnsortedList() { - if err := conntrack.ClearEntriesForIP(proxier.exec, svcIP, clientv1.ProtocolUDP); err != nil { + if err := conntrack.ClearEntriesForIP(proxier.exec, svcIP, v1.ProtocolUDP); err != nil { glog.Errorf("Failed to delete stale service IP %s connections, error: %v", svcIP, err) } } @@ -1418,9 +1417,9 @@ func (proxier *Proxier) getExistingChains(buffer *bytes.Buffer, table utiliptabl // This assumes the proxier mutex is held func (proxier *Proxier) deleteEndpointConnections(connectionMap []proxy.ServiceEndpoint) { for _, epSvcPair := range connectionMap { - if svcInfo, ok := proxier.serviceMap[epSvcPair.ServicePortName]; ok && svcInfo.GetProtocol() == api.ProtocolUDP { + if svcInfo, ok := proxier.serviceMap[epSvcPair.ServicePortName]; ok && svcInfo.GetProtocol() == v1.ProtocolUDP { endpointIP := utilproxy.IPPart(epSvcPair.Endpoint) - err := conntrack.ClearEntriesForNAT(proxier.exec, svcInfo.ClusterIPString(), endpointIP, clientv1.ProtocolUDP) + err := conntrack.ClearEntriesForNAT(proxier.exec, svcInfo.ClusterIPString(), endpointIP, v1.ProtocolUDP) if err != nil { glog.Errorf("Failed to delete %s endpoint connections, error: %v", epSvcPair.ServicePortName.String(), err) } diff --git a/pkg/proxy/ipvs/proxier_test.go b/pkg/proxy/ipvs/proxier_test.go index 4a54ca51d2..4f2ea198b7 100644 --- a/pkg/proxy/ipvs/proxier_test.go +++ b/pkg/proxy/ipvs/proxier_test.go @@ -25,10 +25,10 @@ import ( "testing" "time" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/intstr" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/utils/exec" fakeexec "k8s.io/utils/exec/testing" @@ -178,7 +178,7 @@ func makeNSN(namespace, name string) types.NamespacedName { return types.NamespacedName{Namespace: namespace, Name: name} } -func makeServiceMap(proxier *Proxier, allServices ...*api.Service) { +func makeServiceMap(proxier *Proxier, allServices ...*v1.Service) { for i := range allServices { proxier.OnServiceAdd(allServices[i]) } @@ -188,21 +188,21 @@ func makeServiceMap(proxier *Proxier, allServices ...*api.Service) { proxier.servicesSynced = true } -func makeTestService(namespace, name string, svcFunc func(*api.Service)) *api.Service { - svc := &api.Service{ +func makeTestService(namespace, name string, svcFunc func(*v1.Service)) *v1.Service { + svc := &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, Annotations: map[string]string{}, }, - Spec: api.ServiceSpec{}, - Status: api.ServiceStatus{}, + Spec: v1.ServiceSpec{}, + Status: v1.ServiceStatus{}, } svcFunc(svc) return svc } -func makeEndpointsMap(proxier *Proxier, allEndpoints ...*api.Endpoints) { +func makeEndpointsMap(proxier *Proxier, allEndpoints ...*v1.Endpoints) { for i := range allEndpoints { proxier.OnEndpointsAdd(allEndpoints[i]) } @@ -212,8 +212,8 @@ func makeEndpointsMap(proxier *Proxier, allEndpoints ...*api.Endpoints) { proxier.endpointsSynced = true } -func makeTestEndpoints(namespace, name string, eptFunc func(*api.Endpoints)) *api.Endpoints { - ept := &api.Endpoints{ +func makeTestEndpoints(namespace, name string, eptFunc func(*v1.Endpoints)) *v1.Endpoints { + ept := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, @@ -237,25 +237,25 @@ func TestCleanupLeftovers(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), ) epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -428,25 +428,25 @@ func TestNodePortUDP(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolUDP, + Protocol: v1.ProtocolUDP, NodePort: int32(svcNodePort), }} }), ) epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -459,7 +459,7 @@ func TestNodePortUDP(t *testing.T) { // Check ipvs service and destinations epVS := &netlinktest.ExpectedVirtualServer{ - VSNum: 2, IP: nodeIP.String(), Port: uint16(svcNodePort), Protocol: string(api.ProtocolTCP), + VSNum: 2, IP: nodeIP.String(), Port: uint16(svcNodePort), Protocol: string(v1.ProtocolTCP), RS: []netlinktest.ExpectedRealServer{{ IP: epIP, Port: uint16(svcPort), }}} @@ -469,7 +469,7 @@ func TestNodePortUDP(t *testing.T) { epIPSet := netlinktest.ExpectedIPSet{ kubeNodePortSetUDP: {{ Port: svcNodePort, - Protocol: strings.ToLower(string(api.ProtocolUDP)), + Protocol: strings.ToLower(string(v1.ProtocolUDP)), SetType: utilipset.BitmapPort, }}, } @@ -504,13 +504,13 @@ func TestNodePort(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), @@ -519,14 +519,14 @@ func TestNodePort(t *testing.T) { epIPv6 := "1002:ab8::2:10" epIPs := sets.NewString(epIPv4, epIPv6) makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIPv4, }, { IP: epIPv6, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -548,7 +548,7 @@ func TestNodePort(t *testing.T) { } found := false for _, svc := range services { - if nodeIPs.Has(svc.Address.String()) && svc.Port == uint16(svcNodePort) && svc.Protocol == string(api.ProtocolTCP) { + if nodeIPs.Has(svc.Address.String()) && svc.Port == uint16(svcNodePort) && svc.Protocol == string(v1.ProtocolTCP) { found = true destinations, err := ipvs.GetRealServers(svc) if err != nil { @@ -582,13 +582,13 @@ func TestNodePortNoEndpoint(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), @@ -609,7 +609,7 @@ func TestNodePortNoEndpoint(t *testing.T) { } found := false for _, svc := range services { - if svc.Address.Equal(nodeIP) && svc.Port == uint16(svcNodePort) && svc.Protocol == string(api.ProtocolTCP) { + if svc.Address.Equal(nodeIP) && svc.Port == uint16(svcNodePort) && svc.Protocol == string(v1.ProtocolTCP) { found = true destinations, _ := ipvs.GetRealServers(svc) if len(destinations) != 0 { @@ -636,12 +636,12 @@ func TestClusterIPNoEndpoint(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Namespace, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Namespace, func(svc *v1.Service) { svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} }), ) @@ -656,7 +656,7 @@ func TestClusterIPNoEndpoint(t *testing.T) { if len(services) != 1 { t.Errorf("Expect 1 ipvs services, got %d", len(services)) } else { - if services[0].Address.String() != svcIP || services[0].Port != uint16(svcPort) || services[0].Protocol != string(api.ProtocolTCP) { + if services[0].Address.String() != svcIP || services[0].Port != uint16(svcPort) || services[0].Protocol != string(v1.ProtocolTCP) { t.Errorf("Unexpected mismatch service") } else { destinations, _ := ipvs.GetRealServers(services[0]) @@ -686,20 +686,20 @@ func TestClusterIP(t *testing.T) { Port: "p8080", } makeServiceMap(fp, - makeTestService(svcPortNameV4.Namespace, svcPortNameV4.Name, func(svc *api.Service) { + makeTestService(svcPortNameV4.Namespace, svcPortNameV4.Name, func(svc *v1.Service) { svc.Spec.ClusterIP = svcIPv4 - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortNameV4.Port, Port: int32(svcPortV4), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} }), - makeTestService(svcPortNameV6.Namespace, svcPortNameV6.Name, func(svc *api.Service) { + makeTestService(svcPortNameV6.Namespace, svcPortNameV6.Name, func(svc *v1.Service) { svc.Spec.ClusterIP = svcIPv6 - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortNameV6.Port, Port: int32(svcPortV6), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} }), ) @@ -707,23 +707,23 @@ func TestClusterIP(t *testing.T) { epIPv4 := "10.180.0.1" epIPv6 := "1009:ab8::5:6" makeEndpointsMap(fp, - makeTestEndpoints(svcPortNameV4.Namespace, svcPortNameV4.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortNameV4.Namespace, svcPortNameV4.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIPv4, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortNameV4.Port, Port: int32(svcPortV4), }}, }} }), - makeTestEndpoints(svcPortNameV6.Namespace, svcPortNameV6.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortNameV6.Namespace, svcPortNameV6.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIPv6, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortNameV6.Port, Port: int32(svcPortV6), }}, @@ -744,7 +744,7 @@ func TestClusterIP(t *testing.T) { for i := range services { // Check services if services[i].Address.String() == svcIPv4 { - if services[i].Port != uint16(svcPortV4) || services[i].Protocol != string(api.ProtocolTCP) { + if services[i].Port != uint16(svcPortV4) || services[i].Protocol != string(v1.ProtocolTCP) { t.Errorf("Unexpected mismatch service") } // Check destinations @@ -758,7 +758,7 @@ func TestClusterIP(t *testing.T) { } } if services[i].Address.String() == svcIPv6 { - if services[i].Port != uint16(svcPortV6) || services[i].Protocol != string(api.ProtocolTCP) { + if services[i].Port != uint16(svcPortV6) || services[i].Protocol != string(v1.ProtocolTCP) { t.Errorf("Unexpected mismatch service") } // Check destinations @@ -788,14 +788,14 @@ func TestExternalIPsNoEndpoint(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "ClusterIP" svc.Spec.ClusterIP = svcIP svc.Spec.ExternalIPs = []string{svcExternalIPs} - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, TargetPort: intstr.FromInt(svcPort), }} }), @@ -815,7 +815,7 @@ func TestExternalIPsNoEndpoint(t *testing.T) { } found := false for _, svc := range services { - if svc.Address.String() == svcExternalIPs && svc.Port == uint16(svcPort) && svc.Protocol == string(api.ProtocolTCP) { + if svc.Address.String() == svcExternalIPs && svc.Port == uint16(svcPort) && svc.Protocol == string(v1.ProtocolTCP) { found = true destinations, _ := ipvs.GetRealServers(svc) if len(destinations) != 0 { @@ -843,14 +843,14 @@ func TestExternalIPs(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "ClusterIP" svc.Spec.ClusterIP = svcIP svc.Spec.ExternalIPs = svcExternalIPs.UnsortedList() - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, TargetPort: intstr.FromInt(svcPort), }} }), @@ -858,12 +858,12 @@ func TestExternalIPs(t *testing.T) { epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -883,7 +883,7 @@ func TestExternalIPs(t *testing.T) { } found := false for _, svc := range services { - if svcExternalIPs.Has(svc.Address.String()) && svc.Port == uint16(svcPort) && svc.Protocol == string(api.ProtocolTCP) { + if svcExternalIPs.Has(svc.Address.String()) && svc.Port == uint16(svcPort) && svc.Protocol == string(v1.ProtocolTCP) { found = true destinations, _ := ipvs.GetRealServers(svc) for _, dest := range destinations { @@ -911,16 +911,16 @@ func TestLoadBalancer(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "LoadBalancer" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: svcLBIP, }} }), @@ -928,12 +928,12 @@ func TestLoadBalancer(t *testing.T) { epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -945,7 +945,7 @@ func TestLoadBalancer(t *testing.T) { // Expect 2 services and 1 destination epVS := &netlinktest.ExpectedVirtualServer{ - VSNum: 2, IP: svcLBIP, Port: uint16(svcNodePort), Protocol: string(api.ProtocolTCP), + VSNum: 2, IP: svcLBIP, Port: uint16(svcNodePort), Protocol: string(v1.ProtocolTCP), RS: []netlinktest.ExpectedRealServer{{ IP: epIP, Port: uint16(svcPort), }}} @@ -956,7 +956,7 @@ func TestLoadBalancer(t *testing.T) { kubeLoadBalancerSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.HashIPPort, }}, } @@ -987,16 +987,16 @@ func TestOnlyLocalNodePorts(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal }), ) @@ -1006,23 +1006,23 @@ func TestOnlyLocalNodePorts(t *testing.T) { otherHostname := "other-hostname" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{ { // **local** endpoint address, should be added as RS - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, NodeName: &thisHostname, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}}, { // **remote** endpoint address, should not be added as RS - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: epIP1, NodeName: &otherHostname, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -1042,7 +1042,7 @@ func TestOnlyLocalNodePorts(t *testing.T) { // Expect 3 services and 1 destination epVS := &netlinktest.ExpectedVirtualServer{ - VSNum: 3, IP: nodeIP.String(), Port: uint16(svcNodePort), Protocol: string(api.ProtocolTCP), + VSNum: 3, IP: nodeIP.String(), Port: uint16(svcNodePort), Protocol: string(v1.ProtocolTCP), RS: []netlinktest.ExpectedRealServer{{ IP: epIP, Port: uint16(svcPort), }}} @@ -1051,7 +1051,7 @@ func TestOnlyLocalNodePorts(t *testing.T) { // check ipSet rules epEntry := &utilipset.Entry{ Port: svcNodePort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.BitmapPort, } epIPSet := netlinktest.ExpectedIPSet{ @@ -1087,15 +1087,15 @@ func TestLoadBalanceSourceRanges(t *testing.T) { epIP := "10.180.0.1" makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "LoadBalancer" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }} - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: svcLBIP, }} svc.Spec.LoadBalancerSourceRanges = []string{ @@ -1104,13 +1104,13 @@ func TestLoadBalanceSourceRanges(t *testing.T) { }), ) makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, NodeName: nil, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -1122,7 +1122,7 @@ func TestLoadBalanceSourceRanges(t *testing.T) { // Check ipvs service and destinations epVS := &netlinktest.ExpectedVirtualServer{ - VSNum: 2, IP: svcLBIP, Port: uint16(svcPort), Protocol: string(api.ProtocolTCP), + VSNum: 2, IP: svcLBIP, Port: uint16(svcPort), Protocol: string(v1.ProtocolTCP), RS: []netlinktest.ExpectedRealServer{{ IP: epIP, Port: uint16(svcPort), }}} @@ -1133,19 +1133,19 @@ func TestLoadBalanceSourceRanges(t *testing.T) { kubeLoadBalancerSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.HashIPPort, }}, kubeLoadbalancerFWSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.HashIPPort, }}, kubeLoadBalancerSourceCIDRSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), Net: svcLBSource, SetType: utilipset.HashIPPortNet, }}, @@ -1177,45 +1177,45 @@ func TestAcceptIPVSTraffic(t *testing.T) { ingressIP := "1.2.3.4" externalIP := []string{"5.6.7.8"} svcInfos := []struct { - svcType api.ServiceType + svcType v1.ServiceType svcIP string svcName string epIP string }{ - {api.ServiceTypeClusterIP, "10.20.30.40", "svc1", "10.180.0.1"}, - {api.ServiceTypeLoadBalancer, "10.20.30.41", "svc2", "10.180.0.2"}, - {api.ServiceTypeNodePort, "10.20.30.42", "svc3", "10.180.0.3"}, + {v1.ServiceTypeClusterIP, "10.20.30.40", "svc1", "10.180.0.1"}, + {v1.ServiceTypeLoadBalancer, "10.20.30.41", "svc2", "10.180.0.2"}, + {v1.ServiceTypeNodePort, "10.20.30.42", "svc3", "10.180.0.3"}, } for _, svcInfo := range svcInfos { makeServiceMap(fp, - makeTestService("ns1", svcInfo.svcName, func(svc *api.Service) { + makeTestService("ns1", svcInfo.svcName, func(svc *v1.Service) { svc.Spec.Type = svcInfo.svcType svc.Spec.ClusterIP = svcInfo.svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: "p80", Port: 80, - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: 80, }} - if svcInfo.svcType == api.ServiceTypeLoadBalancer { - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + if svcInfo.svcType == v1.ServiceTypeLoadBalancer { + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: ingressIP, }} } - if svcInfo.svcType == api.ServiceTypeClusterIP { + if svcInfo.svcType == v1.ServiceTypeClusterIP { svc.Spec.ExternalIPs = externalIP } }), ) makeEndpointsMap(fp, - makeTestEndpoints("ns1", "p80", func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints("ns1", "p80", func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: svcInfo.epIP, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p80", Port: 80, }}, @@ -1249,31 +1249,31 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { } makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "LoadBalancer" svc.Spec.ClusterIP = svcIP - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} - svc.Status.LoadBalancer.Ingress = []api.LoadBalancerIngress{{ + svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{ IP: svcLBIP, }} - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal }), ) epIP := "10.180.0.1" makeEndpointsMap(fp, - makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + makeTestEndpoints(svcPortName.Namespace, svcPortName.Name, func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: epIP, NodeName: nil, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: svcPortName.Port, Port: int32(svcPort), }}, @@ -1285,7 +1285,7 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { // Expect 2 services and 1 destination epVS := &netlinktest.ExpectedVirtualServer{ - VSNum: 2, IP: svcLBIP, Port: uint16(svcPort), Protocol: string(api.ProtocolTCP), + VSNum: 2, IP: svcLBIP, Port: uint16(svcPort), Protocol: string(v1.ProtocolTCP), RS: []netlinktest.ExpectedRealServer{{ IP: epIP, Port: uint16(svcPort), }}} @@ -1296,13 +1296,13 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { kubeLoadBalancerSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.HashIPPort, }}, kubeLoadBalancerLocalSet: {{ IP: svcLBIP, Port: svcPort, - Protocol: strings.ToLower(string(api.ProtocolTCP)), + Protocol: strings.ToLower(string(v1.ProtocolTCP)), SetType: utilipset.HashIPPort, }}, } @@ -1322,8 +1322,8 @@ func TestOnlyLocalLoadBalancing(t *testing.T) { checkIptables(t, ipt, epIpt) } -func addTestPort(array []api.ServicePort, name string, protocol api.Protocol, port, nodeport int32, targetPort int) []api.ServicePort { - svcPort := api.ServicePort{ +func addTestPort(array []v1.ServicePort, name string, protocol v1.Protocol, port, nodeport int32, targetPort int) []v1.ServicePort { + svcPort := v1.ServicePort{ Name: name, Protocol: protocol, Port: port, @@ -1339,43 +1339,43 @@ func TestBuildServiceMapAddRemove(t *testing.T) { ipset := ipsettest.NewFake(testIPSetVersion) fp := NewFakeProxier(ipt, ipvs, ipset, nil) - services := []*api.Service{ - makeTestService("somewhere-else", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + services := []*v1.Service{ + makeTestService("somewhere-else", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "UDP", 1235, 5321, 0) }), - makeTestService("somewhere-else", "node-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeNodePort + makeTestService("somewhere-else", "node-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.ClusterIP = "172.16.55.10" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "blahblah", "UDP", 345, 678, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "moreblahblah", "TCP", 344, 677, 0) }), - makeTestService("somewhere", "load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("somewhere", "load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.11" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar", "UDP", 8675, 30061, 7000) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8676, 30062, 7001) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.4"}, }, } }), - makeTestService("somewhere", "only-local-load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("somewhere", "only-local-load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.12" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar2", "UDP", 8677, 30063, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8678, 30064, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }), } @@ -1405,8 +1405,8 @@ func TestBuildServiceMapAddRemove(t *testing.T) { // Remove some stuff // oneService is a modification of services[0] with removed first port. - oneService := makeTestService("somewhere-else", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + oneService := makeTestService("somewhere-else", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "UDP", 1235, 5321, 0) }) @@ -1446,14 +1446,14 @@ func TestBuildServiceMapServiceHeadless(t *testing.T) { fp := NewFakeProxier(ipt, ipvs, ipset, nil) makeServiceMap(fp, - makeTestService("somewhere-else", "headless", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("somewhere-else", "headless", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone svc.Spec.Ports = addTestPort(svc.Spec.Ports, "rpc", "UDP", 1234, 0, 0) }), - makeTestService("somewhere-else", "headless-without-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("somewhere-else", "headless-without-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone }), ) @@ -1480,8 +1480,8 @@ func TestBuildServiceMapServiceTypeExternalName(t *testing.T) { fp := NewFakeProxier(ipt, ipvs, ipset, nil) makeServiceMap(fp, - makeTestService("somewhere-else", "external-name", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeExternalName + makeTestService("somewhere-else", "external-name", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeExternalName svc.Spec.ClusterIP = "172.16.55.4" // Should be ignored svc.Spec.ExternalName = "foo2.bar.com" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "blah", "UDP", 1235, 5321, 0) @@ -1507,24 +1507,24 @@ func TestBuildServiceMapServiceUpdate(t *testing.T) { ipset := ipsettest.NewFake(testIPSetVersion) fp := NewFakeProxier(ipt, ipvs, ipset, nil) - servicev1 := makeTestService("somewhere", "some-service", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + servicev1 := makeTestService("somewhere", "some-service", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "TCP", 1235, 5321, 0) }) - servicev2 := makeTestService("somewhere", "some-service", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + servicev2 := makeTestService("somewhere", "some-service", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "something", "UDP", 1234, 4321, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "somethingelse", "TCP", 1235, 5321, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }) @@ -1598,23 +1598,23 @@ func TestSessionAffinity(t *testing.T) { NamespacedName: makeNSN("ns1", "svc1"), Port: "p80", } - timeoutSeconds := api.DefaultClientIPServiceAffinitySeconds + timeoutSeconds := v1.DefaultClientIPServiceAffinitySeconds makeServiceMap(fp, - makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *api.Service) { + makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) { svc.Spec.Type = "NodePort" svc.Spec.ClusterIP = svcIP svc.Spec.ExternalIPs = []string{svcExternalIPs} - svc.Spec.SessionAffinity = api.ServiceAffinityClientIP - svc.Spec.SessionAffinityConfig = &api.SessionAffinityConfig{ - ClientIP: &api.ClientIPConfig{ + svc.Spec.SessionAffinity = v1.ServiceAffinityClientIP + svc.Spec.SessionAffinityConfig = &v1.SessionAffinityConfig{ + ClientIP: &v1.ClientIPConfig{ TimeoutSeconds: &timeoutSeconds, }, } - svc.Spec.Ports = []api.ServicePort{{ + svc.Spec.Ports = []v1.ServicePort{{ Name: svcPortName.Port, Port: int32(svcPort), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, NodePort: int32(svcNodePort), }} }), @@ -1629,8 +1629,8 @@ func TestSessionAffinity(t *testing.T) { t.Errorf("Failed to get ipvs services, err: %v", err) } for _, svc := range services { - if svc.Timeout != uint32(api.DefaultClientIPServiceAffinitySeconds) { - t.Errorf("Unexpected mismatch ipvs service session affinity timeout: %d, expected: %d", svc.Timeout, api.DefaultClientIPServiceAffinitySeconds) + if svc.Timeout != uint32(v1.DefaultClientIPServiceAffinitySeconds) { + t.Errorf("Unexpected mismatch ipvs service session affinity timeout: %d, expected: %d", svc.Timeout, v1.DefaultClientIPServiceAffinitySeconds) } } } @@ -1645,84 +1645,84 @@ func makeServicePortName(ns, name, port string) proxy.ServicePortName { func Test_updateEndpointsMap(t *testing.T) { var nodeName = testHostname - emptyEndpoint := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{} + emptyEndpoint := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{} } - unnamedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - unnamedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + unnamedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Port: 11, }}, }} } - namedPortLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPort := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPort := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - namedPortRenamed := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenamed := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11-2", Port: 11, }}, }} } - namedPortRenumbered := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortRenumbered := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 22, }}, }} } - namedPortsLocalNoLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + namedPortsLocalNoLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1731,52 +1731,52 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsets := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsets := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsWithLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsWithLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }}, }} } - multipleSubsetsMultiplePortsLocal := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsMultiplePortsLocal := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1784,24 +1784,24 @@ func Test_updateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }}, }} } - multipleSubsetsIPsPorts1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }, { @@ -1809,13 +1809,13 @@ func Test_updateEndpointsMap(t *testing.T) { Port: 12, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.3", }, { IP: "1.1.1.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p13", Port: 13, }, { @@ -1824,15 +1824,15 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - multipleSubsetsIPsPorts2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + multipleSubsetsIPsPorts2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.1", }, { IP: "2.2.2.2", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p21", Port: 21, }, { @@ -1841,81 +1841,81 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - complexBefore1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }} } - complexBefore2 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore2 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.2", NodeName: &nodeName, }, { IP: "2.2.2.22", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p22", Port: 22, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "2.2.2.3", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p23", Port: 23, }}, }} } - complexBefore4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexBefore4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }, { IP: "4.4.4.5", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.6", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p45", Port: 45, }}, }} } - complexAfter1 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter1 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.1", }, { IP: "1.1.1.11", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p11", Port: 11, }}, }, { - Addresses: []api.EndpointAddress{{ + Addresses: []v1.EndpointAddress{{ IP: "1.1.1.2", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p12", Port: 12, }, { @@ -1924,24 +1924,24 @@ func Test_updateEndpointsMap(t *testing.T) { }}, }} } - complexAfter3 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter3 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "3.3.3.3", }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p33", Port: 33, }}, }} } - complexAfter4 := func(ept *api.Endpoints) { - ept.Subsets = []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{ + complexAfter4 := func(ept *v1.Endpoints) { + ept.Subsets = []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{ IP: "4.4.4.4", NodeName: &nodeName, }}, - Ports: []api.EndpointPort{{ + Ports: []v1.EndpointPort{{ Name: "p44", Port: 44, }}, @@ -1952,8 +1952,8 @@ func Test_updateEndpointsMap(t *testing.T) { // previousEndpoints and currentEndpoints are used to call appropriate // handlers OnEndpoints* (based on whether corresponding values are nil // or non-nil) and must be of equal length. - previousEndpoints []*api.Endpoints - currentEndpoints []*api.Endpoints + previousEndpoints []*v1.Endpoints + currentEndpoints []*v1.Endpoints oldEndpoints map[proxy.ServicePortName][]*proxy.BaseEndpointInfo expectedResult map[proxy.ServicePortName][]*proxy.BaseEndpointInfo expectedStaleEndpoints []proxy.ServiceEndpoint @@ -1968,10 +1968,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[1]: no change, unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -1989,10 +1989,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[2]: no change, named port, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortLocal), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2012,10 +2012,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[3]: no change, multiple subsets - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2039,10 +2039,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[4]: no change, multiple subsets, multiple ports, local - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsMultiplePortsLocal), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2074,11 +2074,11 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[5]: no change, multiple endpoints, subsets, IPs, and ports - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsIPsPorts1), makeTestEndpoints("ns2", "ep2", multipleSubsetsIPsPorts2), }, @@ -2142,10 +2142,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[6]: add an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ nil, }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{}, @@ -2163,10 +2163,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[7]: remove an Endpoints - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPortLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ nil, }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2183,10 +2183,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[8]: add an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2213,10 +2213,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[9]: remove an IP and port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortsLocalNoLocal), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2248,10 +2248,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[10]: add a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsetsWithLocal), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2276,10 +2276,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[11]: remove a subset - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", multipleSubsets), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2303,10 +2303,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[12]: rename a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenamed), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2329,10 +2329,10 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[13]: renumber a port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPort), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", namedPortRenumbered), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{ @@ -2353,13 +2353,13 @@ func Test_updateEndpointsMap(t *testing.T) { expectedHealthchecks: map[types.NamespacedName]int{}, }, { // Case[14]: complex add and remove - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexBefore1), makeTestEndpoints("ns2", "ep2", complexBefore2), nil, makeTestEndpoints("ns4", "ep4", complexBefore4), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", complexAfter1), nil, makeTestEndpoints("ns3", "ep3", complexAfter3), @@ -2428,10 +2428,10 @@ func Test_updateEndpointsMap(t *testing.T) { }, }, { // Case[15]: change from 0 endpoint address to 1 unnamed port - previousEndpoints: []*api.Endpoints{ + previousEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", emptyEndpoint), }, - currentEndpoints: []*api.Endpoints{ + currentEndpoints: []*v1.Endpoints{ makeTestEndpoints("ns1", "ep1", unnamedPort), }, oldEndpoints: map[proxy.ServicePortName][]*proxy.BaseEndpointInfo{}, @@ -2554,7 +2554,7 @@ func Test_syncService(t *testing.T) { // case 0, old virtual server is same as new virtual server oldVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 80, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2562,7 +2562,7 @@ func Test_syncService(t *testing.T) { svcName: "foo", newVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 80, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2573,7 +2573,7 @@ func Test_syncService(t *testing.T) { // case 1, old virtual server is different from new virtual server oldVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 8080, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2581,7 +2581,7 @@ func Test_syncService(t *testing.T) { svcName: "bar", newVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 8080, Scheduler: "rr", Flags: utilipvs.FlagPersistent, @@ -2592,7 +2592,7 @@ func Test_syncService(t *testing.T) { // case 2, old virtual server is different from new virtual server oldVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 8080, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2600,7 +2600,7 @@ func Test_syncService(t *testing.T) { svcName: "bar", newVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolTCP), + Protocol: string(v1.ProtocolTCP), Port: 8080, Scheduler: "wlc", Flags: utilipvs.FlagHashed, @@ -2613,7 +2613,7 @@ func Test_syncService(t *testing.T) { svcName: "baz", newVirtualServer: &utilipvs.VirtualServer{ Address: net.ParseIP("1.2.3.4"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 53, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2760,7 +2760,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by kube-proxy. "ipvs0": { Address: net.ParseIP("1.1.1.1"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 53, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2768,7 +2768,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by kube-proxy. "ipvs1": { Address: net.ParseIP("2.2.2.2"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 54, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2776,7 +2776,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by an external party. "ipvs2": { Address: net.ParseIP("3.3.3.3"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 55, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2784,7 +2784,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by an external party. "ipvs3": { Address: net.ParseIP("4.4.4.4"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 56, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2792,7 +2792,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by an external party. "ipvs4": { Address: net.ParseIP("5.5.5.5"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 57, Scheduler: "rr", Flags: utilipvs.FlagHashed, @@ -2800,7 +2800,7 @@ func TestCleanLegacyService(t *testing.T) { // Created by kube-proxy, but now stale. "ipvs5": { Address: net.ParseIP("6.6.6.6"), - Protocol: string(api.ProtocolUDP), + Protocol: string(v1.ProtocolUDP), Port: 58, Scheduler: "rr", Flags: utilipvs.FlagHashed, diff --git a/pkg/proxy/service.go b/pkg/proxy/service.go index 88e804517b..5853ef9ca0 100644 --- a/pkg/proxy/service.go +++ b/pkg/proxy/service.go @@ -25,11 +25,11 @@ import ( "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/tools/record" - apiservice "k8s.io/kubernetes/pkg/api/service" - api "k8s.io/kubernetes/pkg/apis/core" + apiservice "k8s.io/kubernetes/pkg/api/v1/service" utilproxy "k8s.io/kubernetes/pkg/proxy/util" utilnet "k8s.io/kubernetes/pkg/util/net" ) @@ -41,10 +41,10 @@ import ( type BaseServiceInfo struct { ClusterIP net.IP Port int - Protocol api.Protocol + Protocol v1.Protocol NodePort int - LoadBalancerStatus api.LoadBalancerStatus - SessionAffinityType api.ServiceAffinity + LoadBalancerStatus v1.LoadBalancerStatus + SessionAffinityType v1.ServiceAffinity StickyMaxAgeSeconds int ExternalIPs []string LoadBalancerSourceRanges []string @@ -65,7 +65,7 @@ func (info *BaseServiceInfo) ClusterIPString() string { } // GetProtocol is part of ServicePort interface. -func (info *BaseServiceInfo) GetProtocol() api.Protocol { +func (info *BaseServiceInfo) GetProtocol() v1.Protocol { return info.Protocol } @@ -74,13 +74,13 @@ func (info *BaseServiceInfo) GetHealthCheckNodePort() int { return info.HealthCheckNodePort } -func (sct *ServiceChangeTracker) newBaseServiceInfo(port *api.ServicePort, service *api.Service) *BaseServiceInfo { +func (sct *ServiceChangeTracker) newBaseServiceInfo(port *v1.ServicePort, service *v1.Service) *BaseServiceInfo { onlyNodeLocalEndpoints := false if apiservice.RequestsOnlyLocalTraffic(service) { onlyNodeLocalEndpoints = true } var stickyMaxAgeSeconds int - if service.Spec.SessionAffinity == api.ServiceAffinityClientIP { + if service.Spec.SessionAffinity == v1.ServiceAffinityClientIP { // Kube-apiserver side guarantees SessionAffinityConfig won't be nil when session affinity type is ClientIP stickyMaxAgeSeconds = int(*service.Spec.SessionAffinityConfig.ClientIP.TimeoutSeconds) } @@ -128,7 +128,7 @@ func (sct *ServiceChangeTracker) newBaseServiceInfo(port *api.ServicePort, servi return info } -type makeServicePortFunc func(*api.ServicePort, *api.Service, *BaseServiceInfo) ServicePort +type makeServicePortFunc func(*v1.ServicePort, *v1.Service, *BaseServiceInfo) ServicePort // serviceChange contains all changes to services that happened since proxy rules were synced. For a single object, // changes are accumulated, i.e. previous is state from before applying the changes, @@ -170,7 +170,7 @@ func NewServiceChangeTracker(makeServiceInfo makeServicePortFunc, isIPv6Mode *bo // - pass as the pair. // Delete item // - pass as the pair. -func (sct *ServiceChangeTracker) Update(previous, current *api.Service) bool { +func (sct *ServiceChangeTracker) Update(previous, current *v1.Service) bool { svc := current if svc == nil { svc = previous @@ -231,7 +231,7 @@ type ServiceMap map[ServicePortName]ServicePort // serviceToServiceMap translates a single Service object to a ServiceMap. // // NOTE: service object should NOT be modified. -func (sct *ServiceChangeTracker) serviceToServiceMap(service *api.Service) ServiceMap { +func (sct *ServiceChangeTracker) serviceToServiceMap(service *v1.Service) ServiceMap { if service == nil { return nil } @@ -332,7 +332,7 @@ func (sm *ServiceMap) unmerge(other ServiceMap, UDPStaleClusterIP sets.String) { info, exists := (*sm)[svcPortName] if exists { glog.V(1).Infof("Removing service port %q", svcPortName) - if info.GetProtocol() == api.ProtocolUDP { + if info.GetProtocol() == v1.ProtocolUDP { UDPStaleClusterIP.Insert(info.ClusterIPString()) } delete(*sm, svcPortName) diff --git a/pkg/proxy/service_test.go b/pkg/proxy/service_test.go index 22508971f8..61bfa1ee42 100644 --- a/pkg/proxy/service_test.go +++ b/pkg/proxy/service_test.go @@ -22,11 +22,11 @@ import ( "github.com/davecgh/go-spew/spew" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/sets" - api "k8s.io/kubernetes/pkg/apis/core" ) const testHostname = "test-hostname" @@ -35,7 +35,7 @@ func makeTestServiceInfo(clusterIP string, port int, protocol string, healthchec info := &BaseServiceInfo{ ClusterIP: net.ParseIP(clusterIP), Port: port, - Protocol: api.Protocol(protocol), + Protocol: v1.Protocol(protocol), } if healthcheckNodePort != 0 { info.HealthCheckNodePort = healthcheckNodePort @@ -46,22 +46,22 @@ func makeTestServiceInfo(clusterIP string, port int, protocol string, healthchec return info } -func makeTestService(namespace, name string, svcFunc func(*api.Service)) *api.Service { - svc := &api.Service{ +func makeTestService(namespace, name string, svcFunc func(*v1.Service)) *v1.Service { + svc := &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, Annotations: map[string]string{}, }, - Spec: api.ServiceSpec{}, - Status: api.ServiceStatus{}, + Spec: v1.ServiceSpec{}, + Status: v1.ServiceStatus{}, } svcFunc(svc) return svc } -func addTestPort(array []api.ServicePort, name string, protocol api.Protocol, port, nodeport int32, targetPort int) []api.ServicePort { - svcPort := api.ServicePort{ +func addTestPort(array []v1.ServicePort, name string, protocol v1.Protocol, port, nodeport int32, targetPort int) []v1.ServicePort { + svcPort := v1.ServicePort{ Name: name, Protocol: protocol, Port: port, @@ -96,7 +96,7 @@ func TestServiceToServiceMap(t *testing.T) { testCases := []struct { desc string - service *api.Service + service *v1.Service expected map[ServicePortName]*BaseServiceInfo isIPv6Mode *bool }{ @@ -107,25 +107,25 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "headless service", - service: makeTestService("ns2", "headless", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + service: makeTestService("ns2", "headless", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone svc.Spec.Ports = addTestPort(svc.Spec.Ports, "rpc", "UDP", 1234, 0, 0) }), expected: map[ServicePortName]*BaseServiceInfo{}, }, { desc: "headless service without port", - service: makeTestService("ns2", "headless-without-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + service: makeTestService("ns2", "headless-without-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone }), expected: map[ServicePortName]*BaseServiceInfo{}, }, { desc: "cluster ip service", - service: makeTestService("ns2", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + service: makeTestService("ns2", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p1", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p2", "UDP", 1235, 5321, 0) @@ -137,8 +137,8 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "nodeport service", - service: makeTestService("ns2", "node-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeNodePort + service: makeTestService("ns2", "node-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.ClusterIP = "172.16.55.10" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port1", "UDP", 345, 678, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port2", "TCP", 344, 677, 0) @@ -150,14 +150,14 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "load balancer service", - service: makeTestService("ns1", "load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + service: makeTestService("ns1", "load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.11" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port3", "UDP", 8675, 30061, 7000) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port4", "UDP", 8676, 30062, 7001) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.4"}, }, } @@ -169,18 +169,18 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "load balancer service with only local traffic policy", - service: makeTestService("ns1", "only-local-load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + service: makeTestService("ns1", "only-local-load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.12" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "portx", "UDP", 8677, 30063, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "porty", "UDP", 8678, 30064, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }), expected: map[ServicePortName]*BaseServiceInfo{ @@ -190,8 +190,8 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "external name service", - service: makeTestService("ns2", "external-name", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeExternalName + service: makeTestService("ns2", "external-name", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeExternalName svc.Spec.ClusterIP = "172.16.55.4" // Should be ignored svc.Spec.ExternalName = "foo2.bar.com" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "portz", "UDP", 1235, 5321, 0) @@ -200,18 +200,18 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with ipv6 clusterIP under ipv4 mode, service should be filtered", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "invalidIPv6InIPV4Mode", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv6, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -220,18 +220,18 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with ipv4 clusterIP under ipv6 mode, service should be filtered", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "invalidIPv4InIPV6Mode", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv4, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -240,20 +240,20 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with ipv4 configurations under ipv4 mode", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "validIPv4", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv4, ExternalIPs: []string{testExternalIPv4}, LoadBalancerSourceRanges: []string{testSourceRangeIPv4}, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -268,20 +268,20 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with ipv6 configurations under ipv6 mode", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "validIPv6", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv6, ExternalIPs: []string{testExternalIPv6}, LoadBalancerSourceRanges: []string{testSourceRangeIPv6}, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -296,20 +296,20 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with both ipv4 and ipv6 configurations under ipv4 mode, ipv6 fields should be filtered", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "filterIPv6InIPV4Mode", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv4, ExternalIPs: []string{testExternalIPv4, testExternalIPv6}, LoadBalancerSourceRanges: []string{testSourceRangeIPv4, testSourceRangeIPv6}, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -324,20 +324,20 @@ func TestServiceToServiceMap(t *testing.T) { }, { desc: "service with both ipv4 and ipv6 configurations under ipv6 mode, ipv4 fields should be filtered", - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "filterIPv4InIPV6Mode", Namespace: "test", }, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: testClusterIPv6, ExternalIPs: []string{testExternalIPv4, testExternalIPv6}, LoadBalancerSourceRanges: []string{testSourceRangeIPv4, testSourceRangeIPv6}, - Ports: []api.ServicePort{ + Ports: []v1.ServicePort{ { Name: "testPort", Port: int32(12345), - Protocol: api.ProtocolTCP, + Protocol: v1.ProtocolTCP, }, }, }, @@ -391,21 +391,21 @@ func newFakeProxier() *FakeProxier { } } -func makeServiceMap(fake *FakeProxier, allServices ...*api.Service) { +func makeServiceMap(fake *FakeProxier, allServices ...*v1.Service) { for i := range allServices { fake.addService(allServices[i]) } } -func (fake *FakeProxier) addService(service *api.Service) { +func (fake *FakeProxier) addService(service *v1.Service) { fake.serviceChanges.Update(nil, service) } -func (fake *FakeProxier) updateService(oldService *api.Service, service *api.Service) { +func (fake *FakeProxier) updateService(oldService *v1.Service, service *v1.Service) { fake.serviceChanges.Update(oldService, service) } -func (fake *FakeProxier) deleteService(service *api.Service) { +func (fake *FakeProxier) deleteService(service *v1.Service) { fake.serviceChanges.Update(service, nil) } @@ -413,14 +413,14 @@ func TestUpdateServiceMapHeadless(t *testing.T) { fp := newFakeProxier() makeServiceMap(fp, - makeTestService("ns2", "headless", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("ns2", "headless", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone svc.Spec.Ports = addTestPort(svc.Spec.Ports, "rpc", "UDP", 1234, 0, 0) }), - makeTestService("ns2", "headless-without-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP - svc.Spec.ClusterIP = api.ClusterIPNone + makeTestService("ns2", "headless-without-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP + svc.Spec.ClusterIP = v1.ClusterIPNone }), ) @@ -444,8 +444,8 @@ func TestUpdateServiceTypeExternalName(t *testing.T) { fp := newFakeProxier() makeServiceMap(fp, - makeTestService("ns2", "external-name", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeExternalName + makeTestService("ns2", "external-name", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeExternalName svc.Spec.ClusterIP = "172.16.55.4" // Should be ignored svc.Spec.ExternalName = "foo2.bar.com" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "blah", "UDP", 1235, 5321, 0) @@ -468,43 +468,43 @@ func TestUpdateServiceTypeExternalName(t *testing.T) { func TestBuildServiceMapAddRemove(t *testing.T) { fp := newFakeProxier() - services := []*api.Service{ - makeTestService("ns2", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + services := []*v1.Service{ + makeTestService("ns2", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port1", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port2", "UDP", 1235, 5321, 0) }), - makeTestService("ns2", "node-port", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeNodePort + makeTestService("ns2", "node-port", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeNodePort svc.Spec.ClusterIP = "172.16.55.10" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port1", "UDP", 345, 678, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port2", "TCP", 344, 677, 0) }), - makeTestService("ns1", "load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("ns1", "load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.11" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar", "UDP", 8675, 30061, 7000) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8676, 30062, 7001) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.4"}, }, } }), - makeTestService("ns1", "only-local-load-balancer", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + makeTestService("ns1", "only-local-load-balancer", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.12" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "foobar2", "UDP", 8677, 30063, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "baz", "UDP", 8678, 30064, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }), } @@ -534,8 +534,8 @@ func TestBuildServiceMapAddRemove(t *testing.T) { // Remove some stuff // oneService is a modification of services[0] with removed first port. - oneService := makeTestService("ns2", "cluster-ip", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + oneService := makeTestService("ns2", "cluster-ip", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p2", "UDP", 1235, 5321, 0) }) @@ -571,24 +571,24 @@ func TestBuildServiceMapAddRemove(t *testing.T) { func TestBuildServiceMapServiceUpdate(t *testing.T) { fp := newFakeProxier() - servicev1 := makeTestService("ns1", "svc1", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeClusterIP + servicev1 := makeTestService("ns1", "svc1", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeClusterIP svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p1", "UDP", 1234, 4321, 0) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p2", "TCP", 1235, 5321, 0) }) - servicev2 := makeTestService("ns1", "svc1", func(svc *api.Service) { - svc.Spec.Type = api.ServiceTypeLoadBalancer + servicev2 := makeTestService("ns1", "svc1", func(svc *v1.Service) { + svc.Spec.Type = v1.ServiceTypeLoadBalancer svc.Spec.ClusterIP = "172.16.55.4" svc.Spec.LoadBalancerIP = "5.6.7.8" svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p1", "UDP", 1234, 4321, 7002) svc.Spec.Ports = addTestPort(svc.Spec.Ports, "p2", "TCP", 1235, 5321, 7003) - svc.Status.LoadBalancer = api.LoadBalancerStatus{ - Ingress: []api.LoadBalancerIngress{ + svc.Status.LoadBalancer = v1.LoadBalancerStatus{ + Ingress: []v1.LoadBalancerIngress{ {IP: "10.1.2.3"}, }, } - svc.Spec.ExternalTrafficPolicy = api.ServiceExternalTrafficPolicyTypeLocal + svc.Spec.ExternalTrafficPolicy = v1.ServiceExternalTrafficPolicyTypeLocal svc.Spec.HealthCheckNodePort = 345 }) diff --git a/pkg/proxy/types.go b/pkg/proxy/types.go index a3cb4d35e5..f38937068c 100644 --- a/pkg/proxy/types.go +++ b/pkg/proxy/types.go @@ -19,8 +19,8 @@ package proxy import ( "fmt" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" - api "k8s.io/kubernetes/pkg/apis/core" ) // ProxyProvider is the interface provided by proxier implementations. @@ -51,7 +51,7 @@ type ServicePort interface { // ClusterIPString returns service cluster IP in string format. ClusterIPString() string // GetProtocol returns service protocol. - GetProtocol() api.Protocol + GetProtocol() v1.Protocol // GetHealthCheckNodePort returns service health check node port if present. If return 0, it means not present. GetHealthCheckNodePort() int } diff --git a/pkg/proxy/userspace/loadbalancer.go b/pkg/proxy/userspace/loadbalancer.go index ebaeb9f4db..f0e5bcaa69 100644 --- a/pkg/proxy/userspace/loadbalancer.go +++ b/pkg/proxy/userspace/loadbalancer.go @@ -17,7 +17,7 @@ limitations under the License. package userspace import ( - api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/api/core/v1" "k8s.io/kubernetes/pkg/proxy" "net" ) @@ -27,7 +27,7 @@ type LoadBalancer interface { // NextEndpoint returns the endpoint to handle a request for the given // service-port and source address. NextEndpoint(service proxy.ServicePortName, srcAddr net.Addr, sessionAffinityReset bool) (string, error) - NewService(service proxy.ServicePortName, sessionAffinityType api.ServiceAffinity, stickyMaxAgeSeconds int) error + NewService(service proxy.ServicePortName, sessionAffinityType v1.ServiceAffinity, stickyMaxAgeSeconds int) error DeleteService(service proxy.ServicePortName) CleanupStaleStickySessions(service proxy.ServicePortName) ServiceHasEndpoints(service proxy.ServicePortName) bool diff --git a/pkg/proxy/userspace/proxier.go b/pkg/proxy/userspace/proxier.go index 292e96832d..38ee0c2ce6 100644 --- a/pkg/proxy/userspace/proxier.go +++ b/pkg/proxy/userspace/proxier.go @@ -28,14 +28,12 @@ import ( "github.com/golang/glog" "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" - utilnet "k8s.io/apimachinery/pkg/util/net" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/apis/core/helper" - "k8s.io/kubernetes/pkg/proxy" - utilerrors "k8s.io/apimachinery/pkg/util/errors" + utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/kubernetes/pkg/apis/core/v1/helper" + "k8s.io/kubernetes/pkg/proxy" utilproxy "k8s.io/kubernetes/pkg/proxy/util" "k8s.io/kubernetes/pkg/util/conntrack" "k8s.io/kubernetes/pkg/util/iptables" @@ -57,12 +55,12 @@ type ServiceInfo struct { isAliveAtomic int32 // Only access this with atomic ops portal portal - protocol api.Protocol + protocol v1.Protocol proxyPort int socket ProxySocket nodePort int - loadBalancerStatus api.LoadBalancerStatus - sessionAffinityType api.ServiceAffinity + loadBalancerStatus v1.LoadBalancerStatus + sessionAffinityType v1.ServiceAffinity stickyMaxAgeSeconds int // Deprecated, but required for back-compat (including e2e) externalIPs []string @@ -91,7 +89,7 @@ func logTimeout(err error) bool { } // ProxySocketFunc is a function which constructs a ProxySocket from a protocol, ip, and port -type ProxySocketFunc func(protocol api.Protocol, ip net.IP, port int) (ProxySocket, error) +type ProxySocketFunc func(protocol v1.Protocol, ip net.IP, port int) (ProxySocket, error) // Proxier is a simple proxy for TCP connections between a localhost:lport // and services that provide the actual implementations. @@ -121,7 +119,7 @@ var _ proxy.ProxyProvider = &Proxier{} type portMapKey struct { ip string port int - protocol api.Protocol + protocol v1.Protocol } func (k *portMapKey) String() string { @@ -364,7 +362,7 @@ func (proxier *Proxier) setServiceInfo(service proxy.ServicePortName, info *Serv // addServiceOnPort starts listening for a new service, returning the ServiceInfo. // Pass proxyPort=0 to allocate a random port. The timeout only applies to UDP // connections, for now. -func (proxier *Proxier) addServiceOnPort(service proxy.ServicePortName, protocol api.Protocol, proxyPort int, timeout time.Duration) (*ServiceInfo, error) { +func (proxier *Proxier) addServiceOnPort(service proxy.ServicePortName, protocol v1.Protocol, proxyPort int, timeout time.Duration) (*ServiceInfo, error) { sock, err := proxier.makeProxySocket(protocol, proxier.listenIP, proxyPort) if err != nil { return nil, err @@ -386,7 +384,7 @@ func (proxier *Proxier) addServiceOnPort(service proxy.ServicePortName, protocol proxyPort: portNum, protocol: protocol, socket: sock, - sessionAffinityType: api.ServiceAffinityNone, // default + sessionAffinityType: v1.ServiceAffinityNone, // default } proxier.setServiceInfo(service, si) @@ -401,7 +399,7 @@ func (proxier *Proxier) addServiceOnPort(service proxy.ServicePortName, protocol return si, nil } -func (proxier *Proxier) mergeService(service *api.Service) sets.String { +func (proxier *Proxier) mergeService(service *v1.Service) sets.String { if service == nil { return nil } @@ -451,7 +449,7 @@ func (proxier *Proxier) mergeService(service *api.Service) sets.String { info.nodePort = int(servicePort.NodePort) info.sessionAffinityType = service.Spec.SessionAffinity // Kube-apiserver side guarantees SessionAffinityConfig won't be nil when session affinity type is ClientIP - if service.Spec.SessionAffinity == api.ServiceAffinityClientIP { + if service.Spec.SessionAffinity == v1.ServiceAffinityClientIP { info.stickyMaxAgeSeconds = int(*service.Spec.SessionAffinityConfig.ClientIP.TimeoutSeconds) } @@ -466,7 +464,7 @@ func (proxier *Proxier) mergeService(service *api.Service) sets.String { return existingPorts } -func (proxier *Proxier) unmergeService(service *api.Service, existingPorts sets.String) { +func (proxier *Proxier) unmergeService(service *v1.Service, existingPorts sets.String) { if service == nil { return } @@ -493,7 +491,7 @@ func (proxier *Proxier) unmergeService(service *api.Service, existingPorts sets. continue } - if proxier.serviceMap[serviceName].protocol == api.ProtocolUDP { + if proxier.serviceMap[serviceName].protocol == v1.ProtocolUDP { staleUDPServices.Insert(proxier.serviceMap[serviceName].portal.ip.String()) } @@ -512,23 +510,23 @@ func (proxier *Proxier) unmergeService(service *api.Service, existingPorts sets. } } -func (proxier *Proxier) OnServiceAdd(service *api.Service) { +func (proxier *Proxier) OnServiceAdd(service *v1.Service) { _ = proxier.mergeService(service) } -func (proxier *Proxier) OnServiceUpdate(oldService, service *api.Service) { +func (proxier *Proxier) OnServiceUpdate(oldService, service *v1.Service) { existingPorts := proxier.mergeService(service) proxier.unmergeService(oldService, existingPorts) } -func (proxier *Proxier) OnServiceDelete(service *api.Service) { +func (proxier *Proxier) OnServiceDelete(service *v1.Service) { proxier.unmergeService(service, sets.NewString()) } func (proxier *Proxier) OnServiceSynced() { } -func sameConfig(info *ServiceInfo, service *api.Service, port *api.ServicePort) bool { +func sameConfig(info *ServiceInfo, service *v1.Service, port *v1.ServicePort) bool { if info.protocol != port.Protocol || info.portal.port != int(port.Port) || info.nodePort != int(port.NodePort) { return false } @@ -587,7 +585,7 @@ func (proxier *Proxier) openPortal(service proxy.ServicePortName, info *ServiceI return nil } -func (proxier *Proxier) openOnePortal(portal portal, protocol api.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) error { +func (proxier *Proxier) openOnePortal(portal portal, protocol v1.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) error { if local, err := utilproxy.IsLocalIP(portal.ip.String()); err != nil { return fmt.Errorf("can't determine if IP %s is local, assuming not: %v", portal.ip, err) } else if local { @@ -646,7 +644,7 @@ func (proxier *Proxier) openOnePortal(portal portal, protocol api.Protocol, prox // Marks a port as being owned by a particular service, or returns error if already claimed. // Idempotent: reclaiming with the same owner is not an error -func (proxier *Proxier) claimNodePort(ip net.IP, port int, protocol api.Protocol, owner proxy.ServicePortName) error { +func (proxier *Proxier) claimNodePort(ip net.IP, port int, protocol v1.Protocol, owner proxy.ServicePortName) error { proxier.portMapMutex.Lock() defer proxier.portMapMutex.Unlock() @@ -679,7 +677,7 @@ func (proxier *Proxier) claimNodePort(ip net.IP, port int, protocol api.Protocol // Release a claim on a port. Returns an error if the owner does not match the claim. // Tolerates release on an unclaimed port, to simplify . -func (proxier *Proxier) releaseNodePort(ip net.IP, port int, protocol api.Protocol, owner proxy.ServicePortName) error { +func (proxier *Proxier) releaseNodePort(ip net.IP, port int, protocol v1.Protocol, owner proxy.ServicePortName) error { proxier.portMapMutex.Lock() defer proxier.portMapMutex.Unlock() @@ -698,7 +696,7 @@ func (proxier *Proxier) releaseNodePort(ip net.IP, port int, protocol api.Protoc return nil } -func (proxier *Proxier) openNodePort(nodePort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) error { +func (proxier *Proxier) openNodePort(nodePort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) error { // TODO: Do we want to allow containers to access public services? Probably yes. // TODO: We could refactor this to be the same code as portal, but with IP == nil @@ -764,7 +762,7 @@ func (proxier *Proxier) closePortal(service proxy.ServicePortName, info *Service return utilerrors.NewAggregate(el) } -func (proxier *Proxier) closeOnePortal(portal portal, protocol api.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) []error { +func (proxier *Proxier) closeOnePortal(portal portal, protocol v1.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) []error { el := []error{} if local, err := utilproxy.IsLocalIP(portal.ip.String()); err != nil { @@ -807,7 +805,7 @@ func (proxier *Proxier) closeOnePortal(portal portal, protocol api.Protocol, pro return el } -func (proxier *Proxier) closeNodePort(nodePort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) []error { +func (proxier *Proxier) closeNodePort(nodePort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, name proxy.ServicePortName) []error { el := []error{} // Handle traffic from containers. @@ -949,7 +947,7 @@ var zeroIPv6 = net.ParseIP("::") var localhostIPv6 = net.ParseIP("::1") // Build a slice of iptables args that are common to from-container and from-host portal rules. -func iptablesCommonPortalArgs(destIP net.IP, addPhysicalInterfaceMatch bool, addDstLocalMatch bool, destPort int, protocol api.Protocol, service proxy.ServicePortName) []string { +func iptablesCommonPortalArgs(destIP net.IP, addPhysicalInterfaceMatch bool, addDstLocalMatch bool, destPort int, protocol v1.Protocol, service proxy.ServicePortName) []string { // This list needs to include all fields as they are eventually spit out // by iptables-save. This is because some systems do not support the // 'iptables -C' arg, and so fall back on parsing iptables-save output. @@ -982,7 +980,7 @@ func iptablesCommonPortalArgs(destIP net.IP, addPhysicalInterfaceMatch bool, add } // Build a slice of iptables args for a from-container portal rule. -func (proxier *Proxier) iptablesContainerPortalArgs(destIP net.IP, addPhysicalInterfaceMatch bool, addDstLocalMatch bool, destPort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { +func (proxier *Proxier) iptablesContainerPortalArgs(destIP net.IP, addPhysicalInterfaceMatch bool, addDstLocalMatch bool, destPort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { args := iptablesCommonPortalArgs(destIP, addPhysicalInterfaceMatch, addDstLocalMatch, destPort, protocol, service) // This is tricky. @@ -1029,7 +1027,7 @@ func (proxier *Proxier) iptablesContainerPortalArgs(destIP net.IP, addPhysicalIn } // Build a slice of iptables args for a from-host portal rule. -func (proxier *Proxier) iptablesHostPortalArgs(destIP net.IP, addDstLocalMatch bool, destPort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { +func (proxier *Proxier) iptablesHostPortalArgs(destIP net.IP, addDstLocalMatch bool, destPort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { args := iptablesCommonPortalArgs(destIP, false, addDstLocalMatch, destPort, protocol, service) // This is tricky. @@ -1064,7 +1062,7 @@ func (proxier *Proxier) iptablesHostPortalArgs(destIP net.IP, addDstLocalMatch b // Build a slice of iptables args for a from-host public-port rule. // See iptablesHostPortalArgs // TODO: Should we just reuse iptablesHostPortalArgs? -func (proxier *Proxier) iptablesHostNodePortArgs(nodePort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { +func (proxier *Proxier) iptablesHostNodePortArgs(nodePort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { args := iptablesCommonPortalArgs(nil, false, false, nodePort, protocol, service) if proxyIP.Equal(zeroIPv4) || proxyIP.Equal(zeroIPv6) { @@ -1076,7 +1074,7 @@ func (proxier *Proxier) iptablesHostNodePortArgs(nodePort int, protocol api.Prot } // Build a slice of iptables args for an from-non-local public-port rule. -func (proxier *Proxier) iptablesNonLocalNodePortArgs(nodePort int, protocol api.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { +func (proxier *Proxier) iptablesNonLocalNodePortArgs(nodePort int, protocol v1.Protocol, proxyIP net.IP, proxyPort int, service proxy.ServicePortName) []string { args := iptablesCommonPortalArgs(nil, false, false, proxyPort, protocol, service) args = append(args, "-m", "state", "--state", "NEW", "-j", "ACCEPT") return args diff --git a/pkg/proxy/userspace/proxier_test.go b/pkg/proxy/userspace/proxier_test.go index 6c9ce711a6..cee7eec411 100644 --- a/pkg/proxy/userspace/proxier_test.go +++ b/pkg/proxy/userspace/proxier_test.go @@ -29,10 +29,10 @@ import ( "testing" "time" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/runtime" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" ipttest "k8s.io/kubernetes/pkg/util/iptables/testing" "k8s.io/utils/exec" @@ -228,11 +228,11 @@ func waitForNumProxyClients(t *testing.T, s *ServiceInfo, want int, timeout time func TestTCPProxy(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -255,11 +255,11 @@ func TestTCPProxy(t *testing.T) { func TestUDPProxy(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -282,11 +282,11 @@ func TestUDPProxy(t *testing.T) { func TestUDPProxyTimeout(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -314,18 +314,18 @@ func TestMultiPortProxy(t *testing.T) { lb := NewLoadBalancerRR() serviceP := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo-p"}, Port: "p"} serviceQ := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo-q"}, Port: "q"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Protocol: "TCP", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Protocol: "TCP", Port: tcpServerPort}}, }}, }) - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceQ.Name, Namespace: serviceQ.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "q", Protocol: "UDP", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "q", Protocol: "UDP", Port: udpServerPort}}, }}, }) @@ -366,9 +366,9 @@ func TestMultiPortOnServiceAdd(t *testing.T) { } waitForNumProxyLoops(t, p, 0) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: 80, Protocol: "TCP", @@ -413,11 +413,11 @@ func stopProxyByName(proxier *Proxier, service proxy.ServicePortName) error { func TestTCPProxyStop(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -457,11 +457,11 @@ func TestTCPProxyStop(t *testing.T) { func TestUDPProxyStop(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -495,11 +495,11 @@ func TestUDPProxyStop(t *testing.T) { func TestTCPProxyUpdateDelete(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -522,9 +522,9 @@ func TestTCPProxyUpdateDelete(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", @@ -539,11 +539,11 @@ func TestTCPProxyUpdateDelete(t *testing.T) { func TestUDPProxyUpdateDelete(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -566,9 +566,9 @@ func TestUDPProxyUpdateDelete(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "UDP", @@ -583,11 +583,11 @@ func TestUDPProxyUpdateDelete(t *testing.T) { func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -611,9 +611,9 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", @@ -626,9 +626,9 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { // need to add endpoint here because it got clean up during service delete lb.OnEndpointsAdd(endpoint) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", @@ -645,11 +645,11 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -673,9 +673,9 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "UDP", @@ -688,9 +688,9 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { // need to add endpoint here because it got clean up during service delete lb.OnEndpointsAdd(endpoint) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "UDP", @@ -707,11 +707,11 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { func TestTCPProxyUpdatePort(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -730,9 +730,9 @@ func TestTCPProxyUpdatePort(t *testing.T) { testEchoTCP(t, "127.0.0.1", svcInfo.proxyPort) waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: 99, Protocol: "TCP", @@ -755,11 +755,11 @@ func TestTCPProxyUpdatePort(t *testing.T) { func TestUDPProxyUpdatePort(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -777,9 +777,9 @@ func TestUDPProxyUpdatePort(t *testing.T) { } waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: 99, Protocol: "UDP", @@ -800,11 +800,11 @@ func TestUDPProxyUpdatePort(t *testing.T) { func TestProxyUpdatePublicIPs(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -823,10 +823,10 @@ func TestProxyUpdatePublicIPs(t *testing.T) { testEchoTCP(t, "127.0.0.1", svcInfo.proxyPort) waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ - Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ + Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.portal.port), Protocol: "TCP", @@ -852,11 +852,11 @@ func TestProxyUpdatePublicIPs(t *testing.T) { func TestProxyUpdatePortal(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -876,18 +876,18 @@ func TestProxyUpdatePortal(t *testing.T) { testEchoTCP(t, "127.0.0.1", svcInfo.proxyPort) waitForNumProxyLoops(t, p, 1) - svcv0 := &api.Service{ + svcv0 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", }}}, } - svcv1 := &api.Service{ + svcv1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", @@ -899,9 +899,9 @@ func TestProxyUpdatePortal(t *testing.T) { t.Fatalf("service with empty ClusterIP should not be included in the proxy") } - svcv2 := &api.Service{ + svcv2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "None", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "None", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", @@ -913,9 +913,9 @@ func TestProxyUpdatePortal(t *testing.T) { t.Fatalf("service with 'None' as ClusterIP should not be included in the proxy") } - svcv3 := &api.Service{ + svcv3 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "1.2.3.4", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.proxyPort), Protocol: "TCP", diff --git a/pkg/proxy/userspace/proxysocket.go b/pkg/proxy/userspace/proxysocket.go index 207004b1cb..d16b002ac9 100644 --- a/pkg/proxy/userspace/proxysocket.go +++ b/pkg/proxy/userspace/proxysocket.go @@ -26,8 +26,8 @@ import ( "time" "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/util/runtime" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" ) @@ -45,7 +45,7 @@ type ProxySocket interface { ListenPort() int } -func newProxySocket(protocol api.Protocol, ip net.IP, port int) (ProxySocket, error) { +func newProxySocket(protocol v1.Protocol, ip net.IP, port int) (ProxySocket, error) { host := "" if ip != nil { host = ip.String() diff --git a/pkg/proxy/userspace/roundrobin.go b/pkg/proxy/userspace/roundrobin.go index 3ca546b5e0..5e84e8c27c 100644 --- a/pkg/proxy/userspace/roundrobin.go +++ b/pkg/proxy/userspace/roundrobin.go @@ -26,8 +26,8 @@ import ( "time" "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/util/slice" ) @@ -46,7 +46,7 @@ type affinityState struct { } type affinityPolicy struct { - affinityType api.ServiceAffinity + affinityType v1.ServiceAffinity affinityMap map[string]*affinityState // map client IP -> affinity info ttlSeconds int } @@ -66,7 +66,7 @@ type balancerState struct { affinity affinityPolicy } -func newAffinityPolicy(affinityType api.ServiceAffinity, ttlSeconds int) *affinityPolicy { +func newAffinityPolicy(affinityType v1.ServiceAffinity, ttlSeconds int) *affinityPolicy { return &affinityPolicy{ affinityType: affinityType, affinityMap: make(map[string]*affinityState), @@ -81,7 +81,7 @@ func NewLoadBalancerRR() *LoadBalancerRR { } } -func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ttlSeconds int) error { +func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType v1.ServiceAffinity, ttlSeconds int) error { glog.V(4).Infof("LoadBalancerRR NewService %q", svcPort) lb.lock.Lock() defer lb.lock.Unlock() @@ -90,9 +90,9 @@ func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType } // This assumes that lb.lock is already held. -func (lb *LoadBalancerRR) newServiceInternal(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ttlSeconds int) *balancerState { +func (lb *LoadBalancerRR) newServiceInternal(svcPort proxy.ServicePortName, affinityType v1.ServiceAffinity, ttlSeconds int) *balancerState { if ttlSeconds == 0 { - ttlSeconds = int(api.DefaultClientIPServiceAffinitySeconds) //default to 3 hours if not specified. Should 0 be unlimited instead???? + ttlSeconds = int(v1.DefaultClientIPServiceAffinitySeconds) //default to 3 hours if not specified. Should 0 be unlimited instead???? } if _, exists := lb.services[svcPort]; !exists { @@ -114,7 +114,7 @@ func (lb *LoadBalancerRR) DeleteService(svcPort proxy.ServicePortName) { // return true if this service is using some form of session affinity. func isSessionAffinity(affinity *affinityPolicy) bool { // Should never be empty string, but checking for it to be safe. - if affinity.affinityType == "" || affinity.affinityType == api.ServiceAffinityNone { + if affinity.affinityType == "" || affinity.affinityType == v1.ServiceAffinityNone { return false } return true @@ -245,7 +245,7 @@ func (lb *LoadBalancerRR) updateAffinityMap(svcPort proxy.ServicePortName, newEn // buildPortsToEndpointsMap builds a map of portname -> all ip:ports for that // portname. Expode Endpoints.Subsets[*] into this structure. -func buildPortsToEndpointsMap(endpoints *api.Endpoints) map[string][]hostPortPair { +func buildPortsToEndpointsMap(endpoints *v1.Endpoints) map[string][]hostPortPair { portsToEndpoints := map[string][]hostPortPair{} for i := range endpoints.Subsets { ss := &endpoints.Subsets[i] @@ -261,7 +261,7 @@ func buildPortsToEndpointsMap(endpoints *api.Endpoints) map[string][]hostPortPai return portsToEndpoints } -func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) lb.lock.Lock() @@ -279,7 +279,7 @@ func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { // To be safe we will call it here. A new service will only be created // if one does not already exist. The affinity will be updated // later, once NewService is called. - state = lb.newServiceInternal(svcPort, api.ServiceAffinity(""), 0) + state = lb.newServiceInternal(svcPort, v1.ServiceAffinity(""), 0) state.endpoints = slice.ShuffleStrings(newEndpoints) // Reset the round-robin index. @@ -288,7 +288,7 @@ func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { } } -func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) oldPortsToEndpoints := buildPortsToEndpointsMap(oldEndpoints) registeredEndpoints := make(map[proxy.ServicePortName]bool) @@ -313,7 +313,7 @@ func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoin // To be safe we will call it here. A new service will only be created // if one does not already exist. The affinity will be updated // later, once NewService is called. - state = lb.newServiceInternal(svcPort, api.ServiceAffinity(""), 0) + state = lb.newServiceInternal(svcPort, v1.ServiceAffinity(""), 0) state.endpoints = slice.ShuffleStrings(newEndpoints) // Reset the round-robin index. @@ -343,7 +343,7 @@ func (lb *LoadBalancerRR) resetService(svcPort proxy.ServicePortName) { } } -func (lb *LoadBalancerRR) OnEndpointsDelete(endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsDelete(endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) lb.lock.Lock() diff --git a/pkg/proxy/userspace/roundrobin_test.go b/pkg/proxy/userspace/roundrobin_test.go index 8da691a6ea..01b711e0d4 100644 --- a/pkg/proxy/userspace/roundrobin_test.go +++ b/pkg/proxy/userspace/roundrobin_test.go @@ -20,9 +20,9 @@ import ( "net" "testing" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" ) @@ -104,11 +104,11 @@ func TestLoadBalanceWorksWithSingleEndpoint(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 40}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 40}}, }}, } loadBalancer.OnEndpointsAdd(endpoints) @@ -141,11 +141,11 @@ func TestLoadBalanceWorksWithMultipleEndpoints(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "p", Port: 2}, {Name: "p", Port: 3}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "p", Port: 2}, {Name: "p", Port: 3}}, }}, } loadBalancer.OnEndpointsAdd(endpoints) @@ -168,16 +168,16 @@ func TestLoadBalanceWorksWithMultipleEndpointsMultiplePorts(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 2}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 2}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 4}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 4}}, }, }, } @@ -210,20 +210,20 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpointsv1 := &api.Endpoints{ + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 10}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 10}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 2}, {Name: "q", Port: 20}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 2}, {Name: "q", Port: 20}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 30}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 30}}, }, }, } @@ -249,16 +249,16 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { // Then update the configuration with one fewer endpoints, make sure // we start in the beginning again - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint4"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 4}, {Name: "q", Port: 40}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint4"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 4}, {Name: "q", Port: 40}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint5"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 5}, {Name: "q", Port: 50}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint5"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 5}, {Name: "q", Port: 50}}, }, }, } @@ -283,7 +283,7 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, serviceQ, shuffledEndpoints[1], nil) // Clear endpoints - endpointsv3 := &api.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, Subsets: nil} + endpointsv3 := &v1.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, Subsets: nil} loadBalancer.OnEndpointsUpdate(endpointsv2, endpointsv3) endpoint, err = loadBalancer.NextEndpoint(serviceP, nil, false) @@ -300,21 +300,21 @@ func TestLoadBalanceWorksWithServiceRemoval(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints1 := &api.Endpoints{ + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: fooServiceP.Name, Namespace: fooServiceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}, {IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 123}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}, {IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 123}}, }, }, } - endpoints2 := &api.Endpoints{ + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: barServiceP.Name, Namespace: barServiceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint4"}, {IP: "endpoint5"}, {IP: "endpoint6"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 456}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint4"}, {IP: "endpoint5"}, {IP: "endpoint6"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 456}}, }, }, } @@ -357,13 +357,13 @@ func TestStickyLoadBalanceWorksWithNewServiceCalledFirst(t *testing.T) { } // Call NewService() before OnEndpointsUpdate() - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, Ports: []api.EndpointPort{{Port: 3}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, Ports: []v1.EndpointPort{{Port: 3}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) @@ -413,15 +413,15 @@ func TestStickyLoadBalanceWorksWithNewServiceCalledSecond(t *testing.T) { } // Call OnEndpointsUpdate() before NewService() - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) client1 := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0} client2 := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 2), Port: 0} @@ -473,13 +473,13 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpointsv1 := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } @@ -494,12 +494,12 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[2], client3) client3Endpoint := shuffledEndpoints[2] - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}}, }, }, } @@ -516,12 +516,12 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { expectEndpoint(t, loadBalancer, service, client2Endpoint, client2) expectEndpoint(t, loadBalancer, service, client3Endpoint, client3) - endpointsv3 := &api.Endpoints{ + endpointsv3 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 4}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 4}}, }, }, } @@ -546,13 +546,13 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpointsv1 := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } @@ -567,12 +567,12 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[1], client2) // Then update the configuration with one fewer endpoints, make sure // we start in the beginning again - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 4}, {Port: 5}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 4}, {Port: 5}}, }, }, } @@ -586,7 +586,7 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[1], client2) // Clear endpoints - endpointsv3 := &api.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, Subsets: nil} + endpointsv3 := &v1.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, Subsets: nil} loadBalancer.OnEndpointsUpdate(endpointsv2, endpointsv3) endpoint, err = loadBalancer.NextEndpoint(service, nil, false) @@ -605,24 +605,24 @@ func TestStickyLoadBalanceWorksWithServiceRemoval(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(fooService, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints1 := &api.Endpoints{ + loadBalancer.NewService(fooService, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: fooService.Name, Namespace: fooService.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } barService := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "bar"}, Port: ""} - loadBalancer.NewService(barService, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints2 := &api.Endpoints{ + loadBalancer.NewService(barService, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: barService.Name, Namespace: barService.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 4}, {Port: 5}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 4}, {Port: 5}}, }, }, } @@ -674,13 +674,13 @@ func TestStickyLoadBalanceWorksWithEndpointFails(t *testing.T) { } // Call NewService() before OnEndpointsUpdate() - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, Ports: []api.EndpointPort{{Port: 3}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, Ports: []v1.EndpointPort{{Port: 3}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) diff --git a/pkg/proxy/util/utils.go b/pkg/proxy/util/utils.go index d766a1d4eb..ca1e6c8fc9 100644 --- a/pkg/proxy/util/utils.go +++ b/pkg/proxy/util/utils.go @@ -24,8 +24,7 @@ import ( "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/client-go/tools/record" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/apis/core/helper" + helper "k8s.io/kubernetes/pkg/apis/core/v1/helper" utilnet "k8s.io/kubernetes/pkg/util/net" "github.com/golang/glog" @@ -60,14 +59,14 @@ func IsLocalIP(ip string) (bool, error) { return false, nil } -func ShouldSkipService(svcName types.NamespacedName, service *api.Service) bool { +func ShouldSkipService(svcName types.NamespacedName, service *v1.Service) bool { // if ClusterIP is "None" or empty, skip proxying if !helper.IsServiceIPSet(service) { glog.V(3).Infof("Skipping service %s due to clusterIP = %q", svcName, service.Spec.ClusterIP) return true } // Even if ClusterIP is set, ServiceTypeExternalName services don't get proxied - if service.Spec.Type == api.ServiceTypeExternalName { + if service.Spec.Type == v1.ServiceTypeExternalName { glog.V(3).Infof("Skipping service %s due to Type=ExternalName", svcName) return true } diff --git a/pkg/proxy/util/utils_test.go b/pkg/proxy/util/utils_test.go index aaac610ed4..0f4c19f2e8 100644 --- a/pkg/proxy/util/utils_test.go +++ b/pkg/proxy/util/utils_test.go @@ -20,25 +20,25 @@ import ( "net" "testing" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" - api "k8s.io/kubernetes/pkg/apis/core" fake "k8s.io/kubernetes/pkg/proxy/util/testing" ) func TestShouldSkipService(t *testing.T) { testCases := []struct { - service *api.Service + service *v1.Service svcName types.NamespacedName shouldSkip bool }{ { // Cluster IP is None - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ - ClusterIP: api.ClusterIPNone, + Spec: v1.ServiceSpec{ + ClusterIP: v1.ClusterIPNone, }, }, svcName: types.NamespacedName{Namespace: "foo", Name: "bar"}, @@ -46,9 +46,9 @@ func TestShouldSkipService(t *testing.T) { }, { // Cluster IP is empty - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: "", }, }, @@ -57,11 +57,11 @@ func TestShouldSkipService(t *testing.T) { }, { // ExternalName type service - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: "1.2.3.4", - Type: api.ServiceTypeExternalName, + Type: v1.ServiceTypeExternalName, }, }, svcName: types.NamespacedName{Namespace: "foo", Name: "bar"}, @@ -69,11 +69,11 @@ func TestShouldSkipService(t *testing.T) { }, { // ClusterIP type service with ClusterIP set - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: "1.2.3.4", - Type: api.ServiceTypeClusterIP, + Type: v1.ServiceTypeClusterIP, }, }, svcName: types.NamespacedName{Namespace: "foo", Name: "bar"}, @@ -81,11 +81,11 @@ func TestShouldSkipService(t *testing.T) { }, { // NodePort type service with ClusterIP set - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: "1.2.3.4", - Type: api.ServiceTypeNodePort, + Type: v1.ServiceTypeNodePort, }, }, svcName: types.NamespacedName{Namespace: "foo", Name: "bar"}, @@ -93,11 +93,11 @@ func TestShouldSkipService(t *testing.T) { }, { // LoadBalancer type service with ClusterIP set - service: &api.Service{ + service: &v1.Service{ ObjectMeta: metav1.ObjectMeta{Namespace: "foo", Name: "bar"}, - Spec: api.ServiceSpec{ + Spec: v1.ServiceSpec{ ClusterIP: "1.2.3.4", - Type: api.ServiceTypeLoadBalancer, + Type: v1.ServiceTypeLoadBalancer, }, }, svcName: types.NamespacedName{Namespace: "foo", Name: "bar"}, diff --git a/pkg/proxy/winkernel/proxier.go b/pkg/proxy/winkernel/proxier.go index fb9762117c..d87aec75a0 100644 --- a/pkg/proxy/winkernel/proxier.go +++ b/pkg/proxy/winkernel/proxier.go @@ -32,13 +32,13 @@ import ( "github.com/davecgh/go-spew/spew" "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/tools/record" - apiservice "k8s.io/kubernetes/pkg/api/service" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/apis/core/helper" + apiservice "k8s.io/kubernetes/pkg/api/v1/service" + "k8s.io/kubernetes/pkg/apis/core/v1/helper" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/proxy/healthcheck" "k8s.io/kubernetes/pkg/util/async" @@ -86,11 +86,11 @@ type loadBalancerIngressInfo struct { type serviceInfo struct { clusterIP net.IP port int - protocol api.Protocol + protocol v1.Protocol nodePort int targetPort int - loadBalancerStatus api.LoadBalancerStatus - sessionAffinityType api.ServiceAffinity + loadBalancerStatus v1.LoadBalancerStatus + sessionAffinityType v1.ServiceAffinity stickyMaxAgeSeconds int externalIPs []*externalIPInfo loadBalancerIngressIPs []*loadBalancerIngressInfo @@ -156,7 +156,7 @@ func (ep *endpointsInfo) Cleanup() { } // returns a new serviceInfo struct -func newServiceInfo(svcPortName proxy.ServicePortName, port *api.ServicePort, service *api.Service) *serviceInfo { +func newServiceInfo(svcPortName proxy.ServicePortName, port *v1.ServicePort, service *v1.Service) *serviceInfo { onlyNodeLocalEndpoints := false if apiservice.RequestsOnlyLocalTraffic(service) { onlyNodeLocalEndpoints = true @@ -164,7 +164,7 @@ func newServiceInfo(svcPortName proxy.ServicePortName, port *api.ServicePort, se // set default session sticky max age 180min=10800s stickyMaxAgeSeconds := 10800 - if service.Spec.SessionAffinity == api.ServiceAffinityClientIP { + if service.Spec.SessionAffinity == v1.ServiceAffinityClientIP { // Kube-apiserver side guarantees SessionAffinityConfig won't be nil when session affinity type is ClientIP stickyMaxAgeSeconds = int(*service.Spec.SessionAffinityConfig.ClientIP.TimeoutSeconds) } @@ -243,7 +243,7 @@ func newEndpointsChangeMap(hostname string) endpointsChangeMap { } } -func (ecm *endpointsChangeMap) update(namespacedName *types.NamespacedName, previous, current *api.Endpoints) bool { +func (ecm *endpointsChangeMap) update(namespacedName *types.NamespacedName, previous, current *v1.Endpoints) bool { ecm.lock.Lock() defer ecm.lock.Unlock() @@ -266,7 +266,7 @@ func newServiceChangeMap() serviceChangeMap { } } -func (scm *serviceChangeMap) update(namespacedName *types.NamespacedName, previous, current *api.Service) bool { +func (scm *serviceChangeMap) update(namespacedName *types.NamespacedName, previous, current *v1.Service) bool { scm.lock.Lock() defer scm.lock.Unlock() @@ -309,7 +309,7 @@ func (sm *proxyServiceMap) unmerge(other proxyServiceMap, existingPorts, staleSe info, exists := (*sm)[svcPortName] if exists { glog.V(1).Infof("Removing service port %q", svcPortName) - if info.protocol == api.ProtocolUDP { + if info.protocol == v1.ProtocolUDP { staleServices.Insert(info.clusterIP.String()) } info.cleanupAllPolicies(curEndpoints[svcPortName]) @@ -421,11 +421,11 @@ func (lp *localPort) String() string { return fmt.Sprintf("%q (%s:%d/%s)", lp.desc, lp.ip, lp.port, lp.protocol) } -func Enum(p api.Protocol) uint16 { - if p == api.ProtocolTCP { +func Enum(p v1.Protocol) uint16 { + if p == v1.ProtocolTCP { return 6 } - if p == api.ProtocolUDP { + if p == v1.ProtocolUDP { return 17 } return 0 @@ -697,21 +697,21 @@ func (proxier *Proxier) isInitialized() bool { return atomic.LoadInt32(&proxier.initialized) > 0 } -func (proxier *Proxier) OnServiceAdd(service *api.Service) { +func (proxier *Proxier) OnServiceAdd(service *v1.Service) { namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} if proxier.serviceChanges.update(&namespacedName, nil, service) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnServiceUpdate(oldService, service *api.Service) { +func (proxier *Proxier) OnServiceUpdate(oldService, service *v1.Service) { namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} if proxier.serviceChanges.update(&namespacedName, oldService, service) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnServiceDelete(service *api.Service) { +func (proxier *Proxier) OnServiceDelete(service *v1.Service) { namespacedName := types.NamespacedName{Namespace: service.Namespace, Name: service.Name} if proxier.serviceChanges.update(&namespacedName, service, nil) && proxier.isInitialized() { proxier.syncRunner.Run() @@ -728,14 +728,14 @@ func (proxier *Proxier) OnServiceSynced() { proxier.syncProxyRules() } -func shouldSkipService(svcName types.NamespacedName, service *api.Service) bool { +func shouldSkipService(svcName types.NamespacedName, service *v1.Service) bool { // if ClusterIP is "None" or empty, skip proxying if !helper.IsServiceIPSet(service) { glog.V(3).Infof("Skipping service %s due to clusterIP = %q", svcName, service.Spec.ClusterIP) return true } // Even if ClusterIP is set, ServiceTypeExternalName services don't get proxied - if service.Spec.Type == api.ServiceTypeExternalName { + if service.Spec.Type == v1.ServiceTypeExternalName { glog.V(3).Infof("Skipping service %s due to Type=ExternalName", svcName) return true } @@ -772,21 +772,21 @@ func (proxier *Proxier) updateServiceMap() (result updateServiceMapResult) { return result } -func (proxier *Proxier) OnEndpointsAdd(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsAdd(endpoints *v1.Endpoints) { namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} if proxier.endpointsChanges.update(&namespacedName, nil, endpoints) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} if proxier.endpointsChanges.update(&namespacedName, oldEndpoints, endpoints) && proxier.isInitialized() { proxier.syncRunner.Run() } } -func (proxier *Proxier) OnEndpointsDelete(endpoints *api.Endpoints) { +func (proxier *Proxier) OnEndpointsDelete(endpoints *v1.Endpoints) { namespacedName := types.NamespacedName{Namespace: endpoints.Namespace, Name: endpoints.Name} if proxier.endpointsChanges.update(&namespacedName, endpoints, nil) && proxier.isInitialized() { proxier.syncRunner.Run() @@ -852,7 +852,7 @@ func getLocalIPs(endpointsMap proxyEndpointsMap) map[types.NamespacedName]sets.S // This function is used for incremental updated of endpointsMap. // // NOTE: endpoints object should NOT be modified. -func endpointsToEndpointsMap(endpoints *api.Endpoints, hostname string) proxyEndpointsMap { +func endpointsToEndpointsMap(endpoints *v1.Endpoints, hostname string) proxyEndpointsMap { if endpoints == nil { return nil } @@ -897,7 +897,7 @@ func endpointsToEndpointsMap(endpoints *api.Endpoints, hostname string) proxyEnd // Translates single Service object to proxyServiceMap. // // NOTE: service object should NOT be modified. -func serviceToServiceMap(service *api.Service) proxyServiceMap { +func serviceToServiceMap(service *v1.Service) proxyServiceMap { if service == nil { return nil } @@ -941,7 +941,7 @@ func (proxier *Proxier) syncProxyRules() { staleServices := serviceUpdateResult.staleServices // merge stale services gathered from updateEndpointsMap for svcPortName := range endpointUpdateResult.staleServiceNames { - if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.protocol == api.ProtocolUDP { + if svcInfo, ok := proxier.serviceMap[svcPortName]; ok && svcInfo != nil && svcInfo.protocol == v1.ProtocolUDP { glog.V(2).Infof("Stale udp service %v -> %s", svcPortName, svcInfo.clusterIP.String()) staleServices.Insert(svcInfo.clusterIP.String()) } diff --git a/pkg/proxy/winuserspace/loadbalancer.go b/pkg/proxy/winuserspace/loadbalancer.go index eb0dc2dbf6..e7cb770e93 100644 --- a/pkg/proxy/winuserspace/loadbalancer.go +++ b/pkg/proxy/winuserspace/loadbalancer.go @@ -17,7 +17,7 @@ limitations under the License. package winuserspace import ( - api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/api/core/v1" "k8s.io/kubernetes/pkg/proxy" "net" ) @@ -27,7 +27,7 @@ type LoadBalancer interface { // NextEndpoint returns the endpoint to handle a request for the given // service-port and source address. NextEndpoint(service proxy.ServicePortName, srcAddr net.Addr, sessionAffinityReset bool) (string, error) - NewService(service proxy.ServicePortName, sessionAffinityType api.ServiceAffinity, stickyMaxAgeMinutes int) error + NewService(service proxy.ServicePortName, sessionAffinityType v1.ServiceAffinity, stickyMaxAgeMinutes int) error DeleteService(service proxy.ServicePortName) CleanupStaleStickySessions(service proxy.ServicePortName) } diff --git a/pkg/proxy/winuserspace/proxier.go b/pkg/proxy/winuserspace/proxier.go index a94503ed01..9770451e7b 100644 --- a/pkg/proxy/winuserspace/proxier.go +++ b/pkg/proxy/winuserspace/proxier.go @@ -27,11 +27,11 @@ import ( "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" utilnet "k8s.io/apimachinery/pkg/util/net" "k8s.io/apimachinery/pkg/util/runtime" - api "k8s.io/kubernetes/pkg/apis/core" - "k8s.io/kubernetes/pkg/apis/core/helper" + "k8s.io/kubernetes/pkg/apis/core/v1/helper" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/util/netsh" ) @@ -47,12 +47,12 @@ type portal struct { type serviceInfo struct { isAliveAtomic int32 // Only access this with atomic ops portal portal - protocol api.Protocol + protocol v1.Protocol socket proxySocket timeout time.Duration activeClients *clientCache dnsClients *dnsClientCache - sessionAffinityType api.ServiceAffinity + sessionAffinityType v1.ServiceAffinity } func (info *serviceInfo) setAlive(b bool) { @@ -100,7 +100,7 @@ var _ proxy.ProxyProvider = &Proxier{} type portMapKey struct { ip string port int - protocol api.Protocol + protocol v1.Protocol } func (k *portMapKey) String() string { @@ -223,7 +223,7 @@ func (proxier *Proxier) setServiceInfo(service ServicePortPortalName, info *serv // addServicePortPortal starts listening for a new service, returning the serviceInfo. // The timeout only applies to UDP connections, for now. -func (proxier *Proxier) addServicePortPortal(servicePortPortalName ServicePortPortalName, protocol api.Protocol, listenIP string, port int, timeout time.Duration) (*serviceInfo, error) { +func (proxier *Proxier) addServicePortPortal(servicePortPortalName ServicePortPortalName, protocol v1.Protocol, listenIP string, port int, timeout time.Duration) (*serviceInfo, error) { var serviceIP net.IP if listenIP != allAvailableInterfaces { if serviceIP = net.ParseIP(listenIP); serviceIP == nil { @@ -255,7 +255,7 @@ func (proxier *Proxier) addServicePortPortal(servicePortPortalName ServicePortPo timeout: timeout, activeClients: newClientCache(), dnsClients: newDNSClientCache(), - sessionAffinityType: api.ServiceAffinityNone, // default + sessionAffinityType: v1.ServiceAffinityNone, // default } proxier.setServiceInfo(servicePortPortalName, si) @@ -288,7 +288,7 @@ func (proxier *Proxier) closeServicePortPortal(servicePortPortalName ServicePort } // getListenIPPortMap returns a slice of all listen IPs for a service. -func getListenIPPortMap(service *api.Service, listenPort int, nodePort int) map[string]int { +func getListenIPPortMap(service *v1.Service, listenPort int, nodePort int) map[string]int { listenIPPortMap := make(map[string]int) listenIPPortMap[service.Spec.ClusterIP] = listenPort @@ -307,7 +307,7 @@ func getListenIPPortMap(service *api.Service, listenPort int, nodePort int) map[ return listenIPPortMap } -func (proxier *Proxier) mergeService(service *api.Service) map[ServicePortPortalName]bool { +func (proxier *Proxier) mergeService(service *v1.Service) map[ServicePortPortalName]bool { if service == nil { return nil } @@ -361,7 +361,7 @@ func (proxier *Proxier) mergeService(service *api.Service) map[ServicePortPortal Port: servicePort.Name, } timeoutSeconds := 0 - if service.Spec.SessionAffinity == api.ServiceAffinityClientIP { + if service.Spec.SessionAffinity == v1.ServiceAffinityClientIP { timeoutSeconds = int(*service.Spec.SessionAffinityConfig.ClientIP.TimeoutSeconds) } proxier.loadBalancer.NewService(servicePortName, service.Spec.SessionAffinity, timeoutSeconds) @@ -371,7 +371,7 @@ func (proxier *Proxier) mergeService(service *api.Service) map[ServicePortPortal return existingPortPortals } -func (proxier *Proxier) unmergeService(service *api.Service, existingPortPortals map[ServicePortPortalName]bool) { +func (proxier *Proxier) unmergeService(service *v1.Service, existingPortPortals map[ServicePortPortalName]bool) { if service == nil { return } @@ -428,23 +428,23 @@ func (proxier *Proxier) unmergeService(service *api.Service, existingPortPortals } } -func (proxier *Proxier) OnServiceAdd(service *api.Service) { +func (proxier *Proxier) OnServiceAdd(service *v1.Service) { _ = proxier.mergeService(service) } -func (proxier *Proxier) OnServiceUpdate(oldService, service *api.Service) { +func (proxier *Proxier) OnServiceUpdate(oldService, service *v1.Service) { existingPortPortals := proxier.mergeService(service) proxier.unmergeService(oldService, existingPortPortals) } -func (proxier *Proxier) OnServiceDelete(service *api.Service) { +func (proxier *Proxier) OnServiceDelete(service *v1.Service) { proxier.unmergeService(service, map[ServicePortPortalName]bool{}) } func (proxier *Proxier) OnServiceSynced() { } -func sameConfig(info *serviceInfo, service *api.Service, protocol api.Protocol, listenPort int) bool { +func sameConfig(info *serviceInfo, service *v1.Service, protocol v1.Protocol, listenPort int) bool { return info.protocol == protocol && info.portal.port == listenPort && info.sessionAffinityType == service.Spec.SessionAffinity } diff --git a/pkg/proxy/winuserspace/proxier_test.go b/pkg/proxy/winuserspace/proxier_test.go index 587d4e3bfe..eab4c56bb8 100644 --- a/pkg/proxy/winuserspace/proxier_test.go +++ b/pkg/proxy/winuserspace/proxier_test.go @@ -29,10 +29,10 @@ import ( "testing" "time" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/runtime" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" netshtest "k8s.io/kubernetes/pkg/util/netsh/testing" ) @@ -241,11 +241,11 @@ func getPortNum(t *testing.T, addr string) int { func TestTCPProxy(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -268,11 +268,11 @@ func TestTCPProxy(t *testing.T) { func TestUDPProxy(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -295,11 +295,11 @@ func TestUDPProxy(t *testing.T) { func TestUDPProxyTimeout(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -327,18 +327,18 @@ func TestMultiPortProxy(t *testing.T) { lb := NewLoadBalancerRR() serviceP := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo-p"}, Port: "p"} serviceQ := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo-q"}, Port: "q"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Protocol: "TCP", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Protocol: "TCP", Port: tcpServerPort}}, }}, }) - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceQ.Name, Namespace: serviceQ.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "q", Protocol: "UDP", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "q", Protocol: "UDP", Port: udpServerPort}}, }}, }) @@ -379,9 +379,9 @@ func TestMultiPortOnServiceAdd(t *testing.T) { } waitForNumProxyLoops(t, p, 0) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "0.0.0.0", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "0.0.0.0", Ports: []v1.ServicePort{{ Name: "p", Port: 0, Protocol: "TCP", @@ -430,11 +430,11 @@ func stopProxyByName(proxier *Proxier, service ServicePortPortalName) error { func TestTCPProxyStop(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -474,11 +474,11 @@ func TestTCPProxyStop(t *testing.T) { func TestUDPProxyStop(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -512,11 +512,11 @@ func TestUDPProxyStop(t *testing.T) { func TestTCPProxyUpdateDelete(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -540,9 +540,9 @@ func TestTCPProxyUpdateDelete(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "TCP", @@ -557,11 +557,11 @@ func TestTCPProxyUpdateDelete(t *testing.T) { func TestUDPProxyUpdateDelete(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Namespace: service.Namespace, Name: service.Name}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -584,9 +584,9 @@ func TestUDPProxyUpdateDelete(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "UDP", @@ -601,11 +601,11 @@ func TestUDPProxyUpdateDelete(t *testing.T) { func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -629,9 +629,9 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "TCP", @@ -644,9 +644,9 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { // need to add endpoint here because it got clean up during service delete lb.OnEndpointsAdd(endpoint) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "TCP", @@ -663,11 +663,11 @@ func TestTCPProxyUpdateDeleteUpdate(t *testing.T) { func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -691,9 +691,9 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { conn.Close() waitForNumProxyLoops(t, p, 1) - p.OnServiceDelete(&api.Service{ + p.OnServiceDelete(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "UDP", @@ -706,9 +706,9 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { // need to add endpoint here because it got clean up during service delete lb.OnEndpointsAdd(endpoint) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "UDP", @@ -725,11 +725,11 @@ func TestUDPProxyUpdateDeleteUpdate(t *testing.T) { func TestTCPProxyUpdatePort(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -748,9 +748,9 @@ func TestTCPProxyUpdatePort(t *testing.T) { testEchoTCP(t, "127.0.0.1", getPortNum(t, svcInfo.socket.Addr().String())) waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: 0, Protocol: "TCP", @@ -773,11 +773,11 @@ func TestTCPProxyUpdatePort(t *testing.T) { func TestUDPProxyUpdatePort(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: udpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: udpServerPort}}, }}, }) @@ -795,9 +795,9 @@ func TestUDPProxyUpdatePort(t *testing.T) { } waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: 0, Protocol: "UDP", @@ -818,11 +818,11 @@ func TestUDPProxyUpdatePort(t *testing.T) { func TestProxyUpdatePublicIPs(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - lb.OnEndpointsAdd(&api.Endpoints{ + lb.OnEndpointsAdd(&v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, }) @@ -841,10 +841,10 @@ func TestProxyUpdatePublicIPs(t *testing.T) { testEchoTCP(t, "127.0.0.1", getPortNum(t, svcInfo.socket.Addr().String())) waitForNumProxyLoops(t, p, 1) - p.OnServiceAdd(&api.Service{ + p.OnServiceAdd(&v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ - Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ + Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.portal.port), Protocol: "TCP", @@ -870,11 +870,11 @@ func TestProxyUpdatePublicIPs(t *testing.T) { func TestProxyUpdatePortal(t *testing.T) { lb := NewLoadBalancerRR() service := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "echo"}, Port: "p"} - endpoint := &api.Endpoints{ + endpoint := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: tcpServerPort}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "127.0.0.1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: tcpServerPort}}, }}, } lb.OnEndpointsAdd(endpoint) @@ -894,18 +894,18 @@ func TestProxyUpdatePortal(t *testing.T) { testEchoTCP(t, "127.0.0.1", getPortNum(t, svcInfo.socket.Addr().String())) waitForNumProxyLoops(t, p, 1) - svcv0 := &api.Service{ + svcv0 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.portal.port), Protocol: "TCP", }}}, } - svcv1 := &api.Service{ + svcv1 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "", Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.portal.port), Protocol: "TCP", @@ -918,9 +918,9 @@ func TestProxyUpdatePortal(t *testing.T) { t.Fatalf("service with empty ClusterIP should not be included in the proxy") } - svcv2 := &api.Service{ + svcv2 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: "None", Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: "None", Ports: []v1.ServicePort{{ Name: "p", Port: int32(getPortNum(t, svcInfo.socket.Addr().String())), Protocol: "TCP", @@ -932,9 +932,9 @@ func TestProxyUpdatePortal(t *testing.T) { t.Fatalf("service with 'None' as ClusterIP should not be included in the proxy") } - svcv3 := &api.Service{ + svcv3 := &v1.Service{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Spec: api.ServiceSpec{ClusterIP: listenIP, Ports: []api.ServicePort{{ + Spec: v1.ServiceSpec{ClusterIP: listenIP, Ports: []v1.ServicePort{{ Name: "p", Port: int32(svcInfo.portal.port), Protocol: "TCP", diff --git a/pkg/proxy/winuserspace/proxysocket.go b/pkg/proxy/winuserspace/proxysocket.go index 85823b737e..a000f27f5e 100644 --- a/pkg/proxy/winuserspace/proxysocket.go +++ b/pkg/proxy/winuserspace/proxysocket.go @@ -28,9 +28,9 @@ import ( "github.com/golang/glog" "github.com/miekg/dns" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/runtime" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/util/ipconfig" "k8s.io/utils/exec" @@ -78,7 +78,7 @@ type proxySocket interface { ListenPort() int } -func newProxySocket(protocol api.Protocol, ip net.IP, port int) (proxySocket, error) { +func newProxySocket(protocol v1.Protocol, ip net.IP, port int) (proxySocket, error) { host := "" if ip != nil { host = ip.String() diff --git a/pkg/proxy/winuserspace/roundrobin.go b/pkg/proxy/winuserspace/roundrobin.go index 161d616ab5..d3135a038a 100644 --- a/pkg/proxy/winuserspace/roundrobin.go +++ b/pkg/proxy/winuserspace/roundrobin.go @@ -26,8 +26,8 @@ import ( "time" "github.com/golang/glog" + "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" "k8s.io/kubernetes/pkg/util/slice" ) @@ -46,7 +46,7 @@ type affinityState struct { } type affinityPolicy struct { - affinityType api.ServiceAffinity + affinityType v1.ServiceAffinity affinityMap map[string]*affinityState // map client IP -> affinity info ttlSeconds int } @@ -66,7 +66,7 @@ type balancerState struct { affinity affinityPolicy } -func newAffinityPolicy(affinityType api.ServiceAffinity, ttlSeconds int) *affinityPolicy { +func newAffinityPolicy(affinityType v1.ServiceAffinity, ttlSeconds int) *affinityPolicy { return &affinityPolicy{ affinityType: affinityType, affinityMap: make(map[string]*affinityState), @@ -81,7 +81,7 @@ func NewLoadBalancerRR() *LoadBalancerRR { } } -func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ttlSeconds int) error { +func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType v1.ServiceAffinity, ttlSeconds int) error { glog.V(4).Infof("LoadBalancerRR NewService %q", svcPort) lb.lock.Lock() defer lb.lock.Unlock() @@ -90,9 +90,9 @@ func (lb *LoadBalancerRR) NewService(svcPort proxy.ServicePortName, affinityType } // This assumes that lb.lock is already held. -func (lb *LoadBalancerRR) newServiceInternal(svcPort proxy.ServicePortName, affinityType api.ServiceAffinity, ttlSeconds int) *balancerState { +func (lb *LoadBalancerRR) newServiceInternal(svcPort proxy.ServicePortName, affinityType v1.ServiceAffinity, ttlSeconds int) *balancerState { if ttlSeconds == 0 { - ttlSeconds = int(api.DefaultClientIPServiceAffinitySeconds) //default to 3 hours if not specified. Should 0 be unlimited instead???? + ttlSeconds = int(v1.DefaultClientIPServiceAffinitySeconds) //default to 3 hours if not specified. Should 0 be unlimited instead???? } if _, exists := lb.services[svcPort]; !exists { @@ -114,7 +114,7 @@ func (lb *LoadBalancerRR) DeleteService(svcPort proxy.ServicePortName) { // return true if this service is using some form of session affinity. func isSessionAffinity(affinity *affinityPolicy) bool { // Should never be empty string, but checking for it to be safe. - if affinity.affinityType == "" || affinity.affinityType == api.ServiceAffinityNone { + if affinity.affinityType == "" || affinity.affinityType == v1.ServiceAffinityNone { return false } return true @@ -235,7 +235,7 @@ func (lb *LoadBalancerRR) updateAffinityMap(svcPort proxy.ServicePortName, newEn // buildPortsToEndpointsMap builds a map of portname -> all ip:ports for that // portname. Explode Endpoints.Subsets[*] into this structure. -func buildPortsToEndpointsMap(endpoints *api.Endpoints) map[string][]hostPortPair { +func buildPortsToEndpointsMap(endpoints *v1.Endpoints) map[string][]hostPortPair { portsToEndpoints := map[string][]hostPortPair{} for i := range endpoints.Subsets { ss := &endpoints.Subsets[i] @@ -251,7 +251,7 @@ func buildPortsToEndpointsMap(endpoints *api.Endpoints) map[string][]hostPortPai return portsToEndpoints } -func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) lb.lock.Lock() @@ -269,7 +269,7 @@ func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { // To be safe we will call it here. A new service will only be created // if one does not already exist. The affinity will be updated // later, once NewService is called. - state = lb.newServiceInternal(svcPort, api.ServiceAffinity(""), 0) + state = lb.newServiceInternal(svcPort, v1.ServiceAffinity(""), 0) state.endpoints = slice.ShuffleStrings(newEndpoints) // Reset the round-robin index. @@ -278,7 +278,7 @@ func (lb *LoadBalancerRR) OnEndpointsAdd(endpoints *api.Endpoints) { } } -func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) oldPortsToEndpoints := buildPortsToEndpointsMap(oldEndpoints) registeredEndpoints := make(map[proxy.ServicePortName]bool) @@ -303,7 +303,7 @@ func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoin // To be safe we will call it here. A new service will only be created // if one does not already exist. The affinity will be updated // later, once NewService is called. - state = lb.newServiceInternal(svcPort, api.ServiceAffinity(""), 0) + state = lb.newServiceInternal(svcPort, v1.ServiceAffinity(""), 0) state.endpoints = slice.ShuffleStrings(newEndpoints) // Reset the round-robin index. @@ -325,7 +325,7 @@ func (lb *LoadBalancerRR) OnEndpointsUpdate(oldEndpoints, endpoints *api.Endpoin } } -func (lb *LoadBalancerRR) OnEndpointsDelete(endpoints *api.Endpoints) { +func (lb *LoadBalancerRR) OnEndpointsDelete(endpoints *v1.Endpoints) { portsToEndpoints := buildPortsToEndpointsMap(endpoints) lb.lock.Lock() diff --git a/pkg/proxy/winuserspace/roundrobin_test.go b/pkg/proxy/winuserspace/roundrobin_test.go index c0dce2b512..c002ecf34d 100644 --- a/pkg/proxy/winuserspace/roundrobin_test.go +++ b/pkg/proxy/winuserspace/roundrobin_test.go @@ -20,9 +20,9 @@ import ( "net" "testing" + "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" - api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/proxy" ) @@ -104,11 +104,11 @@ func TestLoadBalanceWorksWithSingleEndpoint(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 40}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 40}}, }}, } loadBalancer.OnEndpointsAdd(endpoints) @@ -141,11 +141,11 @@ func TestLoadBalanceWorksWithMultipleEndpoints(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{{ - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "p", Port: 2}, {Name: "p", Port: 3}}, + Subsets: []v1.EndpointSubset{{ + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "p", Port: 2}, {Name: "p", Port: 3}}, }}, } loadBalancer.OnEndpointsAdd(endpoints) @@ -168,16 +168,16 @@ func TestLoadBalanceWorksWithMultipleEndpointsMultiplePorts(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 2}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 2}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 4}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 4}}, }, }, } @@ -210,20 +210,20 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpointsv1 := &api.Endpoints{ + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 10}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 1}, {Name: "q", Port: 10}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 2}, {Name: "q", Port: 20}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 2}, {Name: "q", Port: 20}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 30}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 3}, {Name: "q", Port: 30}}, }, }, } @@ -249,16 +249,16 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { // Then update the configuration with one fewer endpoints, make sure // we start in the beginning again - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint4"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 4}, {Name: "q", Port: 40}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint4"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 4}, {Name: "q", Port: 40}}, }, { - Addresses: []api.EndpointAddress{{IP: "endpoint5"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 5}, {Name: "q", Port: 50}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint5"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 5}, {Name: "q", Port: 50}}, }, }, } @@ -283,7 +283,7 @@ func TestLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, serviceQ, shuffledEndpoints[1], nil) // Clear endpoints - endpointsv3 := &api.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, Subsets: nil} + endpointsv3 := &v1.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: serviceP.Name, Namespace: serviceP.Namespace}, Subsets: nil} loadBalancer.OnEndpointsUpdate(endpointsv2, endpointsv3) endpoint, err = loadBalancer.NextEndpoint(serviceP, nil, false) @@ -300,21 +300,21 @@ func TestLoadBalanceWorksWithServiceRemoval(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - endpoints1 := &api.Endpoints{ + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: fooServiceP.Name, Namespace: fooServiceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}, {IP: "endpoint3"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 123}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint1"}, {IP: "endpoint2"}, {IP: "endpoint3"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 123}}, }, }, } - endpoints2 := &api.Endpoints{ + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: barServiceP.Name, Namespace: barServiceP.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint4"}, {IP: "endpoint5"}, {IP: "endpoint6"}}, - Ports: []api.EndpointPort{{Name: "p", Port: 456}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint4"}, {IP: "endpoint5"}, {IP: "endpoint6"}}, + Ports: []v1.EndpointPort{{Name: "p", Port: 456}}, }, }, } @@ -357,13 +357,13 @@ func TestStickyLoadBalanceWorksWithNewServiceCalledFirst(t *testing.T) { } // Call NewService() before OnEndpointsUpdate() - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, Ports: []api.EndpointPort{{Port: 3}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, Ports: []v1.EndpointPort{{Port: 3}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) @@ -413,15 +413,15 @@ func TestStickyLoadBalanceWorksWithNewServiceCalledSecond(t *testing.T) { } // Call OnEndpointsUpdate() before NewService() - endpoints := &api.Endpoints{ + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) client1 := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0} client2 := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 2), Port: 0} @@ -473,13 +473,13 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpointsv1 := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } @@ -494,12 +494,12 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[2], client3) client3Endpoint := shuffledEndpoints[2] - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}}, }, }, } @@ -516,12 +516,12 @@ func TestStickyLoadBalanaceWorksWithMultipleEndpointsRemoveOne(t *testing.T) { expectEndpoint(t, loadBalancer, service, client2Endpoint, client2) expectEndpoint(t, loadBalancer, service, client3Endpoint, client3) - endpointsv3 := &api.Endpoints{ + endpointsv3 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 4}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 4}}, }, }, } @@ -546,13 +546,13 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpointsv1 := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpointsv1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } @@ -567,12 +567,12 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[1], client2) // Then update the configuration with one fewer endpoints, make sure // we start in the beginning again - endpointsv2 := &api.Endpoints{ + endpointsv2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 4}, {Port: 5}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 4}, {Port: 5}}, }, }, } @@ -586,7 +586,7 @@ func TestStickyLoadBalanceWorksWithMultipleEndpointsAndUpdates(t *testing.T) { expectEndpoint(t, loadBalancer, service, shuffledEndpoints[1], client2) // Clear endpoints - endpointsv3 := &api.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, Subsets: nil} + endpointsv3 := &v1.Endpoints{ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, Subsets: nil} loadBalancer.OnEndpointsUpdate(endpointsv2, endpointsv3) endpoint, err = loadBalancer.NextEndpoint(service, nil, false) @@ -605,24 +605,24 @@ func TestStickyLoadBalanceWorksWithServiceRemoval(t *testing.T) { if err == nil || len(endpoint) != 0 { t.Errorf("Didn't fail with non-existent service") } - loadBalancer.NewService(fooService, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints1 := &api.Endpoints{ + loadBalancer.NewService(fooService, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints1 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: fooService.Name, Namespace: fooService.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 1}, {Port: 2}, {Port: 3}}, }, }, } barService := proxy.ServicePortName{NamespacedName: types.NamespacedName{Namespace: "testnamespace", Name: "bar"}, Port: ""} - loadBalancer.NewService(barService, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints2 := &api.Endpoints{ + loadBalancer.NewService(barService, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints2 := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: barService.Name, Namespace: barService.Namespace}, - Subsets: []api.EndpointSubset{ + Subsets: []v1.EndpointSubset{ { - Addresses: []api.EndpointAddress{{IP: "endpoint"}}, - Ports: []api.EndpointPort{{Port: 4}, {Port: 5}}, + Addresses: []v1.EndpointAddress{{IP: "endpoint"}}, + Ports: []v1.EndpointPort{{Port: 4}, {Port: 5}}, }, }, } @@ -674,13 +674,13 @@ func TestStickyLoadBalanceWorksWithEndpointFails(t *testing.T) { } // Call NewService() before OnEndpointsUpdate() - loadBalancer.NewService(service, api.ServiceAffinityClientIP, int(api.DefaultClientIPServiceAffinitySeconds)) - endpoints := &api.Endpoints{ + loadBalancer.NewService(service, v1.ServiceAffinityClientIP, int(v1.DefaultClientIPServiceAffinitySeconds)) + endpoints := &v1.Endpoints{ ObjectMeta: metav1.ObjectMeta{Name: service.Name, Namespace: service.Namespace}, - Subsets: []api.EndpointSubset{ - {Addresses: []api.EndpointAddress{{IP: "endpoint1"}}, Ports: []api.EndpointPort{{Port: 1}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint2"}}, Ports: []api.EndpointPort{{Port: 2}}}, - {Addresses: []api.EndpointAddress{{IP: "endpoint3"}}, Ports: []api.EndpointPort{{Port: 3}}}, + Subsets: []v1.EndpointSubset{ + {Addresses: []v1.EndpointAddress{{IP: "endpoint1"}}, Ports: []v1.EndpointPort{{Port: 1}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint2"}}, Ports: []v1.EndpointPort{{Port: 2}}}, + {Addresses: []v1.EndpointAddress{{IP: "endpoint3"}}, Ports: []v1.EndpointPort{{Port: 3}}}, }, } loadBalancer.OnEndpointsAdd(endpoints) diff --git a/pkg/util/node/node.go b/pkg/util/node/node.go index 6cb93566e2..ddb29aac2b 100644 --- a/pkg/util/node/node.go +++ b/pkg/util/node/node.go @@ -30,7 +30,6 @@ import ( "k8s.io/apimachinery/pkg/util/strategicpatch" clientset "k8s.io/client-go/kubernetes" v1core "k8s.io/client-go/kubernetes/typed/core/v1" - api "k8s.io/kubernetes/pkg/apis/core" kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis" ) @@ -92,24 +91,6 @@ func GetNodeHostIP(node *v1.Node) (net.IP, error) { return nil, fmt.Errorf("host IP unknown; known addresses: %v", addresses) } -// InternalGetNodeHostIP returns the provided node's IP, based on the priority: -// 1. NodeInternalIP -// 2. NodeExternalIP -func InternalGetNodeHostIP(node *api.Node) (net.IP, error) { - addresses := node.Status.Addresses - addressMap := make(map[api.NodeAddressType][]api.NodeAddress) - for i := range addresses { - addressMap[addresses[i].Type] = append(addressMap[addresses[i].Type], addresses[i]) - } - if addresses, ok := addressMap[api.NodeInternalIP]; ok { - return net.ParseIP(addresses[0].Address), nil - } - if addresses, ok := addressMap[api.NodeExternalIP]; ok { - return net.ParseIP(addresses[0].Address), nil - } - return nil, fmt.Errorf("host IP unknown; known addresses: %v", addresses) -} - // GetZoneKey is a helper function that builds a string identifier that is unique per failure-zone; // it returns empty-string for no zone. func GetZoneKey(node *v1.Node) string {