Merge pull request #43295 from wojtek-t/remove_muxer_from_kube_proxy

cmd/kube-proxy/app/server.go

@@ -305,18 +305,13 @@ func NewProxyServerDefault(config *options.ProxyServerConfig) (*ProxyServer, err
 	// 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 := proxyconfig.NewServiceConfig()
+	serviceConfig := proxyconfig.NewServiceConfig(client.Core().RESTClient(), config.ConfigSyncPeriod)
 	serviceConfig.RegisterHandler(proxier)
+	go serviceConfig.Run(wait.NeverStop)
 
-	endpointsConfig := proxyconfig.NewEndpointsConfig()
+	endpointsConfig := proxyconfig.NewEndpointsConfig(client.Core().RESTClient(), config.ConfigSyncPeriod)
 	endpointsConfig.RegisterHandler(endpointsHandler)
-
-	proxyconfig.NewSourceAPI(
-		client.Core().RESTClient(),
-		config.ConfigSyncPeriod,
-		serviceConfig.Channel("api"),
-		endpointsConfig.Channel("api"),
-	)
+	go endpointsConfig.Run(wait.NeverStop)
 
 	config.NodeRef = &clientv1.ObjectReference{
 		Kind:      "Node",

cmd/kubemark/hollow-node.go

@@ -18,6 +18,7 @@ package main
 
 import (
 	"fmt"
+	"time"
 
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apiserver/pkg/util/flag"
@@ -135,10 +136,10 @@ func main() {
 
 		iptInterface := fakeiptables.NewFake()
 
-		serviceConfig := proxyconfig.NewServiceConfig()
+		serviceConfig := proxyconfig.NewServiceConfig(internalClientset.Core().RESTClient(), 15*time.Minute)
 		serviceConfig.RegisterHandler(&kubemark.FakeProxyHandler{})
 
-		endpointsConfig := proxyconfig.NewEndpointsConfig()
+		endpointsConfig := proxyconfig.NewEndpointsConfig(internalClientset.Core().RESTClient(), 15*time.Minute)
 		endpointsConfig.RegisterHandler(&kubemark.FakeProxyHandler{})
 
 		eventClient, err := clientgoclientset.NewForConfig(clientConfig)

pkg/kubemark/BUILD

@@ -41,6 +41,7 @@ go_library(
         "//vendor:github.com/golang/glog",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/types",
+        "//vendor:k8s.io/apimachinery/pkg/util/wait",
         "//vendor:k8s.io/client-go/kubernetes/typed/core/v1",
         "//vendor:k8s.io/client-go/pkg/api/v1",
         "//vendor:k8s.io/client-go/tools/record",

pkg/kubemark/hollow_proxy.go

@@ -17,9 +17,8 @@ limitations under the License.
 package kubemark
 
 import (
-	"time"
-
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
 	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
 	clientv1 "k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/tools/record"
@@ -71,12 +70,9 @@ func NewHollowProxyOrDie(
 		UID:       types.UID(nodeName),
 		Namespace: "",
 	}
-	proxyconfig.NewSourceAPI(
-		client.Core().RESTClient(),
-		15*time.Minute,
-		serviceConfig.Channel("api"),
-		endpointsConfig.Channel("api"),
-	)
+
+	go endpointsConfig.Run(wait.NeverStop)
+	go serviceConfig.Run(wait.NeverStop)
 
 	hollowProxy, err := proxyapp.NewProxyServer(client, eventClient, config, iptInterface, &FakeProxier{}, broadcaster, recorder, nil, "fake")
 	if err != nil {

pkg/proxy/config/BUILD

@@ -11,21 +11,19 @@ load(
 go_library(
     name = "go_default_library",
     srcs = [
-        "api.go",
         "config.go",
         "doc.go",
     ],
     tags = ["automanaged"],
     deps = [
         "//pkg/api:go_default_library",
+        "//pkg/client/listers/core/internalversion:go_default_library",
         "//pkg/util/config:go_default_library",
-        "//vendor:github.com/davecgh/go-spew/spew",
         "//vendor:github.com/golang/glog",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/fields",
-        "//vendor:k8s.io/apimachinery/pkg/types",
+        "//vendor:k8s.io/apimachinery/pkg/labels",
         "//vendor:k8s.io/apimachinery/pkg/util/runtime",
-        "//vendor:k8s.io/apimachinery/pkg/util/wait",
         "//vendor:k8s.io/client-go/tools/cache",
     ],
 )
@@ -40,7 +38,6 @@ go_test(
     tags = ["automanaged"],
     deps = [
         "//pkg/api:go_default_library",
-        "//vendor:k8s.io/apimachinery/pkg/api/equality",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/runtime",
         "//vendor:k8s.io/apimachinery/pkg/util/wait",

pkg/proxy/config/api.go

-/*
-Copyright 2014 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package config
-
-import (
-	"fmt"
-	"time"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/fields"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/apimachinery/pkg/util/wait"
-	"k8s.io/client-go/tools/cache"
-	"k8s.io/kubernetes/pkg/api"
-)
-
-// NewSourceAPI creates config source that watches for changes to the services and endpoints.
-func NewSourceAPI(c cache.Getter, period time.Duration, servicesChan chan<- ServiceUpdate, endpointsChan chan<- EndpointsUpdate) {
-	servicesLW := cache.NewListWatchFromClient(c, "services", metav1.NamespaceAll, fields.Everything())
-	endpointsLW := cache.NewListWatchFromClient(c, "endpoints", metav1.NamespaceAll, fields.Everything())
-	newSourceAPI(servicesLW, endpointsLW, period, servicesChan, endpointsChan, wait.NeverStop)
-}
-
-func newSourceAPI(
-	servicesLW cache.ListerWatcher,
-	endpointsLW cache.ListerWatcher,
-	period time.Duration,
-	servicesChan chan<- ServiceUpdate,
-	endpointsChan chan<- EndpointsUpdate,
-	stopCh <-chan struct{}) {
-	serviceController := NewServiceController(servicesLW, period, servicesChan)
-	go serviceController.Run(stopCh)
-
-	endpointsController := NewEndpointsController(endpointsLW, period, endpointsChan)
-	go endpointsController.Run(stopCh)
-
-	if !cache.WaitForCacheSync(stopCh, serviceController.HasSynced, endpointsController.HasSynced) {
-		utilruntime.HandleError(fmt.Errorf("source controllers not synced"))
-		return
-	}
-	servicesChan <- ServiceUpdate{Op: SYNCED}
-	endpointsChan <- EndpointsUpdate{Op: SYNCED}
-}
-
-func sendAddService(servicesChan chan<- ServiceUpdate) func(obj interface{}) {
-	return func(obj interface{}) {
-		service, ok := obj.(*api.Service)
-		if !ok {
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Service: %v", obj))
-			return
-		}
-		servicesChan <- ServiceUpdate{Op: ADD, Service: service}
-	}
-}
-
-func sendUpdateService(servicesChan chan<- ServiceUpdate) func(oldObj, newObj interface{}) {
-	return func(_, newObj interface{}) {
-		service, ok := newObj.(*api.Service)
-		if !ok {
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Service: %v", newObj))
-			return
-		}
-		servicesChan <- ServiceUpdate{Op: UPDATE, Service: service}
-	}
-}
-
-func sendDeleteService(servicesChan chan<- ServiceUpdate) func(obj interface{}) {
-	return func(obj interface{}) {
-		var service *api.Service
-		switch t := obj.(type) {
-		case *api.Service:
-			service = t
-		case cache.DeletedFinalStateUnknown:
-			var ok bool
-			service, ok = t.Obj.(*api.Service)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Service: %v", t.Obj))
-				return
-			}
-		default:
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Service: %v", t))
-			return
-		}
-		servicesChan <- ServiceUpdate{Op: REMOVE, Service: service}
-	}
-}
-
-func sendAddEndpoints(endpointsChan chan<- EndpointsUpdate) func(obj interface{}) {
-	return func(obj interface{}) {
-		endpoints, ok := obj.(*api.Endpoints)
-		if !ok {
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Endpoints: %v", obj))
-			return
-		}
-		endpointsChan <- EndpointsUpdate{Op: ADD, Endpoints: endpoints}
-	}
-}
-
-func sendUpdateEndpoints(endpointsChan chan<- EndpointsUpdate) func(oldObj, newObj interface{}) {
-	return func(_, newObj interface{}) {
-		endpoints, ok := newObj.(*api.Endpoints)
-		if !ok {
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Endpoints: %v", newObj))
-			return
-		}
-		endpointsChan <- EndpointsUpdate{Op: UPDATE, Endpoints: endpoints}
-	}
-}
-
-func sendDeleteEndpoints(endpointsChan chan<- EndpointsUpdate) func(obj interface{}) {
-	return func(obj interface{}) {
-		var endpoints *api.Endpoints
-		switch t := obj.(type) {
-		case *api.Endpoints:
-			endpoints = t
-		case cache.DeletedFinalStateUnknown:
-			var ok bool
-			endpoints, ok = t.Obj.(*api.Endpoints)
-			if !ok {
-				utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Endpoints: %v", t.Obj))
-				return
-			}
-		default:
-			utilruntime.HandleError(fmt.Errorf("cannot convert to *api.Endpoints: %v", obj))
-			return
-		}
-		endpointsChan <- EndpointsUpdate{Op: REMOVE, Endpoints: endpoints}
-	}
-}
-
-// NewServiceController creates a controller that is watching services and sending
-// updates into ServiceUpdate channel.
-func NewServiceController(lw cache.ListerWatcher, period time.Duration, ch chan<- ServiceUpdate) cache.Controller {
-	_, serviceController := cache.NewInformer(
-		lw,
-		&api.Service{},
-		period,
-		cache.ResourceEventHandlerFuncs{
-			AddFunc:    sendAddService(ch),
-			UpdateFunc: sendUpdateService(ch),
-			DeleteFunc: sendDeleteService(ch),
-		},
-	)
-	return serviceController
-}
-
-// NewEndpointsController creates a controller that is watching endpoints and sending
-// updates into EndpointsUpdate channel.
-func NewEndpointsController(lw cache.ListerWatcher, period time.Duration, ch chan<- EndpointsUpdate) cache.Controller {
-	_, endpointsController := cache.NewInformer(
-		lw,
-		&api.Endpoints{},
-		period,
-		cache.ResourceEventHandlerFuncs{
-			AddFunc:    sendAddEndpoints(ch),
-			UpdateFunc: sendUpdateEndpoints(ch),
-			DeleteFunc: sendDeleteEndpoints(ch),
-		},
-	)
-	return endpointsController
-}

pkg/proxy/config/api_test.go

@@ -23,10 +23,8 @@ import (
 	"testing"
 	"time"
 
-	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/kubernetes/pkg/api"
@@ -65,68 +63,40 @@ func TestNewServicesSourceApi_UpdatesAndMultipleServices(t *testing.T) {
 		watchResp: fakeWatch,
 	}
 
-	ch := make(chan ServiceUpdate)
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+
+	ch := make(chan struct{})
+	handler := newSvcHandler(t, nil, func() { ch <- struct{}{} })
 
-	serviceController := NewServiceController(lw, 30*time.Second, ch)
-	go serviceController.Run(wait.NeverStop)
+	serviceConfig := newServiceConfig(lw, time.Minute)
+	serviceConfig.RegisterHandler(handler)
+	go serviceConfig.Run(stopCh)
 
 	// Add the first service
+	handler.expected = []api.Service{*service1v1}
 	fakeWatch.Add(service1v1)
-	got, ok := <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected := ServiceUpdate{Op: ADD, Service: service1v1}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v; Got %#v", expected, got)
-	}
+	<-ch
 
 	// Add another service
+	handler.expected = []api.Service{*service1v1, *service2}
 	fakeWatch.Add(service2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	// Could be sorted either of these two ways:
-	expected = ServiceUpdate{Op: ADD, Service: service2}
-
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Modify service1
+	handler.expected = []api.Service{*service1v2, *service2}
 	fakeWatch.Modify(service1v2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = ServiceUpdate{Op: UPDATE, Service: service1v2}
-
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Delete service1
+	handler.expected = []api.Service{*service2}
 	fakeWatch.Delete(service1v2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = ServiceUpdate{Op: REMOVE, Service: service1v2}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Delete service2
+	handler.expected = []api.Service{}
 	fakeWatch.Delete(service2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = ServiceUpdate{Op: REMOVE, Service: service2}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 }
 
 func TestNewEndpointsSourceApi_UpdatesAndMultipleEndpoints(t *testing.T) {
@@ -166,68 +136,40 @@ func TestNewEndpointsSourceApi_UpdatesAndMultipleEndpoints(t *testing.T) {
 		watchResp: fakeWatch,
 	}
 
-	ch := make(chan EndpointsUpdate)
+	stopCh := make(chan struct{})
+	defer close(stopCh)
+
+	ch := make(chan struct{})
+	handler := newEpsHandler(t, nil, func() { ch <- struct{}{} })
 
-	endpointsController := NewEndpointsController(lw, 30*time.Second, ch)
-	go endpointsController.Run(wait.NeverStop)
+	endpointsConfig := newEndpointsConfig(lw, time.Minute)
+	endpointsConfig.RegisterHandler(handler)
+	go endpointsConfig.Run(stopCh)
 
 	// Add the first endpoints
+	handler.expected = []*api.Endpoints{endpoints1v1}
 	fakeWatch.Add(endpoints1v1)
-	got, ok := <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected := EndpointsUpdate{Op: ADD, Endpoints: endpoints1v1}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v; Got %#v", expected, got)
-	}
+	<-ch
 
 	// Add another endpoints
+	handler.expected = []*api.Endpoints{endpoints1v1, endpoints2}
 	fakeWatch.Add(endpoints2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	// Could be sorted either of these two ways:
-	expected = EndpointsUpdate{Op: ADD, Endpoints: endpoints2}
-
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Modify endpoints1
+	handler.expected = []*api.Endpoints{endpoints1v2, endpoints2}
 	fakeWatch.Modify(endpoints1v2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = EndpointsUpdate{Op: UPDATE, Endpoints: endpoints1v2}
-
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Delete endpoints1
+	handler.expected = []*api.Endpoints{endpoints2}
 	fakeWatch.Delete(endpoints1v2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = EndpointsUpdate{Op: REMOVE, Endpoints: endpoints1v2}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 
 	// Delete endpoints2
+	handler.expected = []*api.Endpoints{}
 	fakeWatch.Delete(endpoints2)
-	got, ok = <-ch
-	if !ok {
-		t.Errorf("Unable to read from channel when expected")
-	}
-	expected = EndpointsUpdate{Op: REMOVE, Endpoints: endpoints2}
-	if !apiequality.Semantic.DeepEqual(expected, got) {
-		t.Errorf("Expected %#v, Got %#v", expected, got)
-	}
+	<-ch
 }
 
 type svcHandler struct {
@@ -286,13 +228,6 @@ func TestInitialSync(t *testing.T) {
 	// Wait for both services and endpoints handler.
 	wg.Add(2)
 
-	svcConfig := NewServiceConfig()
-	epsConfig := NewEndpointsConfig()
-	svcHandler := newSvcHandler(t, []api.Service{*svc2, *svc1}, wg.Done)
-	svcConfig.RegisterHandler(svcHandler)
-	epsHandler := newEpsHandler(t, []*api.Endpoints{eps2, eps1}, wg.Done)
-	epsConfig.RegisterHandler(epsHandler)
-
 	// Setup fake api client.
 	fakeSvcWatch := watch.NewFake()
 	svcLW := fakeLW{
@@ -305,8 +240,16 @@ func TestInitialSync(t *testing.T) {
 		watchResp: fakeEpsWatch,
 	}
 
+	svcConfig := newServiceConfig(svcLW, time.Minute)
+	epsConfig := newEndpointsConfig(epsLW, time.Minute)
+	svcHandler := newSvcHandler(t, []api.Service{*svc2, *svc1}, wg.Done)
+	svcConfig.RegisterHandler(svcHandler)
+	epsHandler := newEpsHandler(t, []*api.Endpoints{eps2, eps1}, wg.Done)
+	epsConfig.RegisterHandler(epsHandler)
+
 	stopCh := make(chan struct{})
 	defer close(stopCh)
-	newSourceAPI(svcLW, epsLW, time.Minute, svcConfig.Channel("one"), epsConfig.Channel("two"), stopCh)
+	go svcConfig.Run(stopCh)
+	go epsConfig.Run(stopCh)
 	wg.Wait()
 }