github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-03 09:22:44 +00:00
Code Issues Projects Releases Wiki Activity

pkg/proxy/healthcheck: rename 'proxier' to 'proxy'

Browse Source 
KubeProxy operates with a single health server and two proxies,
one for each IP family. The use of the term 'proxier' in the
types and functions within pkg/proxy/healthcheck can be
misleading, as it may suggest the existence of two health
servers, one for each IP family.

Signed-off-by: Daman Arora <aroradaman@gmail.com>
This commit is contained in:
Daman Arora 2024-12-18 18:00:44 +05:30
parent 9709d36dda
commit d6c575532a
10 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/kube-proxy/app/server.go
View File

@ -159,7 +159,7 @@ type ProxyServer struct {
Broadcaster events.EventBroadcaster Broadcaster events.EventBroadcaster
Recorder events.EventRecorder Recorder events.EventRecorder
NodeRef *v1.ObjectReference NodeRef *v1.ObjectReference
HealthzServer *healthcheck.ProxierHealthServer HealthzServer *healthcheck.ProxyHealthServer
Hostname string Hostname string
PrimaryIPFamily v1.IPFamily PrimaryIPFamily v1.IPFamily
NodeIPs map[v1.IPFamily]net.IP NodeIPs map[v1.IPFamily]net.IP
@ -224,7 +224,7 @@ func newProxyServer(ctx context.Context, config *kubeproxyconfig.KubeProxyConfig
} }
if len(config.HealthzBindAddress) > 0 { if len(config.HealthzBindAddress) > 0 {
s.HealthzServer = healthcheck.NewProxierHealthServer(config.HealthzBindAddress, 2*config.SyncPeriod.Duration) s.HealthzServer = healthcheck.NewProxyHealthServer(config.HealthzBindAddress, 2*config.SyncPeriod.Duration)
} }
err = s.platformSetup(ctx) err = s.platformSetup(ctx)
@ -415,7 +415,7 @@ func createClient(ctx context.Context, config componentbaseconfig.ClientConnecti
return client, nil return client, nil
} }
func serveHealthz(ctx context.Context, hz *healthcheck.ProxierHealthServer, errCh chan error) { func serveHealthz(ctx context.Context, hz *healthcheck.ProxyHealthServer, errCh chan error) {
logger := klog.FromContext(ctx) logger := klog.FromContext(ctx)
if hz == nil { if hz == nil {
return return

6
pkg/proxy/healthcheck/common.go
View File

@ -24,21 +24,21 @@ import (
netutils "k8s.io/utils/net" netutils "k8s.io/utils/net"
) )
// listener allows for testing of ServiceHealthServer and ProxierHealthServer. // listener allows for testing of ServiceHealthServer and ProxyHealthServer.
type listener interface { type listener interface {
// Listen is very much like netutils.MultiListen, except the second arg (network) is // Listen is very much like netutils.MultiListen, except the second arg (network) is
// fixed to be "tcp". // fixed to be "tcp".
Listen(ctx context.Context, addrs ...string) (net.Listener, error) Listen(ctx context.Context, addrs ...string) (net.Listener, error)
} }
// httpServerFactory allows for testing of ServiceHealthServer and ProxierHealthServer. // httpServerFactory allows for testing of ServiceHealthServer and ProxyHealthServer.
type httpServerFactory interface { type httpServerFactory interface {
// New creates an instance of a type satisfying HTTPServer. This is // New creates an instance of a type satisfying HTTPServer. This is
// designed to include http.Server. // designed to include http.Server.
New(handler http.Handler) httpServer New(handler http.Handler) httpServer
} }
// httpServer allows for testing of ServiceHealthServer and ProxierHealthServer. // httpServer allows for testing of ServiceHealthServer and ProxyHealthServer.
// It is designed so that http.Server satisfies this interface, // It is designed so that http.Server satisfies this interface,
type httpServer interface { type httpServer interface {
Serve(listener net.Listener) error Serve(listener net.Listener) error

18
pkg/proxy/healthcheck/healthcheck_test.go
View File

@ -138,11 +138,11 @@ type healthzPayload struct {
NodeHealthy bool NodeHealthy bool
} }
type fakeProxierHealthChecker struct { type fakeProxyHealthChecker struct {
healthy bool healthy bool
} }
func (fake fakeProxierHealthChecker) IsHealthy() bool { func (fake fakeProxyHealthChecker) IsHealthy() bool {
return fake.healthy return fake.healthy
} }
@ -150,7 +150,7 @@ func TestServer(t *testing.T) {
listener := newFakeListener() listener := newFakeListener()
httpFactory := newFakeHTTPServerFactory() httpFactory := newFakeHTTPServerFactory()
nodePortAddresses := proxyutil.NewNodePortAddresses(v1.IPv4Protocol, []string{}) nodePortAddresses := proxyutil.NewNodePortAddresses(v1.IPv4Protocol, []string{})
proxyChecker := &fakeProxierHealthChecker{true} proxyChecker := &fakeProxyHealthChecker{true}
hcsi := newServiceHealthServer("hostname", nil, listener, httpFactory, nodePortAddresses, proxyChecker) hcsi := newServiceHealthServer("hostname", nil, listener, httpFactory, nodePortAddresses, proxyChecker)
hcs := hcsi.(*server) hcs := hcsi.(*server)
@ -469,7 +469,7 @@ func TestHealthzServer(t *testing.T) {
httpFactory := newFakeHTTPServerFactory() httpFactory := newFakeHTTPServerFactory()
fakeClock := testingclock.NewFakeClock(time.Now()) fakeClock := testingclock.NewFakeClock(time.Now())
hs := newProxierHealthServer(listener, httpFactory, fakeClock, "127.0.0.1:10256", 10*time.Second) hs := newProxyHealthServer(listener, httpFactory, fakeClock, "127.0.0.1:10256", 10*time.Second)
server := hs.httpFactory.New(healthzHandler{hs: hs}) server := hs.httpFactory.New(healthzHandler{hs: hs})
hsTest := &serverTest{ hsTest := &serverTest{
@ -479,7 +479,7 @@ func TestHealthzServer(t *testing.T) {
tracking503: 0, tracking503: 0,
} }
testProxierHealthUpdater(hs, hsTest, fakeClock, t) testProxyHealthUpdater(hs, hsTest, fakeClock, t)
// Should return 200 "OK" if we've synced a node, tainted in any other way // Should return 200 "OK" if we've synced a node, tainted in any other way
hs.SyncNode(makeNode(tweakTainted("other"))) hs.SyncNode(makeNode(tweakTainted("other")))
@ -504,7 +504,7 @@ func TestLivezServer(t *testing.T) {
httpFactory := newFakeHTTPServerFactory() httpFactory := newFakeHTTPServerFactory()
fakeClock := testingclock.NewFakeClock(time.Now()) fakeClock := testingclock.NewFakeClock(time.Now())
hs := newProxierHealthServer(listener, httpFactory, fakeClock, "127.0.0.1:10256", 10*time.Second) hs := newProxyHealthServer(listener, httpFactory, fakeClock, "127.0.0.1:10256", 10*time.Second)
server := hs.httpFactory.New(livezHandler{hs: hs}) server := hs.httpFactory.New(livezHandler{hs: hs})
hsTest := &serverTest{ hsTest := &serverTest{
@ -514,7 +514,7 @@ func TestLivezServer(t *testing.T) {
tracking503: 0, tracking503: 0,
} }
testProxierHealthUpdater(hs, hsTest, fakeClock, t) testProxyHealthUpdater(hs, hsTest, fakeClock, t)
// Should return 200 "OK" irrespective of node syncs // Should return 200 "OK" irrespective of node syncs
hs.SyncNode(makeNode(tweakTainted("other"))) hs.SyncNode(makeNode(tweakTainted("other")))
@ -540,7 +540,7 @@ var (
livezURL url = "/livez" livezURL url = "/livez"
) )
func testProxierHealthUpdater(hs *ProxierHealthServer, hsTest *serverTest, fakeClock *testingclock.FakeClock, t *testing.T) { func testProxyHealthUpdater(hs *ProxyHealthServer, hsTest *serverTest, fakeClock *testingclock.FakeClock, t *testing.T) {
// Should return 200 "OK" by default. // Should return 200 "OK" by default.
testHTTPHandler(hsTest, http.StatusOK, t) testHTTPHandler(hsTest, http.StatusOK, t)
@ -659,7 +659,7 @@ func testMetricEquals(metric basemetrics.CounterMetric, expected float64, t *tes
func TestServerWithSelectiveListeningAddress(t *testing.T) { func TestServerWithSelectiveListeningAddress(t *testing.T) {
listener := newFakeListener() listener := newFakeListener()
httpFactory := newFakeHTTPServerFactory() httpFactory := newFakeHTTPServerFactory()
proxyChecker := &fakeProxierHealthChecker{true} proxyChecker := &fakeProxyHealthChecker{true}
// limiting addresses to loop back. We don't want any cleverness here around getting IP for // limiting addresses to loop back. We don't want any cleverness here around getting IP for
// machine nor testing ipv6 || ipv4. using loop back guarantees the test will work on any machine // machine nor testing ipv6 || ipv4. using loop back guarantees the test will work on any machine

38
pkg/proxy/healthcheck/proxier_health.go
View File

@ -35,14 +35,14 @@ const (
ToBeDeletedTaint = "ToBeDeletedByClusterAutoscaler" ToBeDeletedTaint = "ToBeDeletedByClusterAutoscaler"
) )
// ProxierHealthServer allows callers to: // ProxyHealthServer allows callers to:
// 1. run a http server with /healthz and /livez endpoint handlers. // 1. run a http server with /healthz and /livez endpoint handlers.
// 2. update healthz timestamps before and after synchronizing dataplane. // 2. update healthz timestamps before and after synchronizing dataplane.
// 3. sync node status, for reporting unhealthy /healthz response // 3. sync node status, for reporting unhealthy /healthz response
// if the node is marked for deletion by autoscaler. // if the node is marked for deletion by autoscaler.
// 4. get proxy health by verifying that the delay between QueuedUpdate() // 4. get proxy health by verifying that the delay between QueuedUpdate()
// calls and Updated() calls exceeded healthTimeout or not. // calls and Updated() calls exceeded healthTimeout or not.
type ProxierHealthServer struct { type ProxyHealthServer struct {
listener listener listener listener
httpFactory httpServerFactory httpFactory httpServerFactory
clock clock.Clock clock clock.Clock
@ -56,13 +56,13 @@ type ProxierHealthServer struct {
nodeEligible bool nodeEligible bool
} }
// NewProxierHealthServer returns a proxier health http server. // NewProxyHealthServer returns a proxy health http server.
func NewProxierHealthServer(addr string, healthTimeout time.Duration) *ProxierHealthServer { func NewProxyHealthServer(addr string, healthTimeout time.Duration) *ProxyHealthServer {
return newProxierHealthServer(stdNetListener{}, stdHTTPServerFactory{}, clock.RealClock{}, addr, healthTimeout) return newProxyHealthServer(stdNetListener{}, stdHTTPServerFactory{}, clock.RealClock{}, addr, healthTimeout)
} }
func newProxierHealthServer(listener listener, httpServerFactory httpServerFactory, c clock.Clock, addr string, healthTimeout time.Duration) *ProxierHealthServer { func newProxyHealthServer(listener listener, httpServerFactory httpServerFactory, c clock.Clock, addr string, healthTimeout time.Duration) *ProxyHealthServer {
return &ProxierHealthServer{ return &ProxyHealthServer{
listener: listener, listener: listener,
httpFactory: httpServerFactory, httpFactory: httpServerFactory,
clock: c, clock: c,
@ -80,7 +80,7 @@ func newProxierHealthServer(listener listener, httpServerFactory httpServerFacto
// Updated should be called when the proxier of the given IP family has successfully updated // Updated should be called when the proxier of the given IP family has successfully updated
// the service rules to reflect the current state and should be considered healthy now. // the service rules to reflect the current state and should be considered healthy now.
func (hs *ProxierHealthServer) Updated(ipFamily v1.IPFamily) { func (hs *ProxyHealthServer) Updated(ipFamily v1.IPFamily) {
hs.lock.Lock() hs.lock.Lock()
defer hs.lock.Unlock() defer hs.lock.Unlock()
delete(hs.oldestPendingQueuedMap, ipFamily) delete(hs.oldestPendingQueuedMap, ipFamily)
@ -92,7 +92,7 @@ func (hs *ProxierHealthServer) Updated(ipFamily v1.IPFamily) {
// indicates that the proxier for the given IP family has received changes but has not // indicates that the proxier for the given IP family has received changes but has not
// yet pushed them to its backend. If the proxier does not call Updated within the // yet pushed them to its backend. If the proxier does not call Updated within the
// healthTimeout time then it will be considered unhealthy. // healthTimeout time then it will be considered unhealthy.
func (hs *ProxierHealthServer) QueuedUpdate(ipFamily v1.IPFamily) { func (hs *ProxyHealthServer) QueuedUpdate(ipFamily v1.IPFamily) {
hs.lock.Lock() hs.lock.Lock()
defer hs.lock.Unlock() defer hs.lock.Unlock()
// Set oldestPendingQueuedMap[ipFamily] only if it's currently unset // Set oldestPendingQueuedMap[ipFamily] only if it's currently unset
@ -103,12 +103,12 @@ func (hs *ProxierHealthServer) QueuedUpdate(ipFamily v1.IPFamily) {
// IsHealthy returns only the proxier's health state, following the same // IsHealthy returns only the proxier's health state, following the same
// definition the HTTP server defines, but ignoring the state of the Node. // definition the HTTP server defines, but ignoring the state of the Node.
func (hs *ProxierHealthServer) IsHealthy() bool { func (hs *ProxyHealthServer) IsHealthy() bool {
isHealthy, _ := hs.isHealthy() isHealthy, _ := hs.isHealthy()
return isHealthy return isHealthy
} }
func (hs *ProxierHealthServer) isHealthy() (bool, time.Time) { func (hs *ProxyHealthServer) isHealthy() (bool, time.Time) {
hs.lock.RLock() hs.lock.RLock()
defer hs.lock.RUnlock() defer hs.lock.RUnlock()
@ -138,7 +138,7 @@ func (hs *ProxierHealthServer) isHealthy() (bool, time.Time) {
// SyncNode syncs the node and determines if it is eligible or not. Eligible is // SyncNode syncs the node and determines if it is eligible or not. Eligible is
// defined as being: not tainted by ToBeDeletedTaint and not deleted. // defined as being: not tainted by ToBeDeletedTaint and not deleted.
func (hs *ProxierHealthServer) SyncNode(node *v1.Node) { func (hs *ProxyHealthServer) SyncNode(node *v1.Node) {
hs.lock.Lock() hs.lock.Lock()
defer hs.lock.Unlock() defer hs.lock.Unlock()
@ -155,15 +155,15 @@ func (hs *ProxierHealthServer) SyncNode(node *v1.Node) {
hs.nodeEligible = true hs.nodeEligible = true
} }
// NodeEligible returns nodeEligible field of ProxierHealthServer. // NodeEligible returns nodeEligible field of ProxyHealthServer.
func (hs *ProxierHealthServer) NodeEligible() bool { func (hs *ProxyHealthServer) NodeEligible() bool {
hs.lock.RLock() hs.lock.RLock()
defer hs.lock.RUnlock() defer hs.lock.RUnlock()
return hs.nodeEligible return hs.nodeEligible
} }
// Run starts the healthz HTTP server and blocks until it exits. // Run starts the healthz HTTP server and blocks until it exits.
func (hs *ProxierHealthServer) Run(ctx context.Context) error { func (hs *ProxyHealthServer) Run(ctx context.Context) error {
serveMux := http.NewServeMux() serveMux := http.NewServeMux()
serveMux.Handle("/healthz", healthzHandler{hs: hs}) serveMux.Handle("/healthz", healthzHandler{hs: hs})
serveMux.Handle("/livez", livezHandler{hs: hs}) serveMux.Handle("/livez", livezHandler{hs: hs})
@ -171,19 +171,19 @@ func (hs *ProxierHealthServer) Run(ctx context.Context) error {
listener, err := hs.listener.Listen(ctx, hs.addr) listener, err := hs.listener.Listen(ctx, hs.addr)
if err != nil { if err != nil {
return fmt.Errorf("failed to start proxier healthz on %s: %v", hs.addr, err) return fmt.Errorf("failed to start proxy healthz on %s: %v", hs.addr, err)
} }
klog.V(3).InfoS("Starting healthz HTTP server", "address", hs.addr) klog.V(3).InfoS("Starting healthz HTTP server", "address", hs.addr)
if err := server.Serve(listener); err != nil { if err := server.Serve(listener); err != nil {
return fmt.Errorf("proxier healthz closed with error: %v", err) return fmt.Errorf("proxy healthz closed with error: %v", err)
} }
return nil return nil
} }
type healthzHandler struct { type healthzHandler struct {
hs *ProxierHealthServer hs *ProxyHealthServer
} }
func (h healthzHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) { func (h healthzHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
@ -211,7 +211,7 @@ func (h healthzHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
} }
type livezHandler struct { type livezHandler struct {
hs *ProxierHealthServer hs *ProxyHealthServer
} }
func (h livezHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) { func (h livezHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {

10
pkg/proxy/healthcheck/service_health.go
View File

@ -52,13 +52,13 @@ type ServiceHealthServer interface {
SyncEndpoints(newEndpoints map[types.NamespacedName]int) error SyncEndpoints(newEndpoints map[types.NamespacedName]int) error
} }
type proxierHealthChecker interface { type proxyHealthChecker interface {
// IsHealthy returns the proxier's health state, following the same // IsHealthy returns the proxy's health state, following the same
// definition the HTTP server defines. // definition the HTTP server defines.
IsHealthy() bool IsHealthy() bool
} }
func newServiceHealthServer(hostname string, recorder events.EventRecorder, listener listener, factory httpServerFactory, nodePortAddresses *proxyutil.NodePortAddresses, healthzServer proxierHealthChecker) ServiceHealthServer { func newServiceHealthServer(hostname string, recorder events.EventRecorder, listener listener, factory httpServerFactory, nodePortAddresses *proxyutil.NodePortAddresses, healthzServer proxyHealthChecker) ServiceHealthServer {
// It doesn't matter whether we listen on "0.0.0.0", "::", or ""; go // It doesn't matter whether we listen on "0.0.0.0", "::", or ""; go
// treats them all the same. // treats them all the same.
nodeIPs := []net.IP{net.IPv4zero} nodeIPs := []net.IP{net.IPv4zero}
@ -84,7 +84,7 @@ func newServiceHealthServer(hostname string, recorder events.EventRecorder, list
} }
// NewServiceHealthServer allocates a new service healthcheck server manager // NewServiceHealthServer allocates a new service healthcheck server manager
func NewServiceHealthServer(hostname string, recorder events.EventRecorder, nodePortAddresses *proxyutil.NodePortAddresses, healthzServer proxierHealthChecker) ServiceHealthServer { func NewServiceHealthServer(hostname string, recorder events.EventRecorder, nodePortAddresses *proxyutil.NodePortAddresses, healthzServer proxyHealthChecker) ServiceHealthServer {
return newServiceHealthServer(hostname, recorder, stdNetListener{}, stdHTTPServerFactory{}, nodePortAddresses, healthzServer) return newServiceHealthServer(hostname, recorder, stdNetListener{}, stdHTTPServerFactory{}, nodePortAddresses, healthzServer)
} }
@ -96,7 +96,7 @@ type server struct {
listener listener listener listener
httpFactory httpServerFactory httpFactory httpServerFactory
healthzServer proxierHealthChecker healthzServer proxyHealthChecker
lock sync.RWMutex lock sync.RWMutex
services map[types.NamespacedName]*hcInstance services map[types.NamespacedName]*hcInstance

6
pkg/proxy/iptables/proxier.go
View File

@ -111,7 +111,7 @@ func NewDualStackProxier(
hostname string, hostname string,
nodeIPs map[v1.IPFamily]net.IP, nodeIPs map[v1.IPFamily]net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
nodePortAddresses []string, nodePortAddresses []string,
initOnly bool, initOnly bool,
) (proxy.Provider, error) { ) (proxy.Provider, error) {
@ -177,7 +177,7 @@ type Proxier struct {
recorder events.EventRecorder recorder events.EventRecorder
serviceHealthServer healthcheck.ServiceHealthServer serviceHealthServer healthcheck.ServiceHealthServer
healthzServer *healthcheck.ProxierHealthServer healthzServer *healthcheck.ProxyHealthServer
// Since converting probabilities (floats) to strings is expensive // Since converting probabilities (floats) to strings is expensive
// and we are using only probabilities in the format of 1/n, we are // and we are using only probabilities in the format of 1/n, we are
@ -239,7 +239,7 @@ func NewProxier(ctx context.Context,
hostname string, hostname string,
nodeIP net.IP, nodeIP net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
nodePortAddressStrings []string, nodePortAddressStrings []string,
initOnly bool, initOnly bool,
) (*Proxier, error) { ) (*Proxier, error) {

6
pkg/proxy/ipvs/proxier.go
View File

@ -130,7 +130,7 @@ func NewDualStackProxier(
hostname string, hostname string,
nodeIPs map[v1.IPFamily]net.IP, nodeIPs map[v1.IPFamily]net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
scheduler string, scheduler string,
nodePortAddresses []string, nodePortAddresses []string,
initOnly bool, initOnly bool,
@ -212,7 +212,7 @@ type Proxier struct {
recorder events.EventRecorder recorder events.EventRecorder
serviceHealthServer healthcheck.ServiceHealthServer serviceHealthServer healthcheck.ServiceHealthServer
healthzServer *healthcheck.ProxierHealthServer healthzServer *healthcheck.ProxyHealthServer
ipvsScheduler string ipvsScheduler string
// The following buffers are used to reuse memory and avoid allocations // The following buffers are used to reuse memory and avoid allocations
@ -285,7 +285,7 @@ func NewProxier(
hostname string, hostname string,
nodeIP net.IP, nodeIP net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
scheduler string, scheduler string,
nodePortAddressStrings []string, nodePortAddressStrings []string,
initOnly bool, initOnly bool,

6
pkg/proxy/nftables/proxier.go
View File

@ -116,7 +116,7 @@ func NewDualStackProxier(
hostname string, hostname string,
nodeIPs map[v1.IPFamily]net.IP, nodeIPs map[v1.IPFamily]net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
nodePortAddresses []string, nodePortAddresses []string,
initOnly bool, initOnly bool,
) (proxy.Provider, error) { ) (proxy.Provider, error) {
@ -180,7 +180,7 @@ type Proxier struct {
recorder events.EventRecorder recorder events.EventRecorder
serviceHealthServer healthcheck.ServiceHealthServer serviceHealthServer healthcheck.ServiceHealthServer
healthzServer *healthcheck.ProxierHealthServer healthzServer *healthcheck.ProxyHealthServer
// nodePortAddresses selects the interfaces where nodePort works. // nodePortAddresses selects the interfaces where nodePort works.
nodePortAddresses *proxyutil.NodePortAddresses nodePortAddresses *proxyutil.NodePortAddresses
@ -222,7 +222,7 @@ func NewProxier(ctx context.Context,
hostname string, hostname string,
nodeIP net.IP, nodeIP net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
nodePortAddressStrings []string, nodePortAddressStrings []string,
initOnly bool, initOnly bool,
) (*Proxier, error) { ) (*Proxier, error) {

2
pkg/proxy/node.go
View File

@ -93,7 +93,7 @@ func (n *NodePodCIDRHandler) OnNodeSynced() {}
// NodeEligibleHandler handles the life cycle of the Node's eligibility, as // NodeEligibleHandler handles the life cycle of the Node's eligibility, as
// determined by the health server for directing load balancer traffic. // determined by the health server for directing load balancer traffic.
type NodeEligibleHandler struct { type NodeEligibleHandler struct {
HealthServer *healthcheck.ProxierHealthServer HealthServer *healthcheck.ProxyHealthServer
} }
var _ config.NodeHandler = &NodeEligibleHandler{} var _ config.NodeHandler = &NodeEligibleHandler{}

6
pkg/proxy/winkernel/proxier.go
View File

@ -620,7 +620,7 @@ type Proxier struct {
recorder events.EventRecorder recorder events.EventRecorder
serviceHealthServer healthcheck.ServiceHealthServer serviceHealthServer healthcheck.ServiceHealthServer
healthzServer *healthcheck.ProxierHealthServer healthzServer *healthcheck.ProxyHealthServer
hns HostNetworkService hns HostNetworkService
hcn HcnService hcn HcnService
@ -676,7 +676,7 @@ func NewProxier(
hostname string, hostname string,
nodeIP net.IP, nodeIP net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
healthzBindAddress string, healthzBindAddress string,
config config.KubeProxyWinkernelConfiguration, config config.KubeProxyWinkernelConfiguration,
) (*Proxier, error) { ) (*Proxier, error) {
@ -813,7 +813,7 @@ func NewDualStackProxier(
hostname string, hostname string,
nodeIPs map[v1.IPFamily]net.IP, nodeIPs map[v1.IPFamily]net.IP,
recorder events.EventRecorder, recorder events.EventRecorder,
healthzServer *healthcheck.ProxierHealthServer, healthzServer *healthcheck.ProxyHealthServer,
healthzBindAddress string, healthzBindAddress string,
config config.KubeProxyWinkernelConfiguration, config config.KubeProxyWinkernelConfiguration,
) (proxy.Provider, error) { ) (proxy.Provider, error) {