Documentation

Overview

Package k8s abstracts all Kubernetes specific behaviour

Package k8s abstracts all Kubernetes specific behaviour

Package k8s contains all k8s related logic. +groupName=pkg

Package k8s abstracts all Kubernetes specific behaviour

Index

Constants

View Source
const (
	// AnnotationIstioSidecarStatus is the annotation added by Istio into a pod
	// when it is injected with a sidecar proxy.
	// Since Istio 0.5.0, the value of this annotation is a serialized JSON object
	// with the following structure ("imagePullSecrets" was added in Istio 0.8.0):
	//
	//     {
	//         "version": "0213afe1274259d2f23feb4820ad2f8eb8609b84a5538e5f51f711545b6bde88",
	//         "initContainers": ["sleep", "istio-init"],
	//         "containers": ["istio-proxy"],
	//         "volumes": ["cilium-unix-sock-dir", "istio-envoy", "istio-certs"],
	//         "imagePullSecrets": null
	//     }
	AnnotationIstioSidecarStatus = "sidecar.istio.io/status"

	// DefaultSidecarIstioProxyImageRegexp is the default regexp compiled into
	// SidecarIstioProxyImageRegexp.
	DefaultSidecarIstioProxyImageRegexp = "cilium/istio_proxy"
)
View Source
const (
	// maximum number of operations a single json patch may contain.
	// See https://github.com/kubernetes/kubernetes/pull/74000
	MaxJSONPatchOperations = 10000
)

Variables

