k8s.io/kubernetes@v1.29.3/pkg/proxy/kubemark/hollow_proxy.go (about)

     1  /*
     2  Copyright 2015 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package kubemark
    18  
    19  import (
    20  	"fmt"
    21  	"time"
    22  
    23  	v1 "k8s.io/api/core/v1"
    24  	discoveryv1 "k8s.io/api/discovery/v1"
    25  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    26  	"k8s.io/apimachinery/pkg/types"
    27  	clientset "k8s.io/client-go/kubernetes"
    28  	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
    29  	"k8s.io/client-go/tools/events"
    30  	utilsysctl "k8s.io/component-helpers/node/util/sysctl"
    31  	proxyapp "k8s.io/kubernetes/cmd/kube-proxy/app"
    32  	"k8s.io/kubernetes/pkg/proxy"
    33  	proxyconfigapi "k8s.io/kubernetes/pkg/proxy/apis/config"
    34  	proxyconfig "k8s.io/kubernetes/pkg/proxy/config"
    35  	"k8s.io/kubernetes/pkg/proxy/iptables"
    36  	proxyutiliptables "k8s.io/kubernetes/pkg/proxy/util/iptables"
    37  	utiliptables "k8s.io/kubernetes/pkg/util/iptables"
    38  	utilnode "k8s.io/kubernetes/pkg/util/node"
    39  	utilexec "k8s.io/utils/exec"
    40  	netutils "k8s.io/utils/net"
    41  	"k8s.io/utils/ptr"
    42  
    43  	"k8s.io/klog/v2"
    44  )
    45  
    46  type HollowProxy struct {
    47  	ProxyServer *proxyapp.ProxyServer
    48  }
    49  
    50  type FakeProxier struct {
    51  	proxyconfig.NoopNodeHandler
    52  }
    53  
    54  func (*FakeProxier) Sync() {}
    55  func (*FakeProxier) SyncLoop() {
    56  	select {}
    57  }
    58  func (*FakeProxier) OnServiceAdd(service *v1.Service)                                 {}
    59  func (*FakeProxier) OnServiceUpdate(oldService, service *v1.Service)                  {}
    60  func (*FakeProxier) OnServiceDelete(service *v1.Service)                              {}
    61  func (*FakeProxier) OnServiceSynced()                                                 {}
    62  func (*FakeProxier) OnEndpointSliceAdd(slice *discoveryv1.EndpointSlice)              {}
    63  func (*FakeProxier) OnEndpointSliceUpdate(oldSlice, slice *discoveryv1.EndpointSlice) {}
    64  func (*FakeProxier) OnEndpointSliceDelete(slice *discoveryv1.EndpointSlice)           {}
    65  func (*FakeProxier) OnEndpointSlicesSynced()                                          {}
    66  
    67  func NewHollowProxyOrDie(
    68  	nodeName string,
    69  	client clientset.Interface,
    70  	eventClient v1core.EventsGetter,
    71  	iptInterface utiliptables.Interface,
    72  	sysctl utilsysctl.Interface,
    73  	execer utilexec.Interface,
    74  	broadcaster events.EventBroadcaster,
    75  	recorder events.EventRecorder,
    76  	useRealProxier bool,
    77  	proxierSyncPeriod time.Duration,
    78  	proxierMinSyncPeriod time.Duration,
    79  ) (*HollowProxy, error) {
    80  	// Create proxier and service/endpoint handlers.
    81  	var proxier proxy.Provider
    82  	var err error
    83  
    84  	if useRealProxier {
    85  		nodeIP := utilnode.GetNodeIP(client, nodeName)
    86  		if nodeIP == nil {
    87  			klog.InfoS("Can't determine this node's IP, assuming 127.0.0.1")
    88  			nodeIP = netutils.ParseIPSloppy("127.0.0.1")
    89  		}
    90  		family := v1.IPv4Protocol
    91  		if iptInterface.IsIPv6() {
    92  			family = v1.IPv6Protocol
    93  		}
    94  		// Real proxier with fake iptables, sysctl, etc underneath it.
    95  		//var err error
    96  		proxier, err = iptables.NewProxier(
    97  			family,
    98  			iptInterface,
    99  			sysctl,
   100  			execer,
   101  			proxierSyncPeriod,
   102  			proxierMinSyncPeriod,
   103  			false,
   104  			false,
   105  			0,
   106  			proxyutiliptables.NewNoOpLocalDetector(),
   107  			nodeName,
   108  			nodeIP,
   109  			recorder,
   110  			nil,
   111  			[]string{},
   112  			false,
   113  		)
   114  		if err != nil {
   115  			return nil, fmt.Errorf("unable to create proxier: %v", err)
   116  		}
   117  	} else {
   118  		proxier = &FakeProxier{}
   119  	}
   120  
   121  	// Create a Hollow Proxy instance.
   122  	nodeRef := &v1.ObjectReference{
   123  		Kind:      "Node",
   124  		Name:      nodeName,
   125  		UID:       types.UID(nodeName),
   126  		Namespace: "",
   127  	}
   128  	return &HollowProxy{
   129  		ProxyServer: &proxyapp.ProxyServer{
   130  			Config: &proxyconfigapi.KubeProxyConfiguration{
   131  				Mode:             proxyconfigapi.ProxyMode("fake"),
   132  				ConfigSyncPeriod: metav1.Duration{Duration: 30 * time.Second},
   133  				OOMScoreAdj:      ptr.To[int32](0),
   134  			},
   135  
   136  			Client:      client,
   137  			Proxier:     proxier,
   138  			Broadcaster: broadcaster,
   139  			Recorder:    recorder,
   140  			NodeRef:     nodeRef,
   141  		},
   142  	}, nil
   143  }
   144  
   145  func (hp *HollowProxy) Run() error {
   146  	if err := hp.ProxyServer.Run(); err != nil {
   147  		return fmt.Errorf("Error while running proxy: %w", err)
   148  	}
   149  	return nil
   150  }