Documentation

Overview

    Package kubelet is the package that contains the libraries that drive the Kubelet binary. The kubelet is responsible for node level pod management. It runs on each worker in the cluster.

    Index

    Constants

    View Source
    const (
    
    	// ContainerLogsDir is the location of container logs.
    	ContainerLogsDir = "/var/log/containers"
    
    	// MaxContainerBackOff is the max backoff period, exported for the e2e test
    	MaxContainerBackOff = 300 * time.Second
    
    	// ContainerGCPeriod is the period for performing container garbage collection.
    	ContainerGCPeriod = time.Minute
    	// ImageGCPeriod is the period for performing image garbage collection.
    	ImageGCPeriod = 5 * time.Minute
    )
    View Source
    const (
    	// KubeMarkMasqChain is the mark-for-masquerade chain
    	// TODO: clean up this logic in kube-proxy
    	KubeMarkMasqChain utiliptables.Chain = "KUBE-MARK-MASQ"
    
    	// KubeMarkDropChain is the mark-for-drop chain
    	KubeMarkDropChain utiliptables.Chain = "KUBE-MARK-DROP"
    
    	// KubePostroutingChain is kubernetes postrouting rules
    	KubePostroutingChain utiliptables.Chain = "KUBE-POSTROUTING"
    
    	// KubeFirewallChain is kubernetes firewall rules
    	KubeFirewallChain utiliptables.Chain = "KUBE-FIREWALL"
    )
    View Source
    const (
    	NetworkNotReadyErrorMsg = "network is not ready"
    )

    Variables

    View Source
    var (
    	ErrNetworkUnknown = errors.New("network state unknown")
    )

    Functions

    func NewInitializedVolumePluginMgr

    func NewInitializedVolumePluginMgr(
    	kubelet *Kubelet,
    	secretManager secret.Manager,
    	configMapManager configmap.Manager,
    	tokenManager *token.Manager,
    	plugins []volume.VolumePlugin,
    	prober volume.DynamicPluginProber) (*volume.VolumePluginMgr, error)

      NewInitializedVolumePluginMgr returns a new instance of volume.VolumePluginMgr initialized with kubelets implementation of the volume.VolumeHost interface.

      kubelet - used by VolumeHost methods to expose kubelet specific parameters plugins - used to initialize volumePluginMgr

      Types

      type Bootstrap

      type Bootstrap interface {
      	GetConfiguration() kubeletconfiginternal.KubeletConfiguration
      	BirthCry()
      	StartGarbageCollection()
      	ListenAndServe(address net.IP, port uint, tlsOptions *server.TLSOptions, auth server.AuthInterface, enableDebuggingHandlers, enableContentionProfiling bool)
      	ListenAndServeReadOnly(address net.IP, port uint)
      	ListenAndServePodResources()
      	Run(<-chan kubetypes.PodUpdate)
      	RunOnce(<-chan kubetypes.PodUpdate) ([]RunPodResult, error)
      }

        Bootstrap is a bootstrapping interface for kubelet, targets the initialization protocol

        type Builder

        type Builder func(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
        	kubeDeps *Dependencies,
        	crOptions *config.ContainerRuntimeOptions,
        	containerRuntime string,
        	runtimeCgroups string,
        	hostnameOverride string,
        	nodeIP string,
        	providerID string,
        	cloudProvider string,
        	certDirectory string,
        	rootDirectory string,
        	registerNode bool,
        	registerWithTaints []api.Taint,
        	allowedUnsafeSysctls []string,
        	remoteRuntimeEndpoint string,
        	remoteImageEndpoint string,
        	experimentalMounterPath string,
        	experimentalKernelMemcgNotification bool,
        	experimentalCheckNodeCapabilitiesBeforeMount bool,
        	experimentalNodeAllocatableIgnoreEvictionThreshold bool,
        	minimumGCAge metav1.Duration,
        	maxPerPodContainerCount int32,
        	maxContainerCount int32,
        	masterServiceNamespace string,
        	registerSchedulable bool,
        	nonMasqueradeCIDR string,
        	keepTerminatedPodVolumes bool,
        	nodeLabels map[string]string,
        	seccompProfileRoot string,
        	bootstrapCheckpointPath string,
        	nodeStatusMaxImages int32) (Bootstrap, error)

          Builder creates and initializes a Kubelet instance

          type Dependencies

          type Dependencies struct {
          	Options []Option
          
          	// Injected Dependencies
          	Auth                    server.AuthInterface
          	CAdvisorInterface       cadvisor.Interface
          	Cloud                   cloudprovider.Interface
          	ContainerManager        cm.ContainerManager
          	DockerClientConfig      *dockershim.ClientConfig
          	EventClient             v1core.EventsGetter
          	HeartbeatClient         clientset.Interface
          	OnHeartbeatFailure      func()
          	KubeClient              clientset.Interface
          	Mounter                 mount.Interface
          	OOMAdjuster             *oom.OOMAdjuster
          	OSInterface             kubecontainer.OSInterface
          	PodConfig               *config.PodConfig
          	Recorder                record.EventRecorder
          	Subpather               subpath.Interface
          	VolumePlugins           []volume.VolumePlugin
          	DynamicPluginProber     volume.DynamicPluginProber
          	TLSOptions              *server.TLSOptions
          	KubeletConfigController *kubeletconfig.Controller
          }

            Dependencies is a bin for things we might consider "injected dependencies" -- objects constructed at runtime that are necessary for running the Kubelet. This is a temporary solution for grouping these objects while we figure out a more comprehensive dependency injection story for the Kubelet.

            type KillPodOptions

            type KillPodOptions struct {
            	// PodStatusFunc is the function to invoke to set pod status in response to a kill request.
            	PodStatusFunc PodStatusFunc
            	// PodTerminationGracePeriodSecondsOverride is optional override to use if a pod is being killed as part of kill operation.
            	PodTerminationGracePeriodSecondsOverride *int64
            }

              KillPodOptions are options when performing a pod update whose update type is kill.

              type Kubelet

              type Kubelet struct {
              
              	// the list of handlers to call during pod sync loop.
              	lifecycle.PodSyncLoopHandlers
              
              	// the list of handlers to call during pod sync.
              	lifecycle.PodSyncHandlers
              
              	// StatsProvider provides the node and the container stats.
              	*stats.StatsProvider
              	// contains filtered or unexported fields
              }

                Kubelet is the main kubelet implementation.

                func NewMainKubelet

                func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
                	kubeDeps *Dependencies,
                	crOptions *config.ContainerRuntimeOptions,
                	containerRuntime string,
                	runtimeCgroups string,
                	hostnameOverride string,
                	nodeIP string,
                	providerID string,
                	cloudProvider string,
                	certDirectory string,
                	rootDirectory string,
                	registerNode bool,
                	registerWithTaints []api.Taint,
                	allowedUnsafeSysctls []string,
                	remoteRuntimeEndpoint string,
                	remoteImageEndpoint string,
                	experimentalMounterPath string,
                	experimentalKernelMemcgNotification bool,
                	experimentalCheckNodeCapabilitiesBeforeMount bool,
                	experimentalNodeAllocatableIgnoreEvictionThreshold bool,
                	minimumGCAge metav1.Duration,
                	maxPerPodContainerCount int32,
                	maxContainerCount int32,
                	masterServiceNamespace string,
                	registerSchedulable bool,
                	nonMasqueradeCIDR string,
                	keepTerminatedPodVolumes bool,
                	nodeLabels map[string]string,
                	seccompProfileRoot string,
                	bootstrapCheckpointPath string,
                	nodeStatusMaxImages int32) (*Kubelet, error)

                  NewMainKubelet instantiates a new Kubelet object along with all the required internal modules. No initialization of Kubelet and its modules should happen here.

                  func (*Kubelet) BirthCry

                  func (kl *Kubelet) BirthCry()

                    BirthCry sends an event that the kubelet has started up.

                    func (*Kubelet) GeneratePodHostNameAndDomain

                    func (kl *Kubelet) GeneratePodHostNameAndDomain(pod *v1.Pod) (string, string, error)

                      GeneratePodHostNameAndDomain creates a hostname and domain name for a pod, given that pod's spec and annotations or returns an error.

                      func (*Kubelet) GenerateRunContainerOptions

                      func (kl *Kubelet) GenerateRunContainerOptions(pod *v1.Pod, container *v1.Container, podIP string) (*kubecontainer.RunContainerOptions, func(), error)

                        GenerateRunContainerOptions generates the RunContainerOptions, which can be used by the container runtime to set parameters for launching a container.

                        func (*Kubelet) GetActivePods

                        func (kl *Kubelet) GetActivePods() []*v1.Pod

                          GetActivePods returns non-terminal pods

                          func (*Kubelet) GetAttach

                          func (kl *Kubelet) GetAttach(podFullName string, podUID types.UID, containerName string, streamOpts remotecommandserver.Options) (*url.URL, error)

                            GetAttach gets the URL the attach will be served from, or nil if the Kubelet will serve it.

                            func (*Kubelet) GetCachedMachineInfo

                            func (kl *Kubelet) GetCachedMachineInfo() (*cadvisorapiv1.MachineInfo, error)

                              GetCachedMachineInfo assumes that the machine info can't change without a reboot

                              func (*Kubelet) GetConfiguration

                              func (kl *Kubelet) GetConfiguration() kubeletconfiginternal.KubeletConfiguration

                                GetConfiguration returns the KubeletConfiguration used to configure the kubelet.

                                func (*Kubelet) GetExec

                                func (kl *Kubelet) GetExec(podFullName string, podUID types.UID, containerName string, cmd []string, streamOpts remotecommandserver.Options) (*url.URL, error)

                                  GetExec gets the URL the exec will be served from, or nil if the Kubelet will serve it.

                                  func (*Kubelet) GetExtraSupplementalGroupsForPod

                                  func (kl *Kubelet) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64

                                    GetExtraSupplementalGroupsForPod returns a list of the extra supplemental groups for the Pod. These extra supplemental groups come from annotations on persistent volumes that the pod depends on.

                                    func (*Kubelet) GetHostIP

                                    func (kl *Kubelet) GetHostIP() (net.IP, error)

                                      GetHostIP returns host IP or nil in case of error.

                                      func (*Kubelet) GetHostname

                                      func (kl *Kubelet) GetHostname() string

                                        GetHostname Returns the hostname as the kubelet sees it.

                                        func (*Kubelet) GetKubeletContainerLogs

                                        func (kl *Kubelet) GetKubeletContainerLogs(ctx context.Context, podFullName, containerName string, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) error

                                          GetKubeletContainerLogs returns logs from the container TODO: this method is returning logs of random container attempts, when it should be returning the most recent attempt or all of them.

                                          func (*Kubelet) GetNode

                                          func (kl *Kubelet) GetNode() (*v1.Node, error)

                                            GetNode returns the node info for the configured node name of this Kubelet.

                                            func (*Kubelet) GetNodeConfig

                                            func (kl *Kubelet) GetNodeConfig() cm.NodeConfig

                                              GetNodeConfig returns the container manager node config.

                                              func (*Kubelet) GetPodByCgroupfs

                                              func (kl *Kubelet) GetPodByCgroupfs(cgroupfs string) (*v1.Pod, bool)

                                                GetPodByCgroupfs provides the pod that maps to the specified cgroup, as well as whether the pod was found.

                                                func (*Kubelet) GetPodByFullName

                                                func (kl *Kubelet) GetPodByFullName(podFullName string) (*v1.Pod, bool)

                                                  GetPodByFullName gets the pod with the given 'full' name, which incorporates the namespace as well as whether the pod was found.

                                                  func (*Kubelet) GetPodByName

                                                  func (kl *Kubelet) GetPodByName(namespace, name string) (*v1.Pod, bool)

                                                    GetPodByName provides the first pod that matches namespace and name, as well as whether the pod was found.

                                                    func (*Kubelet) GetPodCgroupParent

                                                    func (kl *Kubelet) GetPodCgroupParent(pod *v1.Pod) string

                                                      GetPodCgroupParent gets pod cgroup parent from container manager.

                                                      func (*Kubelet) GetPodCgroupRoot

                                                      func (kl *Kubelet) GetPodCgroupRoot() string

                                                        GetPodCgroupRoot returns the listeral cgroupfs value for the cgroup containing all pods

                                                        func (*Kubelet) GetPodDNS

                                                        func (kl *Kubelet) GetPodDNS(pod *v1.Pod) (*runtimeapi.DNSConfig, error)

                                                          GetPodDNS returns DNS settings for the pod. This function is defined in kubecontainer.RuntimeHelper interface so we have to implement it.

                                                          func (*Kubelet) GetPodDir

                                                          func (kl *Kubelet) GetPodDir(podUID types.UID) string

                                                            GetPodDir returns the full path to the per-pod data directory for the specified pod. This directory may not exist if the pod does not exist.

                                                            func (*Kubelet) GetPods

                                                            func (kl *Kubelet) GetPods() []*v1.Pod

                                                              GetPods returns all pods bound to the kubelet and their spec, and the mirror pods.

                                                              func (*Kubelet) GetPortForward

                                                              func (kl *Kubelet) GetPortForward(podName, podNamespace string, podUID types.UID, portForwardOpts portforward.V4Options) (*url.URL, error)

                                                                GetPortForward gets the URL the port-forward will be served from, or nil if the Kubelet will serve it.

                                                                func (*Kubelet) GetRunningPods

                                                                func (kl *Kubelet) GetRunningPods() ([]*v1.Pod, error)

                                                                  GetRunningPods returns all pods running on kubelet from looking at the container runtime cache. This function converts kubecontainer.Pod to v1.Pod, so only the fields that exist in both kubecontainer.Pod and v1.Pod are considered meaningful.

                                                                  func (*Kubelet) GetVersionInfo

                                                                  func (kl *Kubelet) GetVersionInfo() (*cadvisorapiv1.VersionInfo, error)

                                                                    GetVersionInfo returns information about the version of cAdvisor in use.

                                                                    func (*Kubelet) HandlePodAdditions

                                                                    func (kl *Kubelet) HandlePodAdditions(pods []*v1.Pod)

                                                                      HandlePodAdditions is the callback in SyncHandler for pods being added from a config source.

                                                                      func (*Kubelet) HandlePodCleanups

                                                                      func (kl *Kubelet) HandlePodCleanups() error

                                                                        HandlePodCleanups performs a series of cleanup work, including terminating pod workers, killing unwanted pods, and removing orphaned volumes/pod directories. NOTE: This function is executed by the main sync loop, so it should not contain any blocking calls.

                                                                        func (*Kubelet) HandlePodReconcile

                                                                        func (kl *Kubelet) HandlePodReconcile(pods []*v1.Pod)

                                                                          HandlePodReconcile is the callback in the SyncHandler interface for pods that should be reconciled.

                                                                          func (*Kubelet) HandlePodRemoves

                                                                          func (kl *Kubelet) HandlePodRemoves(pods []*v1.Pod)

                                                                            HandlePodRemoves is the callback in the SyncHandler interface for pods being removed from a config source.

                                                                            func (*Kubelet) HandlePodSyncs

                                                                            func (kl *Kubelet) HandlePodSyncs(pods []*v1.Pod)

                                                                              HandlePodSyncs is the callback in the syncHandler interface for pods that should be dispatched to pod workers for sync.

                                                                              func (*Kubelet) HandlePodUpdates

                                                                              func (kl *Kubelet) HandlePodUpdates(pods []*v1.Pod)

                                                                                HandlePodUpdates is the callback in the SyncHandler interface for pods being updated from a config source.

                                                                                func (*Kubelet) IsPodDeleted

                                                                                func (kl *Kubelet) IsPodDeleted(uid types.UID) bool

                                                                                  IsPodDeleted returns true if the pod is deleted. For the pod to be deleted, either: 1. The pod object is deleted 2. The pod's status is evicted 3. The pod's deletion timestamp is set, and containers are not running

                                                                                  func (*Kubelet) IsPodTerminated

                                                                                  func (kl *Kubelet) IsPodTerminated(uid types.UID) bool

                                                                                    IsPodTerminated returns true if the pod with the provided UID is in a terminated state ("Failed" or "Succeeded") or if the pod has been deleted or removed

                                                                                    func (*Kubelet) LatestLoopEntryTime

                                                                                    func (kl *Kubelet) LatestLoopEntryTime() time.Time

                                                                                      LatestLoopEntryTime returns the last time in the sync loop monitor.

                                                                                      func (*Kubelet) ListVolumesForPod

                                                                                      func (kl *Kubelet) ListVolumesForPod(podUID types.UID) (map[string]volume.Volume, bool)

                                                                                        ListVolumesForPod returns a map of the mounted volumes for the given pod. The key in the map is the OuterVolumeSpecName (i.e. pod.Spec.Volumes[x].Name)

                                                                                        func (*Kubelet) ListenAndServe

                                                                                        func (kl *Kubelet) ListenAndServe(address net.IP, port uint, tlsOptions *server.TLSOptions, auth server.AuthInterface, enableDebuggingHandlers, enableContentionProfiling bool)

                                                                                          ListenAndServe runs the kubelet HTTP server.

                                                                                          func (*Kubelet) ListenAndServePodResources

                                                                                          func (kl *Kubelet) ListenAndServePodResources()

                                                                                            ListenAndServePodResources runs the kubelet podresources grpc service

                                                                                            func (*Kubelet) ListenAndServeReadOnly

                                                                                            func (kl *Kubelet) ListenAndServeReadOnly(address net.IP, port uint)

                                                                                              ListenAndServeReadOnly runs the kubelet HTTP server in read-only mode.

                                                                                              func (*Kubelet) PodResourcesAreReclaimed

                                                                                              func (kl *Kubelet) PodResourcesAreReclaimed(pod *v1.Pod, status v1.PodStatus) bool

                                                                                                PodResourcesAreReclaimed returns true if all required node-level resources that a pod was consuming have been reclaimed by the kubelet. Reclaiming resources is a prerequisite to deleting a pod from the API server.

                                                                                                func (*Kubelet) ResyncInterval

                                                                                                func (kl *Kubelet) ResyncInterval() time.Duration

                                                                                                  ResyncInterval returns the interval used for periodic syncs.

                                                                                                  func (*Kubelet) Run

                                                                                                  func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate)

                                                                                                    Run starts the kubelet reacting to config updates

                                                                                                    func (*Kubelet) RunInContainer

                                                                                                    func (kl *Kubelet) RunInContainer(podFullName string, podUID types.UID, containerName string, cmd []string) ([]byte, error)

                                                                                                      RunInContainer runs a command in a container, returns the combined stdout, stderr as an array of bytes

                                                                                                      func (*Kubelet) RunOnce

                                                                                                      func (kl *Kubelet) RunOnce(updates <-chan kubetypes.PodUpdate) ([]RunPodResult, error)

                                                                                                        RunOnce polls from one configuration update and run the associated pods.

                                                                                                        func (*Kubelet) ServeLogs

                                                                                                        func (kl *Kubelet) ServeLogs(w http.ResponseWriter, req *http.Request)

                                                                                                          ServeLogs returns logs of current machine.

                                                                                                          func (*Kubelet) StartGarbageCollection

                                                                                                          func (kl *Kubelet) StartGarbageCollection()

                                                                                                            StartGarbageCollection starts garbage collection threads.

                                                                                                            type OOMWatcher

                                                                                                            type OOMWatcher interface {
                                                                                                            	Start(ref *v1.ObjectReference) error
                                                                                                            }

                                                                                                              OOMWatcher defines the interface of OOM watchers.

                                                                                                              func NewOOMWatcher

                                                                                                              func NewOOMWatcher(cadvisor cadvisor.Interface, recorder record.EventRecorder) OOMWatcher

                                                                                                                NewOOMWatcher creates and initializes a OOMWatcher based on parameters.

                                                                                                                type OnCompleteFunc

                                                                                                                type OnCompleteFunc func(err error)

                                                                                                                  OnCompleteFunc is a function that is invoked when an operation completes. If err is non-nil, the operation did not complete successfully.

                                                                                                                  type Option

                                                                                                                  type Option func(*Kubelet)

                                                                                                                    Option is a functional option type for Kubelet

                                                                                                                    type PodStatusFunc

                                                                                                                    type PodStatusFunc func(pod *v1.Pod, podStatus *kubecontainer.PodStatus) v1.PodStatus

                                                                                                                      PodStatusFunc is a function that is invoked to generate a pod status.

                                                                                                                      type PodWorkers

                                                                                                                      type PodWorkers interface {
                                                                                                                      	UpdatePod(options *UpdatePodOptions)
                                                                                                                      	ForgetNonExistingPodWorkers(desiredPods map[types.UID]empty)
                                                                                                                      	ForgetWorker(uid types.UID)
                                                                                                                      }

                                                                                                                        PodWorkers is an abstract interface for testability.

                                                                                                                        type ReasonCache

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

                                                                                                                          ReasonCache stores the failure reason of the latest container start in a string, keyed by <pod_UID>_<container_name>. The goal is to propagate this reason to the container status. This endeavor is "best-effort" for two reasons:

                                                                                                                          1. The cache is not persisted.
                                                                                                                          2. We use an LRU cache to avoid extra garbage collection work. This
                                                                                                                             means that some entries may be recycled before a pod has been
                                                                                                                             deleted.
                                                                                                                          

                                                                                                                          TODO(random-liu): Use more reliable cache which could collect garbage of failed pod. TODO(random-liu): Move reason cache to somewhere better.

                                                                                                                          func NewReasonCache

                                                                                                                          func NewReasonCache() *ReasonCache

                                                                                                                            NewReasonCache creates an instance of 'ReasonCache'.

                                                                                                                            func (*ReasonCache) Get

                                                                                                                            func (c *ReasonCache) Get(uid types.UID, name string) (*reasonItem, bool)

                                                                                                                              Get gets error reason from the cache. The return values are error reason, error message and whether an error reason is found in the cache. If no error reason is found, empty string will be returned for error reason and error message.

                                                                                                                              func (*ReasonCache) Remove

                                                                                                                              func (c *ReasonCache) Remove(uid types.UID, name string)

                                                                                                                                Remove removes error reason from the cache

                                                                                                                                func (*ReasonCache) Update

                                                                                                                                func (c *ReasonCache) Update(uid types.UID, result kubecontainer.PodSyncResult)

                                                                                                                                  Update updates the reason cache with the SyncPodResult. Only SyncResult with StartContainer action will change the cache.

                                                                                                                                  type RunPodResult

                                                                                                                                  type RunPodResult struct {
                                                                                                                                  	Pod *v1.Pod
                                                                                                                                  	Err error
                                                                                                                                  }

                                                                                                                                    RunPodResult defines the running results of a Pod.

                                                                                                                                    type SyncHandler

                                                                                                                                    type SyncHandler interface {
                                                                                                                                    	HandlePodAdditions(pods []*v1.Pod)
                                                                                                                                    	HandlePodUpdates(pods []*v1.Pod)
                                                                                                                                    	HandlePodRemoves(pods []*v1.Pod)
                                                                                                                                    	HandlePodReconcile(pods []*v1.Pod)
                                                                                                                                    	HandlePodSyncs(pods []*v1.Pod)
                                                                                                                                    	HandlePodCleanups() error
                                                                                                                                    }

                                                                                                                                      SyncHandler is an interface implemented by Kubelet, for testability

                                                                                                                                      type UpdatePodOptions

                                                                                                                                      type UpdatePodOptions struct {
                                                                                                                                      	// pod to update
                                                                                                                                      	Pod *v1.Pod
                                                                                                                                      	// the mirror pod for the pod to update, if it is a static pod
                                                                                                                                      	MirrorPod *v1.Pod
                                                                                                                                      	// the type of update (create, update, sync, kill)
                                                                                                                                      	UpdateType kubetypes.SyncPodType
                                                                                                                                      	// optional callback function when operation completes
                                                                                                                                      	// this callback is not guaranteed to be completed since a pod worker may
                                                                                                                                      	// drop update requests if it was fulfilling a previous request.  this is
                                                                                                                                      	// only guaranteed to be invoked in response to a kill pod request which is
                                                                                                                                      	// always delivered.
                                                                                                                                      	OnCompleteFunc OnCompleteFunc
                                                                                                                                      	// if update type is kill, use the specified options to kill the pod.
                                                                                                                                      	KillPodOptions *KillPodOptions
                                                                                                                                      }

                                                                                                                                        UpdatePodOptions is an options struct to pass to a UpdatePod operation.

                                                                                                                                        Directories

                                                                                                                                        Path Synopsis
                                                                                                                                        cri
                                                                                                                                        cri/runtime/v1alpha2
                                                                                                                                        Package v1alpha2 is a generated protocol buffer package.
                                                                                                                                        Package v1alpha2 is a generated protocol buffer package.
                                                                                                                                        deviceplugin/v1alpha
                                                                                                                                        Package deviceplugin is a generated protocol buffer package.
                                                                                                                                        Package deviceplugin is a generated protocol buffer package.
                                                                                                                                        deviceplugin/v1beta1
                                                                                                                                        Package v1beta1 is a generated protocol buffer package.
                                                                                                                                        Package v1beta1 is a generated protocol buffer package.
                                                                                                                                        pluginregistration/v1
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        pluginregistration/v1alpha1
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        pluginregistration/v1beta1
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        Package pluginregistration is a generated protocol buffer package.
                                                                                                                                        podresources/v1alpha1
                                                                                                                                        Package v1alpha1 is a generated protocol buffer package.
                                                                                                                                        Package v1alpha1 is a generated protocol buffer package.
                                                                                                                                        Kubelet interactions with cAdvisor.
                                                                                                                                        Kubelet interactions with cAdvisor.
                                                                                                                                        cm
                                                                                                                                        cpumanager/topology
                                                                                                                                        Package topology contains helpers for the CPU manager.
                                                                                                                                        Package topology contains helpers for the CPU manager.
                                                                                                                                        Reads the pod configuration from the Kubernetes apiserver.
                                                                                                                                        Reads the pod configuration from the Kubernetes apiserver.
                                                                                                                                        testing
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Package custommetrics contains support for instrumenting cAdvisor to gather custom metrics from pods.
                                                                                                                                        Package custommetrics contains support for instrumenting cAdvisor to gather custom metrics from pods.
                                                                                                                                        Docker integration using pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go
                                                                                                                                        Docker integration using pkg/kubelet/apis/cri/runtime/v1alpha2/api.pb.go
                                                                                                                                        cm
                                                                                                                                        network/cni/testing
                                                                                                                                        mock_cni is a mock of the `libcni.CNI` interface.
                                                                                                                                        mock_cni is a mock of the `libcni.CNI` interface.
                                                                                                                                        Package envvars is the package that build the environment variables that kubernetes provides to the containers run by it.
                                                                                                                                        Package envvars is the package that build the environment variables that kubernetes provides to the containers run by it.
                                                                                                                                        Package eviction is responsible for enforcing eviction thresholds to maintain node stability.
                                                                                                                                        Package eviction is responsible for enforcing eviction thresholds to maintain node stability.
                                                                                                                                        api
                                                                                                                                        Package images is responsible for managing lifecycle of container images.
                                                                                                                                        Package images is responsible for managing lifecycle of container images.
                                                                                                                                        Package kuberuntime contains an implementation of kubecontainer.Runtime using the interface in pkg/kubelet/v1.
                                                                                                                                        Package kuberuntime contains an implementation of kubecontainer.Runtime using the interface in pkg/kubelet/v1.
                                                                                                                                        Package leaky holds bits of kubelet that should be internal but have leaked out through bad abstractions.
                                                                                                                                        Package leaky holds bits of kubelet that should be internal but have leaked out through bad abstractions.
                                                                                                                                        Handlers for pod lifecycle events and interfaces to integrate with kubelet admission, synchronization, and eviction of pods.
                                                                                                                                        Handlers for pod lifecycle events and interfaces to integrate with kubelet admission, synchronization, and eviction of pods.
                                                                                                                                        network
                                                                                                                                        dns
                                                                                                                                        Package pleg contains types and a generic implementation of the pod lifecycle event generator.
                                                                                                                                        Package pleg contains types and a generic implementation of the pod lifecycle event generator.
                                                                                                                                        pod
                                                                                                                                        testing
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        Code generated by mockery v1.0.0
                                                                                                                                        package qos contains helper functions for quality of service.
                                                                                                                                        package qos contains helper functions for quality of service.
                                                                                                                                        Package remote contains gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package remote contains gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        fake
                                                                                                                                        Package fake containers a fake gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package fake containers a fake gRPC implementation of internalapi.RuntimeService and internalapi.ImageManagerService.
                                                                                                                                        Package server contains functions related to serving Kubelet's external interface.
                                                                                                                                        Package server contains functions related to serving Kubelet's external interface.
                                                                                                                                        portforward
                                                                                                                                        Package portforward contains server-side logic for handling port forwarding requests.
                                                                                                                                        Package portforward contains server-side logic for handling port forwarding requests.
                                                                                                                                        remotecommand
                                                                                                                                        Package remotecommand contains functions related to executing commands in and attaching to pods.
                                                                                                                                        Package remotecommand contains functions related to executing commands in and attaching to pods.
                                                                                                                                        stats
                                                                                                                                        Package stats handles exporting Kubelet and container stats.
                                                                                                                                        Package stats handles exporting Kubelet and container stats.
                                                                                                                                        Package token implements a manager of serviceaccount tokens for pods running on the node.
                                                                                                                                        Package token implements a manager of serviceaccount tokens for pods running on the node.
                                                                                                                                        Common types in the Kubelet.
                                                                                                                                        Common types in the Kubelet.
                                                                                                                                        Utility functions.
                                                                                                                                        Utility functions.
                                                                                                                                        pluginwatcher/example_plugin_apis/v1beta1
                                                                                                                                        Package v1beta1 is a generated protocol buffer package.
                                                                                                                                        Package v1beta1 is a generated protocol buffer package.
                                                                                                                                        pluginwatcher/example_plugin_apis/v1beta2
                                                                                                                                        Package v1beta2 is a generated protocol buffer package.
                                                                                                                                        Package v1beta2 is a generated protocol buffer package.
                                                                                                                                        store
                                                                                                                                        Package store hosts a Store interface and its implementations.
                                                                                                                                        Package store hosts a Store interface and its implementations.
                                                                                                                                        cache
                                                                                                                                        Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                                                                                                                                        Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                                                                                                                                        populator
                                                                                                                                        Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                                                                                                                                        Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                                                                                                                                        reconciler
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).
                                                                                                                                        Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).
                                                                                                                                        Package winstats provides a client to get node and pod level stats on windows
                                                                                                                                        Package winstats provides a client to get node and pod level stats on windows