View Source
var CCNPStatusesPath = path.Join(kvstore.BaseKeyPrefix, "state", "ccnpstatuses", "v2")

    CCNPStatusesPath is the KVStore key prefix for CCNP status

    View Source
    var CNPStatusesPath = path.Join(kvstore.BaseKeyPrefix, "state", "cnpstatuses", "v2")

      CNPStatusesPath is the prefix in the kvstore which will contain all keys representing CNPStatus state for all nodes in the cluster.

      View Source
      var (
      	// SidecarIstioProxyImageRegexp is the regular expression matching
      	// compatible Istio sidecar istio-proxy container image names.
      	// This is set by the "sidecar-istio-proxy-image" configuration flag.
      	SidecarIstioProxyImageRegexp = regexp.MustCompile(DefaultSidecarIstioProxyImageRegexp)
      )

      Functions

      func AnnotationsEqual

      func AnnotationsEqual(relevantAnnotations []string, anno1, anno2 map[string]string) bool

        AnnotationsEqual returns whether the annotation with any key in relevantAnnotations is equal in anno1 and anno2.

        func Configure

        func Configure(apiServerURL, kubeconfigPath string, qps float32, burst int)

          Configure sets the parameters of the Kubernetes package

          func ConvertToCCNP

          func ConvertToCCNP(obj interface{}) interface{}

            ConvertToCCNP converts a *cilium_v2.CiliumClusterwideNetworkPolicy into a *types.SlimCNP without the Status field of the given CNP, or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.SlimCNP, also without the Status field of the given CNP, in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumClusterwideNetworkPolicy nor cache.DeletedFinalStateUnknown, the original obj is returned. WARNING calling this function will set *all* fields of the given CNP as empty.

            func ConvertToCCNPWithStatus

            func ConvertToCCNPWithStatus(obj interface{}) interface{}

              ConvertToCCNPWithStatus converts a *cilium_v2.CiliumClusterwideNetworkPolicy into *types.SlimCNP or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.SlimCNP in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumClusterwideNetworkPolicy nor cache.DeletedFinalStateUnknown, the original obj is returned.

              func ConvertToCNP

              func ConvertToCNP(obj interface{}) interface{}

                ConvertToCNP converts a *cilium_v2.CiliumNetworkPolicy into a *types.SlimCNP without the Status field of the given CNP, or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.SlimCNP, also without the Status field of the given CNP, in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumNetworkPolicy nor cache.DeletedFinalStateUnknown, the original obj is returned. WARNING calling this function will set *all* fields of the given CNP as empty.

                func ConvertToCNPWithStatus

                func ConvertToCNPWithStatus(obj interface{}) interface{}

                  ConvertToCNPWithStatus converts a *cilium_v2.CiliumNetworkPolicy or a *cilium_v2.CiliumClusterwideNetworkPolicy into a *types.SlimCNP or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.SlimCNP in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumNetworkPolicy nor cache.DeletedFinalStateUnknown, the original obj is returned.

                  func ConvertToCiliumEndpoint

                  func ConvertToCiliumEndpoint(obj interface{}) interface{}

                    ConvertToCiliumEndpoint converts a *cilium_v2.CiliumEndpoint into a *types.CiliumEndpoint or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.CiliumEndpoint in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumEndpoint nor cache.DeletedFinalStateUnknown, the original obj is returned.

                    func ConvertToCiliumExternalWorkload

                    func ConvertToCiliumExternalWorkload(obj interface{}) interface{}

                      ConvertToCiliumExternalWorkload converts a *cilium_v2.CiliumExternalWorkload into a *cilium_v2.CiliumExternalWorkload or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *cilium_v2.CiliumExternalWorkload in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumExternalWorkload nor cache.DeletedFinalStateUnknown, the original obj is returned.

                      func ConvertToCiliumLocalRedirectPolicy

                      func ConvertToCiliumLocalRedirectPolicy(obj interface{}) interface{}

                        ConvertToCiliumLocalRedirectPolicy converts a *cilium_v2.CiliumLocalRedirectPolicy into a *cilium_v2.CiliumLocalRedirectPolicy or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *cilium_v2.CiliumLocalRedirectPolicy in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumLocalRedirectPolicy nor cache.DeletedFinalStateUnknown, the original obj is returned.

                        func ConvertToCiliumNode

                        func ConvertToCiliumNode(obj interface{}) interface{}

                          ConvertToCiliumNode converts a *cilium_v2.CiliumNode into a *cilium_v2.CiliumNode or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *cilium_v2.CiliumNode in its Obj. If the given obj can't be cast into either *cilium_v2.CiliumNode nor cache.DeletedFinalStateUnknown, the original obj is returned.

                          func ConvertToK8sService

                          func ConvertToK8sService(obj interface{}) interface{}

                            ConvertToK8sService converts a *v1.Service into a *slim_corev1.Service or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *slim_corev1.Service in its Obj. If the given obj can't be cast into either *slim_corev1.Service nor cache.DeletedFinalStateUnknown, the original obj is returned.

                            func ConvertToNode

                            func ConvertToNode(obj interface{}) interface{}

                              ConvertToNode converts a *v1.Node into a *types.Node or a cache.DeletedFinalStateUnknown into a cache.DeletedFinalStateUnknown with a *types.Node in its Obj. If the given obj can't be cast into either *v1.Node nor cache.DeletedFinalStateUnknown, the original obj is returned. WARNING calling this function will set *all* fields of the given Node as empty.

                              func CreateConfig

                              func CreateConfig() (*rest.Config, error)

                                CreateConfig creates a client configuration based on the configured API server and Kubeconfig path

                                func CreateConfigFromAgentResponse

                                func CreateConfigFromAgentResponse(resp *models.DaemonConfiguration) (*rest.Config, error)

                                  CreateConfigFromAgentResponse creates a client configuration from a models.DaemonConfigurationResponse

                                  func CreateCustomDialer

                                  func CreateCustomDialer(b ServiceIPGetter, log *logrus.Entry) func(s string, duration time.Duration) (conn net.Conn, e error)

                                    CreateCustomDialer returns a custom dialer that picks the service IP, from the given ServiceIPGetter, if the address the used to dial is a k8s service.

                                    func EqualV1Services

                                    func EqualV1Services(k8sSVC1, k8sSVC2 *slim_corev1.Service, nodeAddressing datapath.NodeAddressing) bool

                                    func GetAPIServerURL

                                    func GetAPIServerURL() string

                                      GetAPIServerURL returns the configured API server URL address

                                      func GetBurst

                                      func GetBurst() int

                                        GetBurst gets the burst limit of the K8s configuration.

                                        func GetKubeconfigPath

                                        func GetKubeconfigPath() string

                                          GetKubeconfigPath returns the configured path to the kubeconfig configuration file

                                          func GetNode

                                          func GetNode(c kubernetes.Interface, nodeName string) (*corev1.Node, error)

                                            GetNode returns the kubernetes nodeName's node information from the kubernetes api server

                                            func GetPodMetadata

                                            func GetPodMetadata(k8sNs *slim_corev1.Namespace, pod *slim_corev1.Pod) (containerPorts []slim_corev1.ContainerPort, lbls map[string]string, retAnno map[string]string, retErr error)

                                              GetPodMetadata returns the labels and annotations of the pod with the given namespace / name.

                                              func GetPolicyLabelsv1

                                              func GetPolicyLabelsv1(np *slim_networkingv1.NetworkPolicy) labels.LabelArray

                                                GetPolicyLabelsv1 extracts the name of np. It uses the name from the Cilium annotation if present. If the policy's annotations do not contain the Cilium annotation, the policy's name field is used instead.

                                                func GetQPS

                                                func GetQPS() float32

                                                  GetQPS gets the QPS of the K8s configuration.

                                                  func HasEndpointSlice

                                                  func HasEndpointSlice(hasEndpointSlices chan struct{}, controller cache.Controller) bool

                                                    HasEndpointSlice returns true if the hasEndpointSlices is closed before the controller has been synchronized with k8s.

                                                    func Init

                                                    func Init(conf k8sconfig.Configuration) error

                                                      Init initializes the Kubernetes package. It is required to call Configure() beforehand.

                                                      func IsEnabled

                                                      func IsEnabled() bool

                                                        IsEnabled checks if Cilium is being used in tandem with Kubernetes.

                                                        func IsErrParse

                                                        func IsErrParse(e error) bool

                                                          IsErrParse returns true if the error is a ErrParse

                                                          func K8sErrorHandler

                                                          func K8sErrorHandler(e error)

                                                            K8sErrorHandler handles the error messages in a non verbose way by omitting repeated instances of the same error message for a timeout defined with k8sErrLogTimeout.

                                                            func NewClusterService

                                                            func NewClusterService(id ServiceID, k8sService *Service, k8sEndpoints *Endpoints) serviceStore.ClusterService

                                                              NewClusterService returns the serviceStore.ClusterService representing a Kubernetes Service

                                                              func ObjToCLRP

                                                              func ObjToCLRP(obj interface{}) *cilium_v2.CiliumLocalRedirectPolicy

                                                                ObjToCLRP attempts to cast object to a CLRP object and returns a deep copy if the castin succeeds. Otherwise, nil is returned.

                                                                func ObjToCiliumEndpoint

                                                                func ObjToCiliumEndpoint(obj interface{}) *types.CiliumEndpoint

                                                                  ObjToCiliumEndpoint attempts to cast object to a CiliumEndpoint object and returns a deep copy if the castin succeeds. Otherwise, nil is returned.

                                                                  func ObjToCiliumNode

                                                                  func ObjToCiliumNode(obj interface{}) *cilium_v2.CiliumNode

                                                                    ObjToCiliumNode attempts to cast object to a CiliumNode object and returns a deep copy if the castin succeeds. Otherwise, nil is returned.

                                                                    func ObjToSlimCNP

                                                                    func ObjToSlimCNP(obj interface{}) *types.SlimCNP

                                                                    func ObjToV1EndpointSlice

                                                                    func ObjToV1EndpointSlice(obj interface{}) *slim_discover_v1beta1.EndpointSlice

                                                                    func ObjToV1Endpoints

                                                                    func ObjToV1Endpoints(obj interface{}) *slim_corev1.Endpoints

                                                                    func ObjToV1Namespace

                                                                    func ObjToV1Namespace(obj interface{}) *slim_corev1.Namespace

                                                                    func ObjToV1NetworkPolicy

                                                                    func ObjToV1NetworkPolicy(obj interface{}) *slim_networkingv1.NetworkPolicy

                                                                    func ObjToV1Node

                                                                    func ObjToV1Node(obj interface{}) *slim_corev1.Node

                                                                    func ObjToV1PartialObjectMetadata

                                                                    func ObjToV1PartialObjectMetadata(obj interface{}) *slim_metav1.PartialObjectMetadata

                                                                    func ObjToV1Services

                                                                    func ObjToV1Services(obj interface{}) *slim_corev1.Service

                                                                    func ObjToV1beta1CRD

                                                                    func ObjToV1beta1CRD(obj interface{}) *slim_apiextensions_v1beta1.CustomResourceDefinition

                                                                    func ObjTov1Pod

                                                                    func ObjTov1Pod(obj interface{}) *slim_corev1.Pod

                                                                    func ParseEndpointSlice

                                                                      ParseEndpointSlice parses a Kubernetes Endpoints resource

                                                                      func ParseEndpoints

                                                                      func ParseEndpoints(ep *slim_corev1.Endpoints) (ServiceID, *Endpoints)

                                                                        ParseEndpoints parses a Kubernetes Endpoints resource

                                                                        func ParseNetworkPolicy

                                                                        func ParseNetworkPolicy(np *slim_networkingv1.NetworkPolicy) (api.Rules, error)

                                                                          ParseNetworkPolicy parses a k8s NetworkPolicy. Returns a list of Cilium policy rules that can be added, along with an error if there was an error sanitizing the rules.

                                                                          func ParseNode

                                                                          func ParseNode(k8sNode *slim_corev1.Node, source source.Source) *nodeTypes.Node

                                                                            ParseNode parses a kubernetes node to a cilium node

                                                                            func ParseNodeAddressType

                                                                            func ParseNodeAddressType(k8sAddress slim_corev1.NodeAddressType) (addressing.AddressType, error)

                                                                              ParseNodeAddressType converts a Kubernetes NodeAddressType to a Cilium NodeAddressType. If the Kubernetes NodeAddressType does not have a corresponding Cilium AddressType, returns an error.

                                                                              func ParseService

                                                                              func ParseService(svc *slim_corev1.Service, nodeAddressing datapath.NodeAddressing) (ServiceID, *Service)

                                                                                ParseService parses a Kubernetes service and returns a Service

                                                                                func PreprocessRules

                                                                                func PreprocessRules(r api.Rules, cache *ServiceCache) error

                                                                                  PreprocessRules translates rules that apply to headless services

                                                                                  func RegisterCRDs

                                                                                  func RegisterCRDs() error

                                                                                    RegisterCRDs registers all CRDs with the K8s apiserver.

                                                                                    func SupportsEndpointSlice

                                                                                    func SupportsEndpointSlice() bool

                                                                                      SupportsEndpointSlice returns true if cilium-operator or cilium-agent should watch and process endpoint slices.

                                                                                      func WaitForNodeInformation

                                                                                      func WaitForNodeInformation() error

                                                                                        WaitForNodeInformation retrieves the node information via the CiliumNode or Kubernetes Node resource. This function will block until the information is received.

                                                                                        Types

                                                                                        type Backend

                                                                                        type Backend struct {
                                                                                        	Ports    serviceStore.PortConfiguration
                                                                                        	NodeName string
                                                                                        }

                                                                                          Backend contains all ports and the node name of a given backend +k8s:deepcopy-gen=true

                                                                                          func (*Backend) DeepCopy

                                                                                          func (in *Backend) DeepCopy() *Backend

                                                                                            DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Backend.

                                                                                            func (*Backend) DeepCopyInto

                                                                                            func (in *Backend) DeepCopyInto(out *Backend)

                                                                                              DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                              func (*Backend) DeepEquals

                                                                                              func (b *Backend) DeepEquals(o *Backend) bool

                                                                                                DeepEquals returns true if both Backends are identical

                                                                                                type CCNPStatusEventHandler

                                                                                                type CCNPStatusEventHandler struct {
                                                                                                	*CNPStatusEventHandler
                                                                                                }

                                                                                                  CCNPStatusEventHandler handles status updates events for all the CCNPs in the cluster. Upon creation of Clusterwide policies, it will start a controller for that CNP which handles sending of updates for that CCNP to the kubernetes API server. Upon receiving eventes from the key-value store it will send the update for the CCNP corresponding to the status update to the controller for that CCNP.

                                                                                                  func NewCCNPStatusEventHandler

                                                                                                  func NewCCNPStatusEventHandler(k8sStore cache.Store, updateInterval time.Duration) *CCNPStatusEventHandler

                                                                                                    NewCCNPStatusEventHandler returns a new CCNPStatusEventHandler. which is more or less a wrapper around the CNPStatusEventHandler itself.

                                                                                                    type CNPNSWithMeta

                                                                                                    type CNPNSWithMeta struct {
                                                                                                    	UID       k8sTypes.UID
                                                                                                    	Namespace string
                                                                                                    	Name      string
                                                                                                    	Node      string
                                                                                                    	cilium_v2.CiliumNetworkPolicyNodeStatus
                                                                                                    }

                                                                                                      CNPNSWithMeta is a wrapper around a CiliumNetworkPolicyNodeStatus with metadata that uniquely identifies the CNP which is being updated, and the node to which the status update corresponds. Implements pkg/kvstore/store/Key.

                                                                                                      func (*CNPNSWithMeta) GetKeyName

                                                                                                      func (c *CNPNSWithMeta) GetKeyName() string

                                                                                                        GetKeyName returns the uniquely identifying information of this CNPNSWithMeta as a string for use as a key in a map.

                                                                                                        func (CNPNSWithMeta) GetName

                                                                                                        func (c CNPNSWithMeta) GetName() string

                                                                                                        func (CNPNSWithMeta) GetNamespace

                                                                                                        func (c CNPNSWithMeta) GetNamespace() string

                                                                                                        func (CNPNSWithMeta) GetUID

                                                                                                        func (c CNPNSWithMeta) GetUID() k8sTypes.UID

                                                                                                        func (*CNPNSWithMeta) Marshal

                                                                                                        func (c *CNPNSWithMeta) Marshal() ([]byte, error)

                                                                                                          Marshal marshals the CNPNSWithMeta into JSON form.

                                                                                                          func (*CNPNSWithMeta) Unmarshal

                                                                                                          func (c *CNPNSWithMeta) Unmarshal(data []byte) error

                                                                                                            Unmarshal unmarshals the CNPNSWithMeta from JSON form.

                                                                                                            type CNPStatusEventHandler

                                                                                                            type CNPStatusEventHandler struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              CNPStatusEventHandler handles status updates events for all CNPs in the cluster. Upon creation of CNPs, it will start a controller for that CNP which handles sending of updates for that CNP to the Kubernetes API server. Upon receiving events from the key-value store, it will send the update for the CNP corresponding to the status update to the controller for that CNP.

                                                                                                              func NewCNPStatusEventHandler

                                                                                                              func NewCNPStatusEventHandler(k8sStore cache.Store, updateInterval time.Duration) *CNPStatusEventHandler

                                                                                                                NewCNPStatusEventHandler returns a new CNPStatusEventHandler.

                                                                                                                func (*CNPStatusEventHandler) OnDelete

                                                                                                                func (c *CNPStatusEventHandler) OnDelete(_ store.NamedKey)

                                                                                                                  OnDelete is called when a delete event is called on the CNP status key. It is a NoOp

                                                                                                                  func (*CNPStatusEventHandler) OnUpdate

                                                                                                                  func (c *CNPStatusEventHandler) OnUpdate(key store.Key)

                                                                                                                    OnUpdate is called when a CNPStatus object is modified in the KVStore.

                                                                                                                    func (*CNPStatusEventHandler) StartStatusHandler

                                                                                                                    func (c *CNPStatusEventHandler) StartStatusHandler(cnp *types.SlimCNP)

                                                                                                                      StartStatusHandler starts the goroutine which sends status updates for the given CNP to the Kubernetes APIserver. If a status handler has already been started, it is a no-op.

                                                                                                                      func (*CNPStatusEventHandler) StopStatusHandler

                                                                                                                      func (c *CNPStatusEventHandler) StopStatusHandler(cnp *types.SlimCNP)

                                                                                                                        StopStatusHandler signals that we need to stop managing the sending of status updates to the Kubernetes APIServer for the given CNP. It also cleans up all status updates from the key-value store for this CNP.

                                                                                                                        func (*CNPStatusEventHandler) UpdateCNPStore

                                                                                                                        func (c *CNPStatusEventHandler) UpdateCNPStore(cnpStore *store.SharedStore)

                                                                                                                          UpdateCNPStore updates the CNP store for the status event handler This must be called before before Starting the status handler using StartStatusHandler method.

                                                                                                                          type CNPStatusUpdateContext

                                                                                                                          type CNPStatusUpdateContext struct {
                                                                                                                          	// CiliumNPClient is the CiliumNetworkPolicy client
                                                                                                                          	CiliumNPClient clientset.Interface
                                                                                                                          
                                                                                                                          	// CiliumV2Store is a store containing all CiliumNetworkPolicy
                                                                                                                          	CiliumV2Store cache.Store
                                                                                                                          
                                                                                                                          	// NodeName is the name of the node, it is used to separate status
                                                                                                                          	// field entries per node
                                                                                                                          	NodeName string
                                                                                                                          
                                                                                                                          	// NodeManager implements the backoff.NodeManager interface and is used
                                                                                                                          	// to provide cluster-size dependent backoff
                                                                                                                          	NodeManager backoff.NodeManager
                                                                                                                          
                                                                                                                          	// UpdateDuration must be populated using spanstart.Start() to provide
                                                                                                                          	// the timestamp of when the status update operation was started. It is
                                                                                                                          	// used to provide the latency in the Prometheus metrics.
                                                                                                                          	UpdateDuration *spanstat.SpanStat
                                                                                                                          
                                                                                                                          	// WaitForEndpointsAtPolicyRev must point to a function that will wait
                                                                                                                          	// for all local endpoints to reach the particular policy revision
                                                                                                                          	WaitForEndpointsAtPolicyRev func(ctx context.Context, rev uint64) error
                                                                                                                          }

                                                                                                                            CNPStatusUpdateContext is the context required to update the status of a CNP. It is filled out by the owner of the Kubernetes client before UpdateStatus() is called.

                                                                                                                            func (*CNPStatusUpdateContext) UpdateStatus

                                                                                                                            func (c *CNPStatusUpdateContext) UpdateStatus(ctx context.Context, cnp *types.SlimCNP, rev uint64, policyImportErr error) error

                                                                                                                              UpdateStatus updates the status section of a CiliumNetworkPolicy. It will retry as long as required to update the status unless a non-temporary error occurs in which case it expects a surrounding controller to restart or give up.

                                                                                                                              type CacheAction

                                                                                                                              type CacheAction int

                                                                                                                                CacheAction is the type of action that was performed on the cache

                                                                                                                                const (
                                                                                                                                	// UpdateService reflects that the service was updated or added
                                                                                                                                	UpdateService CacheAction = iota
                                                                                                                                
                                                                                                                                	// DeleteService reflects that the service was deleted
                                                                                                                                	DeleteService
                                                                                                                                )

                                                                                                                                func (CacheAction) String

                                                                                                                                func (c CacheAction) String() string

                                                                                                                                  String returns the cache action as a string

                                                                                                                                  type EndpointSliceID

                                                                                                                                  type EndpointSliceID struct {
                                                                                                                                  	ServiceID
                                                                                                                                  	EndpointSliceName string
                                                                                                                                  }

                                                                                                                                    EndpointSliceID identifies a Kubernetes EndpointSlice as well as the legacy v1.Endpoints.

                                                                                                                                    func ParseEndpointSliceID

                                                                                                                                    func ParseEndpointSliceID(es *slim_discover_v1beta1.EndpointSlice) EndpointSliceID

                                                                                                                                      ParseEndpointSliceID parses a Kubernetes endpoints slice and returns a EndpointSliceID

                                                                                                                                      type Endpoints

                                                                                                                                      type Endpoints struct {
                                                                                                                                      	// Backends is a map containing all backend IPs and ports. The key to
                                                                                                                                      	// the map is the backend IP in string form. The value defines the list
                                                                                                                                      	// of ports for that backend IP, plus an additional optional node name.
                                                                                                                                      	Backends map[string]*Backend
                                                                                                                                      }

                                                                                                                                        Endpoints is an abstraction for the Kubernetes endpoints object. Endpoints consists of a set of backend IPs in combination with a set of ports and protocols. The name of the backend ports must match the names of the frontend ports of the corresponding service. +k8s:deepcopy-gen=true

                                                                                                                                        func (*Endpoints) CIDRPrefixes

                                                                                                                                        func (e *Endpoints) CIDRPrefixes() ([]*net.IPNet, error)

                                                                                                                                          CIDRPrefixes returns the endpoint's backends as a slice of IPNets.

                                                                                                                                          func (*Endpoints) DeepCopy

                                                                                                                                          func (in *Endpoints) DeepCopy() *Endpoints

                                                                                                                                            DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Endpoints.

                                                                                                                                            func (*Endpoints) DeepCopyInto

                                                                                                                                            func (in *Endpoints) DeepCopyInto(out *Endpoints)

                                                                                                                                              DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                              func (*Endpoints) DeepEquals

                                                                                                                                              func (e *Endpoints) DeepEquals(o *Endpoints) bool

                                                                                                                                                DeepEquals returns true if both endpoints are deep equal.

                                                                                                                                                func (*Endpoints) String

                                                                                                                                                func (e *Endpoints) String() string

                                                                                                                                                  String returns the string representation of an endpoints resource, with backends and ports sorted.

                                                                                                                                                  type ErrParse

                                                                                                                                                  type ErrParse struct {
                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                  }

                                                                                                                                                    ErrParse is an error to describe where policy fails to parse due any invalid rule.

                                                                                                                                                    func (ErrParse) Error

                                                                                                                                                    func (e ErrParse) Error() string

                                                                                                                                                      Error returns the error message for parsing

                                                                                                                                                      type FrontendList

                                                                                                                                                      type FrontendList map[string]struct{}

                                                                                                                                                        FrontendList is the list of all k8s service frontends

                                                                                                                                                        func (FrontendList) LooseMatch

                                                                                                                                                        func (l FrontendList) LooseMatch(frontend loadbalancer.L3n4Addr) (exists bool)

                                                                                                                                                          LooseMatch returns true if the provided frontend is found in the FrontendList. If the frontend has a protocol value set, it only matches a k8s service with a matching protocol. If no protocol is set, any k8s service matching frontend IP and port is considered a match, regardless of protocol.

                                                                                                                                                          type JSONPatch

                                                                                                                                                          type JSONPatch struct {
                                                                                                                                                          	OP    string      `json:"op,omitempty"`
                                                                                                                                                          	Path  string      `json:"path,omitempty"`
                                                                                                                                                          	Value interface{} `json:"value"`
                                                                                                                                                          }

                                                                                                                                                            JSONPatch structure based on the RFC 6902

                                                                                                                                                            type K8sAPIExtensionsClient

                                                                                                                                                            type K8sAPIExtensionsClient struct {
                                                                                                                                                            	apiextclientset.Interface
                                                                                                                                                            }

                                                                                                                                                              K8sAPIExtensionsClient is a wrapper around clientset.Interface.

                                                                                                                                                              func APIExtClient

                                                                                                                                                              func APIExtClient() *K8sAPIExtensionsClient

                                                                                                                                                                APIExtClient returns the default API Extension client.

                                                                                                                                                                func WatcherAPIExtClient

                                                                                                                                                                func WatcherAPIExtClient() *K8sAPIExtensionsClient

                                                                                                                                                                  WatcherAPIExtClient returns the client dedicated to API Extensions watchers.

                                                                                                                                                                  type K8sCiliumClient

                                                                                                                                                                  type K8sCiliumClient struct {
                                                                                                                                                                  	clientset.Interface
                                                                                                                                                                  }

                                                                                                                                                                    K8sCiliumClient is a wrapper around clientset.Interface.

                                                                                                                                                                    func CiliumClient

                                                                                                                                                                    func CiliumClient() *K8sCiliumClient

                                                                                                                                                                      CiliumClient returns the default Cilium Kubernetes client.

                                                                                                                                                                      type K8sClient

                                                                                                                                                                      type K8sClient struct {
                                                                                                                                                                      	// kubernetes.Interface is the object through which interactions with
                                                                                                                                                                      	// Kubernetes are performed.
                                                                                                                                                                      	kubernetes.Interface
                                                                                                                                                                      }

                                                                                                                                                                        K8sClient is a wrapper around kubernetes.Interface.

                                                                                                                                                                        func Client

                                                                                                                                                                        func Client() *K8sClient

                                                                                                                                                                          Client returns the default Kubernetes client.

                                                                                                                                                                          func WatcherClient

                                                                                                                                                                          func WatcherClient() *K8sClient

                                                                                                                                                                            WatcherClient returns the client dedicated to K8s watchers.

                                                                                                                                                                            func (K8sClient) AnnotateNode

                                                                                                                                                                            func (k8sCli K8sClient) AnnotateNode(nodeName string, encryptKey uint8, v4CIDR, v6CIDR *cidr.CIDR, v4HealthIP, v6HealthIP, v4CiliumHostIP, v6CiliumHostIP net.IP) error

                                                                                                                                                                              AnnotateNode writes v4 and v6 CIDRs and health IPs in the given k8s node name. In case of failure while updating the node, this function while spawn a go routine to retry the node update indefinitely.

                                                                                                                                                                              func (K8sClient) GetSecrets

                                                                                                                                                                              func (k8sCli K8sClient) GetSecrets(ctx context.Context, ns, name string) (map[string][]byte, error)

                                                                                                                                                                                GetSecrets returns the secrets found in the given namespace and name.

                                                                                                                                                                                func (K8sClient) MarkNodeReady

                                                                                                                                                                                func (k8sCli K8sClient) MarkNodeReady(nodeName string)

                                                                                                                                                                                  MarkNodeReady marks the Kubernetes node resource as ready from a networking perspective

                                                                                                                                                                                  type K8sMetaObject

                                                                                                                                                                                  type K8sMetaObject interface {
                                                                                                                                                                                  	GetUID() k8sTypes.UID
                                                                                                                                                                                  	GetNamespace() string
                                                                                                                                                                                  	GetName() string
                                                                                                                                                                                  }

                                                                                                                                                                                  type NodeStatusUpdate

                                                                                                                                                                                  type NodeStatusUpdate struct {
                                                                                                                                                                                  	*cilium_v2.CiliumNetworkPolicyNodeStatus
                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                  }

                                                                                                                                                                                    NodeStatusUpdate pairs a CiliumNetworkPolicyNodeStatus to a specific node.

                                                                                                                                                                                    type NodeStatusUpdater

                                                                                                                                                                                    type NodeStatusUpdater struct {
                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                    }

                                                                                                                                                                                      NodeStatusUpdater handles the lifecycle around sending CNP NodeStatus updates.

                                                                                                                                                                                      type RuleTranslator

                                                                                                                                                                                      type RuleTranslator struct {
                                                                                                                                                                                      	Service          ServiceID
                                                                                                                                                                                      	Endpoint         Endpoints
                                                                                                                                                                                      	ServiceLabels    map[string]string
                                                                                                                                                                                      	Revert           bool
                                                                                                                                                                                      	AllocatePrefixes bool
                                                                                                                                                                                      }

                                                                                                                                                                                        RuleTranslator implements pkg/policy.Translator interface Translate populates/depopulates given rule with ToCIDR rules Based on provided service/endpoint

                                                                                                                                                                                        func NewK8sTranslator

                                                                                                                                                                                        func NewK8sTranslator(
                                                                                                                                                                                        	serviceInfo ServiceID,
                                                                                                                                                                                        	endpoint Endpoints,
                                                                                                                                                                                        	revert bool,
                                                                                                                                                                                        	labels map[string]string,
                                                                                                                                                                                        	allocatePrefixes bool) RuleTranslator

                                                                                                                                                                                          NewK8sTranslator returns RuleTranslator

                                                                                                                                                                                          func (RuleTranslator) Translate

                                                                                                                                                                                          func (k RuleTranslator) Translate(r *api.Rule, result *policy.TranslationResult) error

                                                                                                                                                                                            Translate calls TranslateEgress on all r.Egress rules

                                                                                                                                                                                            func (RuleTranslator) TranslateEgress

                                                                                                                                                                                            func (k RuleTranslator) TranslateEgress(r *api.EgressRule, result *policy.TranslationResult) error

                                                                                                                                                                                              TranslateEgress populates/depopulates egress rules with ToCIDR entries based on toService entries

                                                                                                                                                                                              type Service

                                                                                                                                                                                              type Service struct {
                                                                                                                                                                                              	FrontendIP net.IP
                                                                                                                                                                                              	IsHeadless bool
                                                                                                                                                                                              
                                                                                                                                                                                              	// IncludeExternal is true when external endpoints from other clusters
                                                                                                                                                                                              	// should be included
                                                                                                                                                                                              	IncludeExternal bool
                                                                                                                                                                                              
                                                                                                                                                                                              	// Shared is true when the service should be exposed/shared to other clusters
                                                                                                                                                                                              	Shared bool
                                                                                                                                                                                              
                                                                                                                                                                                              	// TrafficPolicy controls how backends are selected. If set to "Local", only
                                                                                                                                                                                              	// node-local backends are chosen
                                                                                                                                                                                              	TrafficPolicy loadbalancer.SVCTrafficPolicy
                                                                                                                                                                                              
                                                                                                                                                                                              	// HealthCheckNodePort defines on which port the node runs a HTTP health
                                                                                                                                                                                              	// check server which may be used by external loadbalancers to determine
                                                                                                                                                                                              	// if a node has local backends. This will only have effect if both
                                                                                                                                                                                              	// LoadBalancerIPs is not empty and TrafficPolicy is SVCTrafficPolicyLocal.
                                                                                                                                                                                              	HealthCheckNodePort uint16
                                                                                                                                                                                              
                                                                                                                                                                                              	Ports map[loadbalancer.FEPortName]*loadbalancer.L4Addr
                                                                                                                                                                                              	// NodePorts stores mapping for port name => NodePort frontend addr string =>
                                                                                                                                                                                              	// NodePort fronted addr. The string addr => addr indirection is to avoid
                                                                                                                                                                                              	// storing duplicates.
                                                                                                                                                                                              	NodePorts map[loadbalancer.FEPortName]map[string]*loadbalancer.L3n4AddrID
                                                                                                                                                                                              	// K8sExternalIPs stores mapping of the endpoint in a string format to the
                                                                                                                                                                                              	// externalIP in net.IP format.
                                                                                                                                                                                              	K8sExternalIPs map[string]net.IP
                                                                                                                                                                                              
                                                                                                                                                                                              	// LoadBalancerIPs stores LB IPs assigned to the service (string(IP) => IP).
                                                                                                                                                                                              	LoadBalancerIPs          map[string]net.IP
                                                                                                                                                                                              	LoadBalancerSourceRanges map[string]*cidr.CIDR
                                                                                                                                                                                              
                                                                                                                                                                                              	Labels   map[string]string
                                                                                                                                                                                              	Selector map[string]string
                                                                                                                                                                                              
                                                                                                                                                                                              	// SessionAffinity denotes whether service has the clientIP session affinity
                                                                                                                                                                                              	SessionAffinity bool
                                                                                                                                                                                              	// SessionAffinityTimeoutSeconds denotes session affinity timeout
                                                                                                                                                                                              	SessionAffinityTimeoutSec uint32
                                                                                                                                                                                              
                                                                                                                                                                                              	// Type is the internal service type
                                                                                                                                                                                              	Type loadbalancer.SVCType
                                                                                                                                                                                              }

                                                                                                                                                                                                Service is an abstraction for a k8s service that is composed by the frontend IP address (FEIP) and the map of the frontend ports (Ports). +k8s:deepcopy-gen=true

                                                                                                                                                                                                func NewService

                                                                                                                                                                                                func NewService(ip net.IP, externalIPs, loadBalancerIPs, loadBalancerSourceRanges []string,
                                                                                                                                                                                                	headless bool, trafficPolicy loadbalancer.SVCTrafficPolicy,
                                                                                                                                                                                                	healthCheckNodePort uint16, labels, selector map[string]string,
                                                                                                                                                                                                	namespace string, svcType loadbalancer.SVCType) *Service

                                                                                                                                                                                                  NewService returns a new Service with the Ports map initialized.

                                                                                                                                                                                                  func ParseClusterService

                                                                                                                                                                                                  func ParseClusterService(svc *serviceStore.ClusterService) *Service

                                                                                                                                                                                                    ParseClusterService parses a ClusterService and returns a Service. ClusterService is a subset of what a Service can express, especially, ClusterService does not have: - other service types than ClusterIP - an explicit traffic policy, SVCTrafficPolicyCluster is assumed - health check node ports - NodePorts - external IPs - LoadBalancerIPs - LoadBalancerSourceRanges - SessionAffinity

                                                                                                                                                                                                    ParseClusterService() is paired with EqualsClusterService() that has the above wired in.

                                                                                                                                                                                                    func (*Service) DeepCopy

                                                                                                                                                                                                    func (in *Service) DeepCopy() *Service

                                                                                                                                                                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Service.

                                                                                                                                                                                                      func (*Service) DeepCopyInto

                                                                                                                                                                                                      func (in *Service) DeepCopyInto(out *Service)

                                                                                                                                                                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                                                        func (*Service) DeepEquals

                                                                                                                                                                                                        func (s *Service) DeepEquals(o *Service) bool

                                                                                                                                                                                                          DeepEquals returns true if both services are equal

                                                                                                                                                                                                          func (*Service) EqualsClusterService

                                                                                                                                                                                                          func (s *Service) EqualsClusterService(svc *serviceStore.ClusterService) bool

                                                                                                                                                                                                            EqualsClusterService returns true the given ClusterService would parse into Service if ParseClusterService() would be called. This is necessary to avoid memory allocations that would be performed by ParseClusterService() when the service already exists.

                                                                                                                                                                                                            func (Service) IsExternal

                                                                                                                                                                                                            func (s Service) IsExternal() bool

                                                                                                                                                                                                              IsExternal returns true if the service is expected to serve out-of-cluster endpoints:

                                                                                                                                                                                                              func (*Service) String

                                                                                                                                                                                                              func (s *Service) String() string

                                                                                                                                                                                                                String returns the string representation of a service resource

                                                                                                                                                                                                                func (*Service) UniquePorts

                                                                                                                                                                                                                func (s *Service) UniquePorts() map[uint16]bool

                                                                                                                                                                                                                  UniquePorts returns a map of all unique ports configured in the service

                                                                                                                                                                                                                  type ServiceCache

                                                                                                                                                                                                                  type ServiceCache struct {
                                                                                                                                                                                                                  	Events chan ServiceEvent
                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    ServiceCache is a list of services correlated with the matching endpoints. The Events member will receive events as services.

                                                                                                                                                                                                                    func NewServiceCache

                                                                                                                                                                                                                    func NewServiceCache(nodeAddressing datapath.NodeAddressing) ServiceCache

                                                                                                                                                                                                                      NewServiceCache returns a new ServiceCache

                                                                                                                                                                                                                      func (*ServiceCache) DebugStatus

                                                                                                                                                                                                                      func (s *ServiceCache) DebugStatus() string

                                                                                                                                                                                                                        DebugStatus implements debug.StatusObject to provide debug status collection ability

                                                                                                                                                                                                                        func (*ServiceCache) DeleteEndpointSlices

                                                                                                                                                                                                                        func (s *ServiceCache) DeleteEndpointSlices(epSlice *slim_discovery_v1beta1.EndpointSlice, swg *lock.StoppableWaitGroup) ServiceID

                                                                                                                                                                                                                        func (*ServiceCache) DeleteEndpoints

                                                                                                                                                                                                                        func (s *ServiceCache) DeleteEndpoints(k8sEndpoints *slim_corev1.Endpoints, swg *lock.StoppableWaitGroup) ServiceID

                                                                                                                                                                                                                          DeleteEndpoints parses a Kubernetes endpoints and removes it from the ServiceCache

                                                                                                                                                                                                                          func (*ServiceCache) DeleteService

                                                                                                                                                                                                                          func (s *ServiceCache) DeleteService(k8sSvc *slim_corev1.Service, swg *lock.StoppableWaitGroup)

                                                                                                                                                                                                                            DeleteService parses a Kubernetes service and removes it from the ServiceCache

                                                                                                                                                                                                                            func (*ServiceCache) EnsureService

                                                                                                                                                                                                                            func (s *ServiceCache) EnsureService(svcID ServiceID, swg *lock.StoppableWaitGroup) bool

                                                                                                                                                                                                                            func (*ServiceCache) GetNodeAddressing

                                                                                                                                                                                                                            func (s *ServiceCache) GetNodeAddressing() datapath.NodeAddressing

                                                                                                                                                                                                                              GetNodeAddressing returns the registered node addresses to this service cache.

                                                                                                                                                                                                                              func (*ServiceCache) GetServiceAddrsWithType

                                                                                                                                                                                                                              func (s *ServiceCache) GetServiceAddrsWithType(svcID ServiceID, svcType loadbalancer.SVCType) map[loadbalancer.FEPortName]*loadbalancer.L3n4Addr

                                                                                                                                                                                                                                GetServiceAddrWithPortsAndType returns a slice of all the L3n4Addr that are backing the given Service ID with given type. Note: The returned IPs are with External scope.

                                                                                                                                                                                                                                func (*ServiceCache) GetServiceFrontendIP

                                                                                                                                                                                                                                func (s *ServiceCache) GetServiceFrontendIP(svcID ServiceID, svcType loadbalancer.SVCType) net.IP

                                                                                                                                                                                                                                  GetServiceFrontendIP returns the frontend IP (aka clusterIP) for the given service with type.

                                                                                                                                                                                                                                  func (*ServiceCache) GetServiceIP

                                                                                                                                                                                                                                  func (s *ServiceCache) GetServiceIP(svcID ServiceID) *loadbalancer.L3n4Addr

                                                                                                                                                                                                                                    GetServiceIP returns a random L3n4Addr that is backing the given Service ID. The returned IP is with external scope since its string representation might be used for net Dialer.

                                                                                                                                                                                                                                    func (*ServiceCache) MergeClusterServiceDelete

                                                                                                                                                                                                                                    func (s *ServiceCache) MergeClusterServiceDelete(service *serviceStore.ClusterService, swg *lock.StoppableWaitGroup)

                                                                                                                                                                                                                                      MergeClusterServiceDelete merges the deletion of a cluster service in a remote cluster into the local service cache, deleting the local service.

                                                                                                                                                                                                                                      func (*ServiceCache) MergeClusterServiceUpdate

                                                                                                                                                                                                                                      func (s *ServiceCache) MergeClusterServiceUpdate(service *serviceStore.ClusterService, swg *lock.StoppableWaitGroup)

                                                                                                                                                                                                                                        MergeClusterServiceUpdate merges a cluster service of a local cluster into the local service cache. The service endpoints are stored as external endpoints and are correlated on demand with local services via correlateEndpoints(). Local service is created and/or updated if needed.

                                                                                                                                                                                                                                        func (*ServiceCache) MergeExternalServiceDelete

                                                                                                                                                                                                                                        func (s *ServiceCache) MergeExternalServiceDelete(service *serviceStore.ClusterService, swg *lock.StoppableWaitGroup)

                                                                                                                                                                                                                                          MergeExternalServiceDelete merges the deletion of a cluster service in a remote cluster into the local service cache. The service endpoints are stored as external endpoints and are correlated on demand with local services via correlateEndpoints().

                                                                                                                                                                                                                                          func (*ServiceCache) MergeExternalServiceUpdate

                                                                                                                                                                                                                                          func (s *ServiceCache) MergeExternalServiceUpdate(service *serviceStore.ClusterService, swg *lock.StoppableWaitGroup)

                                                                                                                                                                                                                                            MergeExternalServiceUpdate merges a cluster service of a remote cluster into the local service cache. The service endpoints are stored as external endpoints and are correlated on demand with local services via correlateEndpoints().

                                                                                                                                                                                                                                            func (*ServiceCache) UniqueServiceFrontends

                                                                                                                                                                                                                                            func (s *ServiceCache) UniqueServiceFrontends() FrontendList

                                                                                                                                                                                                                                              UniqueServiceFrontends returns all externally scoped services known to the service cache as a map, indexed by the string representation of a loadbalancer.L3n4Addr. This helper is only used in unit tests.

                                                                                                                                                                                                                                              func (*ServiceCache) UpdateEndpointSlices

                                                                                                                                                                                                                                              func (s *ServiceCache) UpdateEndpointSlices(epSlice *slim_discovery_v1beta1.EndpointSlice, swg *lock.StoppableWaitGroup) (ServiceID, *Endpoints)

                                                                                                                                                                                                                                              func (*ServiceCache) UpdateEndpoints

                                                                                                                                                                                                                                              func (s *ServiceCache) UpdateEndpoints(k8sEndpoints *slim_corev1.Endpoints, swg *lock.StoppableWaitGroup) (ServiceID, *Endpoints)

                                                                                                                                                                                                                                                UpdateEndpoints parses a Kubernetes endpoints and adds or updates it in the ServiceCache. Returns the ServiceID unless the Kubernetes endpoints could not be parsed and a bool to indicate whether the endpoints was changed in the cache or not.

                                                                                                                                                                                                                                                func (*ServiceCache) UpdateService

                                                                                                                                                                                                                                                func (s *ServiceCache) UpdateService(k8sSvc *slim_corev1.Service, swg *lock.StoppableWaitGroup) ServiceID

                                                                                                                                                                                                                                                  UpdateService parses a Kubernetes service and adds or updates it in the ServiceCache. Returns the ServiceID unless the Kubernetes service could not be parsed and a bool to indicate whether the service was changed in the cache or not.

                                                                                                                                                                                                                                                  type ServiceEvent

                                                                                                                                                                                                                                                  type ServiceEvent struct {
                                                                                                                                                                                                                                                  	// Action is the action that was performed in the cache
                                                                                                                                                                                                                                                  	Action CacheAction
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// ID is the identified of the service
                                                                                                                                                                                                                                                  	ID ServiceID
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Service is the service structure
                                                                                                                                                                                                                                                  	Service *Service
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// OldService is the service structure
                                                                                                                                                                                                                                                  	OldService *Service
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Endpoints is the endpoints structured correlated with the service
                                                                                                                                                                                                                                                  	Endpoints *Endpoints
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// SWG provides a mechanism to detect if a service was synchronized with
                                                                                                                                                                                                                                                  	// the datapath.
                                                                                                                                                                                                                                                  	SWG *lock.StoppableWaitGroup
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    ServiceEvent is emitted via the Events channel of ServiceCache and describes the change that occurred in the cache

                                                                                                                                                                                                                                                    type ServiceID

                                                                                                                                                                                                                                                    type ServiceID struct {
                                                                                                                                                                                                                                                    	Name      string `json:"serviceName,omitempty"`
                                                                                                                                                                                                                                                    	Namespace string `json:"namespace,omitempty"`
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      ServiceID identifies the Kubernetes service

                                                                                                                                                                                                                                                      func ParseEndpointsID

                                                                                                                                                                                                                                                      func ParseEndpointsID(svc *slim_corev1.Endpoints) ServiceID

                                                                                                                                                                                                                                                        ParseEndpointsID parses a Kubernetes endpoints and returns the ServiceID

                                                                                                                                                                                                                                                        func ParseServiceID

                                                                                                                                                                                                                                                        func ParseServiceID(svc *slim_corev1.Service) ServiceID

                                                                                                                                                                                                                                                          ParseServiceID parses a Kubernetes service and returns the ServiceID

                                                                                                                                                                                                                                                          func ParseServiceIDFrom

                                                                                                                                                                                                                                                          func ParseServiceIDFrom(dn string) *ServiceID

                                                                                                                                                                                                                                                            ParseServiceIDFrom returns a ServiceID derived from the given kubernetes service FQDN.

                                                                                                                                                                                                                                                            func (ServiceID) String

                                                                                                                                                                                                                                                            func (s ServiceID) String() string

                                                                                                                                                                                                                                                              String returns the string representation of a service ID

                                                                                                                                                                                                                                                              type ServiceIPGetter

                                                                                                                                                                                                                                                              type ServiceIPGetter interface {
                                                                                                                                                                                                                                                              	GetServiceIP(svcID ServiceID) *loadbalancer.L3n4Addr
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                              Directories

                                                                                                                                                                                                                                                              Path Synopsis
                                                                                                                                                                                                                                                              apis
                                                                                                                                                                                                                                                              cilium.io/v2
                                                                                                                                                                                                                                                              Package v2 is the v2 version of the API.
                                                                                                                                                                                                                                                              Package v2 is the v2 version of the API.
                                                                                                                                                                                                                                                              cilium.io/v2/client
                                                                                                                                                                                                                                                              Package client generated by go-bindata.// sources: ../../../../../../examples/crds/ciliumclusterwidenetworkpolicies.yaml ../../../../../../examples/crds/ciliumendpoints.yaml ../../../../../../examples/crds/ciliumexternalworkloads.yaml ../../../../../../examples/crds/ciliumidentities.yaml ../../../../../../examples/crds/ciliumlocalredirectpolicies.yaml ../../../../../../examples/crds/ciliumnetworkpolicies.yaml ../../../../../../examples/crds/ciliumnodes.yaml
                                                                                                                                                                                                                                                              Package client generated by go-bindata.// sources: ../../../../../../examples/crds/ciliumclusterwidenetworkpolicies.yaml ../../../../../../examples/crds/ciliumendpoints.yaml ../../../../../../examples/crds/ciliumexternalworkloads.yaml ../../../../../../examples/crds/ciliumidentities.yaml ../../../../../../examples/crds/ciliumlocalredirectpolicies.yaml ../../../../../../examples/crds/ciliumnetworkpolicies.yaml ../../../../../../examples/crds/ciliumnodes.yaml
                                                                                                                                                                                                                                                              client
                                                                                                                                                                                                                                                              clientset/versioned
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              clientset/versioned/fake
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              clientset/versioned/scheme
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              clientset/versioned/typed/cilium.io/v2
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              clientset/versioned/typed/cilium.io/v2/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              slim
                                                                                                                                                                                                                                                              k8s/api/core/v1
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              k8s/api/discovery/v1beta1
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              k8s/api/networking/v1
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/fake
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/scheme
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/typed/apiextensions/v1
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/typed/apiextensions/v1/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/typed/apiextensions/v1beta1
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              k8s/apiextensions-client/clientset/versioned/typed/apiextensions/v1beta1/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              k8s/apis/apiextensions/v1
                                                                                                                                                                                                                                                              Package v1 is the v1 version of the API.
                                                                                                                                                                                                                                                              Package v1 is the v1 version of the API.
                                                                                                                                                                                                                                                              k8s/apis/apiextensions/v1beta1
                                                                                                                                                                                                                                                              Package v1beta1 is the v1beta1 version of the API.
                                                                                                                                                                                                                                                              Package v1beta1 is the v1beta1 version of the API.
                                                                                                                                                                                                                                                              k8s/apis/labels
                                                                                                                                                                                                                                                              Package labels implements a simple label system, parsing and matching selectors with sets of labels.
                                                                                                                                                                                                                                                              Package labels implements a simple label system, parsing and matching selectors with sets of labels.
                                                                                                                                                                                                                                                              k8s/apis/meta/v1
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              k8s/apis/meta/v1beta1
                                                                                                                                                                                                                                                              package v1beta1 is alpha objects from meta that will be introduced.
                                                                                                                                                                                                                                                              package v1beta1 is alpha objects from meta that will be introduced.
                                                                                                                                                                                                                                                              k8s/apis/util/intstr
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated clientset.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/fake
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              This package has the automatically generated fake clientset.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/scheme
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              This package contains the scheme of the automatically generated clientset.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/core/v1
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/core/v1/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/discovery/v1beta1
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/discovery/v1beta1/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/networking/v1
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              This package has the automatically generated typed clients.
                                                                                                                                                                                                                                                              k8s/client/clientset/versioned/typed/networking/v1/fake
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package fake has the automatically generated clients.
                                                                                                                                                                                                                                                              Package synced provides tools for tracking if k8s resources have been initially sychronized with the k8s apiserver.
                                                                                                                                                                                                                                                              Package synced provides tools for tracking if k8s resources have been initially sychronized with the k8s apiserver.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package types contains slimmer versions of k8s types.
                                                                                                                                                                                                                                                              Package version keeps track of the Kubernetes version the client is connected to
                                                                                                                                                                                                                                                              Package version keeps track of the Kubernetes version the client is connected to