Documentation

Index

Constants

View Source
const (
	// MaxPodTerminationMessageLogLength is the maximum bytes any one pod may have written
	// as termination message output across all containers. Containers will be evenly truncated
	// until output is below this limit.
	MaxPodTerminationMessageLogLength = 1024 * 12
	// MaxContainerTerminationMessageLength is the upper bound any one container may write to
	// its termination message path. Contents above this length will be truncated.
	MaxContainerTerminationMessageLength = 1024 * 4
	// MaxContainerTerminationMessageLogLength is the maximum bytes any one container will
	// have written to its termination message when the message is read from the logs.
	MaxContainerTerminationMessageLogLength = 1024 * 2
	// MaxContainerTerminationMessageLogLines is the maximum number of previous lines of
	// log output that the termination message can contain.
	MaxContainerTerminationMessageLogLines = 80
)

Variables

View Source
var (
	ErrRunContainer     = errors.New("RunContainerError")
	ErrKillContainer    = errors.New("KillContainerError")
	ErrVerifyNonRoot    = errors.New("VerifyNonRootError")
	ErrRunInitContainer = errors.New("RunInitContainerError")
	ErrCreatePodSandbox = errors.New("CreatePodSandboxError")
	ErrConfigPodSandbox = errors.New("ConfigPodSandboxError")
	ErrKillPodSandbox   = errors.New("KillPodSandboxError")
)
View Source
var (
	ErrSetupNetwork    = errors.New("SetupNetworkError")
	ErrTeardownNetwork = errors.New("TeardownNetworkError")
)
View Source
var (
	// ErrContainerNotFound returned when a container in the given pod with the
	// given container name was not found, amongst those managed by the kubelet.
	ErrContainerNotFound = errors.New("no matching container")
)
View Source
var ErrCrashLoopBackOff = errors.New("CrashLoopBackOff")

    Container Terminated and Kubelet is backing off the restart

    View Source
    var ImplicitContainerPrefix string = "implicitly required container "

    Functions

    func BuildPodFullName

    func BuildPodFullName(name, namespace string) string

      Build the pod full name from pod name and namespace.

      func EnvVarsToMap

      func EnvVarsToMap(envs []EnvVar) map[string]string

        EnvVarsToMap constructs a map of environment name to value from a slice of env vars.

        func ExpandContainerCommandAndArgs

        func ExpandContainerCommandAndArgs(container *v1.Container, envs []EnvVar) (command []string, args []string)

        func ExpandContainerCommandOnlyStatic

        func ExpandContainerCommandOnlyStatic(containerCommand []string, envs []v1.EnvVar) (command []string)

          ExpandContainerCommandOnlyStatic substitutes only static environment variable values from the container environment definitions. This does *not* include valueFrom substitutions. TODO: callers should use ExpandContainerCommandAndArgs with a fully resolved list of environment.

          func ExpandContainerVolumeMounts

          func ExpandContainerVolumeMounts(mount v1.VolumeMount, envs []EnvVar) (string, error)

          func FilterEventRecorder

          func FilterEventRecorder(recorder record.EventRecorder) record.EventRecorder

            Create an event recorder to record object's event except implicitly required container's, like infra container.

            func FormatPod

            func FormatPod(pod *Pod) string

              FormatPod returns a string representing a pod in a human readable format, with pod UID as part of the string.

              func GenerateContainerRef

              func GenerateContainerRef(pod *v1.Pod, container *v1.Container) (*v1.ObjectReference, error)

                GenerateContainerRef returns an *v1.ObjectReference which references the given container within the given pod. Returns an error if the reference can't be constructed or the container doesn't actually belong to the pod.

                This function will return an error if the provided Pod does not have a selfLink, but we expect selfLink to be populated at all call sites for the function.

                func GetContainerSpec

                func GetContainerSpec(pod *v1.Pod, containerName string) *v1.Container

                  GetContainerSpec gets the container spec by containerName.

                  func GetPodFullName

                  func GetPodFullName(pod *v1.Pod) string

                    GetPodFullName returns a name that uniquely identifies a pod.

                    func HandleResizing

                    func HandleResizing(resize <-chan remotecommand.TerminalSize, resizeFunc func(size remotecommand.TerminalSize))

                      handleResizing spawns a goroutine that processes the resize channel, calling resizeFunc for each remotecommand.TerminalSize received from the channel. The resize channel must be closed elsewhere to stop the goroutine.

                      func HasPrivilegedContainer

                      func HasPrivilegedContainer(pod *v1.Pod) bool

                        HasPrivilegedContainer returns true if any of the containers in the pod are privileged.

                        func HashContainer

                        func HashContainer(container *v1.Container) uint64

                          HashContainer returns the hash of the container. It is used to compare the running container with its desired spec.

                          func IsHostNetworkPod

                          func IsHostNetworkPod(pod *v1.Pod) bool

                            Pod must not be nil.

                            func ParsePodFullName

                            func ParsePodFullName(podFullName string) (string, string, error)

                              Parse the pod full name.

                              func ShouldContainerBeRestarted

                              func ShouldContainerBeRestarted(container *v1.Container, pod *v1.Pod, podStatus *PodStatus) bool

                                ShouldContainerBeRestarted checks whether a container needs to be restarted. TODO(yifan): Think about how to refactor this.

                                func V1EnvVarsToMap

                                func V1EnvVarsToMap(envs []v1.EnvVar) map[string]string

                                  V1EnvVarsToMap constructs a map of environment name to value from a slice of env vars.

                                  Types

                                  type Annotation

                                  type Annotation struct {
                                  	Name  string
                                  	Value string
                                  }

                                  type Cache

                                  type Cache interface {
                                  	Get(types.UID) (*PodStatus, error)
                                  	Set(types.UID, *PodStatus, error, time.Time)
                                  	// GetNewerThan is a blocking call that only returns the status
                                  	// when it is newer than the given time.
                                  	GetNewerThan(types.UID, time.Time) (*PodStatus, error)
                                  	Delete(types.UID)
                                  	UpdateTime(time.Time)
                                  }

                                    Cache stores the PodStatus for the pods. It represents *all* the visible pods/containers in the container runtime. All cache entries are at least as new or newer than the global timestamp (set by UpdateTime()), while individual entries may be slightly newer than the global timestamp. If a pod has no states known by the runtime, Cache returns an empty PodStatus object with ID populated.

                                    Cache provides two methods to retrive the PodStatus: the non-blocking Get() and the blocking GetNewerThan() method. The component responsible for populating the cache is expected to call Delete() to explicitly free the cache entries.

                                    func NewCache

                                    func NewCache() Cache

                                      NewCache creates a pod cache.

                                      type Container

                                      type Container struct {
                                      	// The ID of the container, used by the container runtime to identify
                                      	// a container.
                                      	ID ContainerID
                                      	// The name of the container, which should be the same as specified by
                                      	// v1.Container.
                                      	Name string
                                      	// The image name of the container, this also includes the tag of the image,
                                      	// the expected form is "NAME:TAG".
                                      	Image string
                                      	// The id of the image used by the container.
                                      	ImageID string
                                      	// Hash of the container, used for comparison. Optional for containers
                                      	// not managed by kubelet.
                                      	Hash uint64
                                      	// State is the state of the container.
                                      	State ContainerState
                                      }

                                        Container provides the runtime information for a container, such as ID, hash, state of the container.

                                        type ContainerAttacher

                                        type ContainerAttacher interface {
                                        	AttachContainer(id ContainerID, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize <-chan remotecommand.TerminalSize) (err error)
                                        }

                                        type ContainerCommandRunner

                                        type ContainerCommandRunner interface {
                                        	// RunInContainer synchronously executes the command in the container, and returns the output.
                                        	// If the command completes with a non-0 exit code, a k8s.io/utils/exec.ExitError will be returned.
                                        	RunInContainer(id ContainerID, cmd []string, timeout time.Duration) ([]byte, error)
                                        }

                                        type ContainerGC

                                        type ContainerGC interface {
                                        	// Garbage collect containers.
                                        	GarbageCollect() error
                                        	// Deletes all unused containers, including containers belonging to pods that are terminated but not deleted
                                        	DeleteAllUnusedContainers() error
                                        }

                                          Manages garbage collection of dead containers.

                                          Implementation is thread-compatible.

                                          func NewContainerGC

                                          func NewContainerGC(runtime Runtime, policy ContainerGCPolicy, sourcesReadyProvider SourcesReadyProvider) (ContainerGC, error)

                                            New ContainerGC instance with the specified policy.

                                            type ContainerGCPolicy

                                            type ContainerGCPolicy struct {
                                            	// Minimum age at which a container can be garbage collected, zero for no limit.
                                            	MinAge time.Duration
                                            
                                            	// Max number of dead containers any single pod (UID, container name) pair is
                                            	// allowed to have, less than zero for no limit.
                                            	MaxPerPodContainer int
                                            
                                            	// Max number of total dead containers, less than zero for no limit.
                                            	MaxContainers int
                                            }

                                              Specified a policy for garbage collecting containers.

                                              type ContainerID

                                              type ContainerID struct {
                                              	// The type of the container runtime. e.g. 'docker'.
                                              	Type string
                                              	// The identification of the container, this is comsumable by
                                              	// the underlying container runtime. (Note that the container
                                              	// runtime interface still takes the whole struct as input).
                                              	ID string
                                              }

                                                ContainerID is a type that identifies a container.

                                                func BuildContainerID

                                                func BuildContainerID(typ, ID string) ContainerID

                                                func ParseContainerID

                                                func ParseContainerID(containerID string) ContainerID

                                                  Convenience method for creating a ContainerID from an ID string.

                                                  func (*ContainerID) IsEmpty

                                                  func (c *ContainerID) IsEmpty() bool

                                                  func (*ContainerID) MarshalJSON

                                                  func (c *ContainerID) MarshalJSON() ([]byte, error)

                                                  func (*ContainerID) ParseString

                                                  func (c *ContainerID) ParseString(data string) error

                                                  func (*ContainerID) String

                                                  func (c *ContainerID) String() string

                                                  func (*ContainerID) UnmarshalJSON

                                                  func (c *ContainerID) UnmarshalJSON(data []byte) error

                                                  type ContainerState

                                                  type ContainerState string
                                                  const (
                                                  	ContainerStateCreated ContainerState = "created"
                                                  	ContainerStateRunning ContainerState = "running"
                                                  	ContainerStateExited  ContainerState = "exited"
                                                  	// This unknown encompasses all the states that we currently don't care.
                                                  	ContainerStateUnknown ContainerState = "unknown"
                                                  )

                                                  func SandboxToContainerState

                                                  func SandboxToContainerState(state runtimeapi.PodSandboxState) ContainerState

                                                    SandboxToContainerState converts runtimeapi.PodSandboxState to kubecontainer.ContainerState. This is only needed because we need to return sandboxes as if they were kubecontainer.Containers to avoid substantial changes to PLEG. TODO: Remove this once it becomes obsolete.

                                                    type ContainerStatus

                                                    type ContainerStatus struct {
                                                    	// ID of the container.
                                                    	ID ContainerID
                                                    	// Name of the container.
                                                    	Name string
                                                    	// Status of the container.
                                                    	State ContainerState
                                                    	// Creation time of the container.
                                                    	CreatedAt time.Time
                                                    	// Start time of the container.
                                                    	StartedAt time.Time
                                                    	// Finish time of the container.
                                                    	FinishedAt time.Time
                                                    	// Exit code of the container.
                                                    	ExitCode int
                                                    	// Name of the image, this also includes the tag of the image,
                                                    	// the expected form is "NAME:TAG".
                                                    	Image string
                                                    	// ID of the image.
                                                    	ImageID string
                                                    	// Hash of the container, used for comparison.
                                                    	Hash uint64
                                                    	// Number of times that the container has been restarted.
                                                    	RestartCount int
                                                    	// A string explains why container is in such a status.
                                                    	Reason string
                                                    	// Message written by the container before exiting (stored in
                                                    	// TerminationMessagePath).
                                                    	Message string
                                                    }

                                                      ContainerStatus represents the status of a container.

                                                      type DeviceInfo

                                                      type DeviceInfo struct {
                                                      	// Path on host for mapping
                                                      	PathOnHost string
                                                      	// Path in Container to map
                                                      	PathInContainer string
                                                      	// Cgroup permissions
                                                      	Permissions string
                                                      }

                                                      type DockerID

                                                      type DockerID string

                                                        DockerID is an ID of docker container. It is a type to make it clear when we're working with docker container Ids

                                                        func (DockerID) ContainerID

                                                        func (id DockerID) ContainerID() ContainerID

                                                        type EnvVar

                                                        type EnvVar struct {
                                                        	Name  string
                                                        	Value string
                                                        }

                                                        type HandlerRunner

                                                        type HandlerRunner interface {
                                                        	Run(containerID ContainerID, pod *v1.Pod, container *v1.Container, handler *v1.Handler) (string, error)
                                                        }

                                                          HandlerRunner runs a lifecycle handler for a container.

                                                          type Image

                                                          type Image struct {
                                                          	// ID of the image.
                                                          	ID string
                                                          	// Other names by which this image is known.
                                                          	RepoTags []string
                                                          	// Digests by which this image is known.
                                                          	RepoDigests []string
                                                          	// The size of the image in bytes.
                                                          	Size int64
                                                          }

                                                            Basic information about a container image.

                                                            type ImageService

                                                            type ImageService interface {
                                                            	// PullImage pulls an image from the network to local storage using the supplied
                                                            	// secrets if necessary. It returns a reference (digest or ID) to the pulled image.
                                                            	PullImage(image ImageSpec, pullSecrets []v1.Secret, podSandboxConfig *runtimeapi.PodSandboxConfig) (string, error)
                                                            	// GetImageRef gets the reference (digest or ID) of the image which has already been in
                                                            	// the local storage. It returns ("", nil) if the image isn't in the local storage.
                                                            	GetImageRef(image ImageSpec) (string, error)
                                                            	// Gets all images currently on the machine.
                                                            	ListImages() ([]Image, error)
                                                            	// Removes the specified image.
                                                            	RemoveImage(image ImageSpec) error
                                                            	// Returns Image statistics.
                                                            	ImageStats() (*ImageStats, error)
                                                            }

                                                            type ImageSpec

                                                            type ImageSpec struct {
                                                            	Image string
                                                            }

                                                              ImageSpec is an internal representation of an image. Currently, it wraps the value of a Container's Image field, but in the future it will include more detailed information about the different image types.

                                                              type ImageStats

                                                              type ImageStats struct {
                                                              	// Total amount of storage consumed by existing images.
                                                              	TotalStorageBytes uint64
                                                              }

                                                                ImageStats contains statistics about all the images currently available.

                                                                type Mount

                                                                type Mount struct {
                                                                	// Name of the volume mount.
                                                                	// TODO(yifan): Remove this field, as this is not representing the unique name of the mount,
                                                                	// but the volume name only.
                                                                	Name string
                                                                	// Path of the mount within the container.
                                                                	ContainerPath string
                                                                	// Path of the mount on the host.
                                                                	HostPath string
                                                                	// Whether the mount is read-only.
                                                                	ReadOnly bool
                                                                	// Whether the mount needs SELinux relabeling
                                                                	SELinuxRelabel bool
                                                                	// Requested propagation mode
                                                                	Propagation runtimeapi.MountPropagation
                                                                }

                                                                type OSInterface

                                                                type OSInterface interface {
                                                                	MkdirAll(path string, perm os.FileMode) error
                                                                	Symlink(oldname string, newname string) error
                                                                	Stat(path string) (os.FileInfo, error)
                                                                	Remove(path string) error
                                                                	RemoveAll(path string) error
                                                                	Create(path string) (*os.File, error)
                                                                	Chmod(path string, perm os.FileMode) error
                                                                	Hostname() (name string, err error)
                                                                	Chtimes(path string, atime time.Time, mtime time.Time) error
                                                                	Pipe() (r *os.File, w *os.File, err error)
                                                                	ReadDir(dirname string) ([]os.FileInfo, error)
                                                                	Glob(pattern string) ([]string, error)
                                                                }

                                                                  OSInterface collects system level operations that need to be mocked out during tests.

                                                                  type Option

                                                                  type Option func(Runtime)

                                                                    Option is a functional option type for Runtime, useful for completely optional settings.

                                                                    type Pod

                                                                    type Pod struct {
                                                                    	// The ID of the pod, which can be used to retrieve a particular pod
                                                                    	// from the pod list returned by GetPods().
                                                                    	ID types.UID
                                                                    	// The name and namespace of the pod, which is readable by human.
                                                                    	Name      string
                                                                    	Namespace string
                                                                    	// List of containers that belongs to this pod. It may contain only
                                                                    	// running containers, or mixed with dead ones (when GetPods(true)).
                                                                    	Containers []*Container
                                                                    	// List of sandboxes associated with this pod. The sandboxes are converted
                                                                    	// to Container temporariliy to avoid substantial changes to other
                                                                    	// components. This is only populated by kuberuntime.
                                                                    	// TODO: use the runtimeApi.PodSandbox type directly.
                                                                    	Sandboxes []*Container
                                                                    }

                                                                      Pod is a group of containers.

                                                                      func ConvertPodStatusToRunningPod

                                                                      func ConvertPodStatusToRunningPod(runtimeName string, podStatus *PodStatus) Pod

                                                                        TODO(random-liu): Convert PodStatus to running Pod, should be deprecated soon

                                                                        func (*Pod) FindContainerByID

                                                                        func (p *Pod) FindContainerByID(id ContainerID) *Container

                                                                        func (*Pod) FindContainerByName

                                                                        func (p *Pod) FindContainerByName(containerName string) *Container

                                                                          FindContainerByName returns a container in the pod with the given name. When there are multiple containers with the same name, the first match will be returned.

                                                                          func (*Pod) FindSandboxByID

                                                                          func (p *Pod) FindSandboxByID(id ContainerID) *Container

                                                                          func (*Pod) IsEmpty

                                                                          func (p *Pod) IsEmpty() bool

                                                                            IsEmpty returns true if the pod is empty.

                                                                            func (*Pod) ToAPIPod

                                                                            func (p *Pod) ToAPIPod() *v1.Pod

                                                                              ToAPIPod converts Pod to v1.Pod. Note that if a field in v1.Pod has no corresponding field in Pod, the field would not be populated.

                                                                              type PodPair

                                                                              type PodPair struct {
                                                                              	// APIPod is the v1.Pod
                                                                              	APIPod *v1.Pod
                                                                              	// RunningPod is the pod defined in pkg/kubelet/container/runtime#Pod
                                                                              	RunningPod *Pod
                                                                              }

                                                                                PodPair contains both runtime#Pod and api#Pod

                                                                                type PodStatus

                                                                                type PodStatus struct {
                                                                                	// ID of the pod.
                                                                                	ID types.UID
                                                                                	// Name of the pod.
                                                                                	Name string
                                                                                	// Namespace of the pod.
                                                                                	Namespace string
                                                                                	// IP of the pod.
                                                                                	IP string
                                                                                	// Status of containers in the pod.
                                                                                	ContainerStatuses []*ContainerStatus
                                                                                	// Status of the pod sandbox.
                                                                                	// Only for kuberuntime now, other runtime may keep it nil.
                                                                                	SandboxStatuses []*runtimeapi.PodSandboxStatus
                                                                                }

                                                                                  PodStatus represents the status of the pod and its containers. v1.PodStatus can be derived from examining PodStatus and v1.Pod.

                                                                                  func (*PodStatus) FindContainerStatusByName

                                                                                  func (podStatus *PodStatus) FindContainerStatusByName(containerName string) *ContainerStatus

                                                                                    FindContainerStatusByName returns container status in the pod status with the given name. When there are multiple containers' statuses with the same name, the first match will be returned.

                                                                                    func (*PodStatus) GetRunningContainerStatuses

                                                                                    func (podStatus *PodStatus) GetRunningContainerStatuses() []*ContainerStatus

                                                                                      Get container status of all the running containers in a pod

                                                                                      type PodSyncResult

                                                                                      type PodSyncResult struct {
                                                                                      	// Result of different sync actions
                                                                                      	SyncResults []*SyncResult
                                                                                      	// Error encountered in SyncPod() and KillPod() that is not already included in SyncResults
                                                                                      	SyncError error
                                                                                      }

                                                                                        PodSyncResult is the summary result of SyncPod() and KillPod()

                                                                                        func (*PodSyncResult) AddPodSyncResult

                                                                                        func (p *PodSyncResult) AddPodSyncResult(result PodSyncResult)

                                                                                          AddPodSyncResult merges a PodSyncResult to current one

                                                                                          func (*PodSyncResult) AddSyncResult

                                                                                          func (p *PodSyncResult) AddSyncResult(result ...*SyncResult)

                                                                                            AddSyncResult adds multiple SyncResult to current PodSyncResult

                                                                                            func (*PodSyncResult) Error

                                                                                            func (p *PodSyncResult) Error() error

                                                                                              Error returns an error summarizing all the errors in PodSyncResult

                                                                                              func (*PodSyncResult) Fail

                                                                                              func (p *PodSyncResult) Fail(err error)

                                                                                                Fail fails the PodSyncResult with an error occurred in SyncPod() and KillPod() itself

                                                                                                type Pods

                                                                                                type Pods []*Pod

                                                                                                func (Pods) FindPod

                                                                                                func (p Pods) FindPod(podFullName string, podUID types.UID) Pod

                                                                                                  FindPod combines FindPodByID and FindPodByFullName, it finds and returns a pod in the pod list either by the full name or the pod ID. It will return an empty pod if not found.

                                                                                                  func (Pods) FindPodByFullName

                                                                                                  func (p Pods) FindPodByFullName(podFullName string) Pod

                                                                                                    FindPodByFullName finds and returns a pod in the pod list by the full name. It will return an empty pod if not found.

                                                                                                    func (Pods) FindPodByID

                                                                                                    func (p Pods) FindPodByID(podUID types.UID) Pod

                                                                                                      FindPodByID finds and returns a pod in the pod list by UID. It will return an empty pod if not found.

                                                                                                      type PortMapping

                                                                                                      type PortMapping struct {
                                                                                                      	// Name of the port mapping
                                                                                                      	Name string
                                                                                                      	// Protocol of the port mapping.
                                                                                                      	Protocol v1.Protocol
                                                                                                      	// The port number within the container.
                                                                                                      	ContainerPort int
                                                                                                      	// The port number on the host.
                                                                                                      	HostPort int
                                                                                                      	// The host IP.
                                                                                                      	HostIP string
                                                                                                      }

                                                                                                      func MakePortMappings

                                                                                                      func MakePortMappings(container *v1.Container) (ports []PortMapping)

                                                                                                        MakePortMappings creates internal port mapping from api port mapping.

                                                                                                        type RealOS

                                                                                                        type RealOS struct{}

                                                                                                          RealOS is used to dispatch the real system level operations.

                                                                                                          func (RealOS) Chmod

                                                                                                          func (RealOS) Chmod(path string, perm os.FileMode) error

                                                                                                            Chmod will change the permissions on the specified path or return an error.

                                                                                                            func (RealOS) Chtimes

                                                                                                            func (RealOS) Chtimes(path string, atime time.Time, mtime time.Time) error

                                                                                                              Chtimes will call os.Chtimes to change the atime and mtime of the path

                                                                                                              func (RealOS) Create

                                                                                                              func (RealOS) Create(path string) (*os.File, error)

                                                                                                                Create will call os.Create to create and return a file at path.

                                                                                                                func (RealOS) Glob

                                                                                                                func (RealOS) Glob(pattern string) ([]string, error)

                                                                                                                  Glob will call filepath.Glob to return the names of all files matching pattern.

                                                                                                                  func (RealOS) Hostname

                                                                                                                  func (RealOS) Hostname() (name string, err error)

                                                                                                                    Hostname will call os.Hostname to return the hostname.

                                                                                                                    func (RealOS) MkdirAll

                                                                                                                    func (RealOS) MkdirAll(path string, perm os.FileMode) error

                                                                                                                      MkdirAll will call os.MkdirAll to create a directory.

                                                                                                                      func (RealOS) Pipe

                                                                                                                      func (RealOS) Pipe() (r *os.File, w *os.File, err error)

                                                                                                                        Pipe will call os.Pipe to return a connected pair of pipe.

                                                                                                                        func (RealOS) ReadDir

                                                                                                                        func (RealOS) ReadDir(dirname string) ([]os.FileInfo, error)

                                                                                                                          ReadDir will call ioutil.ReadDir to return the files under the directory.

                                                                                                                          func (RealOS) Remove

                                                                                                                          func (RealOS) Remove(path string) error

                                                                                                                            Remove will call os.Remove to remove the path.

                                                                                                                            func (RealOS) RemoveAll

                                                                                                                            func (RealOS) RemoveAll(path string) error

                                                                                                                              RemoveAll will call os.RemoveAll to remove the path and its children.

                                                                                                                              func (RealOS) Stat

                                                                                                                              func (RealOS) Stat(path string) (os.FileInfo, error)

                                                                                                                                Stat will call os.Stat to get the FileInfo for a given path

                                                                                                                                func (RealOS) Symlink(oldname string, newname string) error

                                                                                                                                  Symlink will call os.Symlink to create a symbolic link.

                                                                                                                                  type RefManager

                                                                                                                                  type RefManager struct {
                                                                                                                                  	sync.RWMutex
                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                  }

                                                                                                                                    RefManager manages the references for the containers. The references are used for reporting events such as creation, failure, etc. This manager is thread-safe, no locks are necessary for the caller.

                                                                                                                                    func NewRefManager

                                                                                                                                    func NewRefManager() *RefManager

                                                                                                                                      NewRefManager creates and returns a container reference manager with empty contents.

                                                                                                                                      func (*RefManager) ClearRef

                                                                                                                                      func (c *RefManager) ClearRef(id ContainerID)

                                                                                                                                        ClearRef forgets the given container id and its associated container reference.

                                                                                                                                        func (*RefManager) GetRef

                                                                                                                                        func (c *RefManager) GetRef(id ContainerID) (ref *v1.ObjectReference, ok bool)

                                                                                                                                          GetRef returns the container reference of the given ID, or (nil, false) if none is stored.

                                                                                                                                          func (*RefManager) SetRef

                                                                                                                                          func (c *RefManager) SetRef(id ContainerID, ref *v1.ObjectReference)

                                                                                                                                            SetRef stores a reference to a pod's container, associating it with the given container ID.

                                                                                                                                            type RunContainerOptions

                                                                                                                                            type RunContainerOptions struct {
                                                                                                                                            	// The environment variables list.
                                                                                                                                            	Envs []EnvVar
                                                                                                                                            	// The mounts for the containers.
                                                                                                                                            	Mounts []Mount
                                                                                                                                            	// The host devices mapped into the containers.
                                                                                                                                            	Devices []DeviceInfo
                                                                                                                                            	// The port mappings for the containers.
                                                                                                                                            	PortMappings []PortMapping
                                                                                                                                            	// The annotations for the container
                                                                                                                                            	// These annotations are generated by other components (i.e.,
                                                                                                                                            	// not users). Currently, only device plugins populate the annotations.
                                                                                                                                            	Annotations []Annotation
                                                                                                                                            	// If the container has specified the TerminationMessagePath, then
                                                                                                                                            	// this directory will be used to create and mount the log file to
                                                                                                                                            	// container.TerminationMessagePath
                                                                                                                                            	PodContainerDir string
                                                                                                                                            	// The type of container rootfs
                                                                                                                                            	ReadOnly bool
                                                                                                                                            	// hostname for pod containers
                                                                                                                                            	Hostname string
                                                                                                                                            	// EnableHostUserNamespace sets userns=host when users request host namespaces (pid, ipc, net),
                                                                                                                                            	// are using non-namespaced capabilities (mknod, sys_time, sys_module), the pod contains a privileged container,
                                                                                                                                            	// or using host path volumes.
                                                                                                                                            	// This should only be enabled when the container runtime is performing user remapping AND if the
                                                                                                                                            	// experimental behavior is desired.
                                                                                                                                            	EnableHostUserNamespace bool
                                                                                                                                            }

                                                                                                                                              RunContainerOptions specify the options which are necessary for running containers

                                                                                                                                              type Runtime

                                                                                                                                              type Runtime interface {
                                                                                                                                              	// Type returns the type of the container runtime.
                                                                                                                                              	Type() string
                                                                                                                                              
                                                                                                                                              	// Version returns the version information of the container runtime.
                                                                                                                                              	Version() (Version, error)
                                                                                                                                              
                                                                                                                                              	// APIVersion returns the cached API version information of the container
                                                                                                                                              	// runtime. Implementation is expected to update this cache periodically.
                                                                                                                                              	// This may be different from the runtime engine's version.
                                                                                                                                              	// TODO(random-liu): We should fold this into Version()
                                                                                                                                              	APIVersion() (Version, error)
                                                                                                                                              	// Status returns the status of the runtime. An error is returned if the Status
                                                                                                                                              	// function itself fails, nil otherwise.
                                                                                                                                              	Status() (*RuntimeStatus, error)
                                                                                                                                              	// GetPods returns a list of containers grouped by pods. The boolean parameter
                                                                                                                                              	// specifies whether the runtime returns all containers including those already
                                                                                                                                              	// exited and dead containers (used for garbage collection).
                                                                                                                                              	GetPods(all bool) ([]*Pod, error)
                                                                                                                                              	// GarbageCollect removes dead containers using the specified container gc policy
                                                                                                                                              	// If allSourcesReady is not true, it means that kubelet doesn't have the
                                                                                                                                              	// complete list of pods from all avialble sources (e.g., apiserver, http,
                                                                                                                                              	// file). In this case, garbage collector should refrain itself from aggressive
                                                                                                                                              	// behavior such as removing all containers of unrecognized pods (yet).
                                                                                                                                              	// If evictNonDeletedPods is set to true, containers and sandboxes belonging to pods
                                                                                                                                              	// that are terminated, but not deleted will be evicted.  Otherwise, only deleted pods will be GC'd.
                                                                                                                                              	// TODO: Revisit this method and make it cleaner.
                                                                                                                                              	GarbageCollect(gcPolicy ContainerGCPolicy, allSourcesReady bool, evictNonDeletedPods bool) error
                                                                                                                                              	// Syncs the running pod into the desired pod.
                                                                                                                                              	SyncPod(pod *v1.Pod, podStatus *PodStatus, pullSecrets []v1.Secret, backOff *flowcontrol.Backoff) PodSyncResult
                                                                                                                                              	// KillPod kills all the containers of a pod. Pod may be nil, running pod must not be.
                                                                                                                                              	// TODO(random-liu): Return PodSyncResult in KillPod.
                                                                                                                                              	// gracePeriodOverride if specified allows the caller to override the pod default grace period.
                                                                                                                                              	// only hard kill paths are allowed to specify a gracePeriodOverride in the kubelet in order to not corrupt user data.
                                                                                                                                              	// it is useful when doing SIGKILL for hard eviction scenarios, or max grace period during soft eviction scenarios.
                                                                                                                                              	KillPod(pod *v1.Pod, runningPod Pod, gracePeriodOverride *int64) error
                                                                                                                                              	// GetPodStatus retrieves the status of the pod, including the
                                                                                                                                              	// information of all containers in the pod that are visible in Runtime.
                                                                                                                                              	GetPodStatus(uid types.UID, name, namespace string) (*PodStatus, error)
                                                                                                                                              	// TODO(vmarmol): Unify pod and containerID args.
                                                                                                                                              	// GetContainerLogs returns logs of a specific container. By
                                                                                                                                              	// default, it returns a snapshot of the container log. Set 'follow' to true to
                                                                                                                                              	// stream the log. Set 'follow' to false and specify the number of lines (e.g.
                                                                                                                                              	// "100" or "all") to tail the log.
                                                                                                                                              	GetContainerLogs(ctx context.Context, pod *v1.Pod, containerID ContainerID, logOptions *v1.PodLogOptions, stdout, stderr io.Writer) (err error)
                                                                                                                                              	// Delete a container. If the container is still running, an error is returned.
                                                                                                                                              	DeleteContainer(containerID ContainerID) error
                                                                                                                                              	// ImageService provides methods to image-related methods.
                                                                                                                                              	ImageService
                                                                                                                                              	// UpdatePodCIDR sends a new podCIDR to the runtime.
                                                                                                                                              	// This method just proxies a new runtimeConfig with the updated
                                                                                                                                              	// CIDR value down to the runtime shim.
                                                                                                                                              	UpdatePodCIDR(podCIDR string) error
                                                                                                                                              }

                                                                                                                                                Runtime interface defines the interfaces that should be implemented by a container runtime. Thread safety is required from implementations of this interface.

                                                                                                                                                type RuntimeCache

                                                                                                                                                type RuntimeCache interface {
                                                                                                                                                	GetPods() ([]*Pod, error)
                                                                                                                                                	ForceUpdateIfOlder(time.Time) error
                                                                                                                                                }

                                                                                                                                                func NewRuntimeCache

                                                                                                                                                func NewRuntimeCache(getter podsGetter) (RuntimeCache, error)

                                                                                                                                                  NewRuntimeCache creates a container runtime cache.

                                                                                                                                                  type RuntimeCondition

                                                                                                                                                  type RuntimeCondition struct {
                                                                                                                                                  	// Type of runtime condition.
                                                                                                                                                  	Type RuntimeConditionType
                                                                                                                                                  	// Status of the condition, one of true/false.
                                                                                                                                                  	Status bool
                                                                                                                                                  	// Reason is brief reason for the condition's last transition.
                                                                                                                                                  	Reason string
                                                                                                                                                  	// Message is human readable message indicating details about last transition.
                                                                                                                                                  	Message string
                                                                                                                                                  }

                                                                                                                                                    RuntimeCondition contains condition information for the runtime.

                                                                                                                                                    func (*RuntimeCondition) String

                                                                                                                                                    func (c *RuntimeCondition) String() string

                                                                                                                                                      String formats the runtime condition into human readable string.

                                                                                                                                                      type RuntimeConditionType

                                                                                                                                                      type RuntimeConditionType string

                                                                                                                                                        RuntimeConditionType is the types of required runtime conditions.

                                                                                                                                                        const (
                                                                                                                                                        	// RuntimeReady means the runtime is up and ready to accept basic containers.
                                                                                                                                                        	RuntimeReady RuntimeConditionType = "RuntimeReady"
                                                                                                                                                        	// NetworkReady means the runtime network is up and ready to accept containers which require network.
                                                                                                                                                        	NetworkReady RuntimeConditionType = "NetworkReady"
                                                                                                                                                        )

                                                                                                                                                        type RuntimeHelper

                                                                                                                                                        type RuntimeHelper interface {
                                                                                                                                                        	GenerateRunContainerOptions(pod *v1.Pod, container *v1.Container, podIP string) (contOpts *RunContainerOptions, cleanupAction func(), err error)
                                                                                                                                                        	GetPodDNS(pod *v1.Pod) (dnsConfig *runtimeapi.DNSConfig, err error)
                                                                                                                                                        	// GetPodCgroupParent returns the CgroupName identifier, and its literal cgroupfs form on the host
                                                                                                                                                        	// of a pod.
                                                                                                                                                        	GetPodCgroupParent(pod *v1.Pod) string
                                                                                                                                                        	GetPodDir(podUID types.UID) string
                                                                                                                                                        	GeneratePodHostNameAndDomain(pod *v1.Pod) (hostname string, hostDomain string, err error)
                                                                                                                                                        	// 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.
                                                                                                                                                        	GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64
                                                                                                                                                        }

                                                                                                                                                          RuntimeHelper wraps kubelet to make container runtime able to get necessary informations like the RunContainerOptions, DNS settings, Host IP.

                                                                                                                                                          type RuntimeStatus

                                                                                                                                                          type RuntimeStatus struct {
                                                                                                                                                          	// Conditions is an array of current observed runtime conditions.
                                                                                                                                                          	Conditions []RuntimeCondition
                                                                                                                                                          }

                                                                                                                                                            RuntimeStatus contains the status of the runtime.

                                                                                                                                                            func (*RuntimeStatus) GetRuntimeCondition

                                                                                                                                                            func (r *RuntimeStatus) GetRuntimeCondition(t RuntimeConditionType) *RuntimeCondition

                                                                                                                                                              GetRuntimeCondition gets a specified runtime condition from the runtime status.

                                                                                                                                                              func (*RuntimeStatus) String

                                                                                                                                                              func (s *RuntimeStatus) String() string

                                                                                                                                                                String formats the runtime status into human readable string.

                                                                                                                                                                type SortContainerStatusesByCreationTime

                                                                                                                                                                type SortContainerStatusesByCreationTime []*ContainerStatus

                                                                                                                                                                  Sort the container statuses by creation time.

                                                                                                                                                                  func (SortContainerStatusesByCreationTime) Len

                                                                                                                                                                  func (SortContainerStatusesByCreationTime) Less

                                                                                                                                                                  func (SortContainerStatusesByCreationTime) Swap

                                                                                                                                                                  type SourcesReadyProvider

                                                                                                                                                                  type SourcesReadyProvider interface {
                                                                                                                                                                  	// AllReady returns true if the currently configured sources have all been seen.
                                                                                                                                                                  	AllReady() bool
                                                                                                                                                                  }

                                                                                                                                                                    SourcesReadyProvider knows how to determine if configuration sources are ready

                                                                                                                                                                    type StreamingRuntime

                                                                                                                                                                    type StreamingRuntime interface {
                                                                                                                                                                    	GetExec(id ContainerID, cmd []string, stdin, stdout, stderr, tty bool) (*url.URL, error)
                                                                                                                                                                    	GetAttach(id ContainerID, stdin, stdout, stderr, tty bool) (*url.URL, error)
                                                                                                                                                                    	GetPortForward(podName, podNamespace string, podUID types.UID, ports []int32) (*url.URL, error)
                                                                                                                                                                    }

                                                                                                                                                                      StreamingRuntime is the interface implemented by runtimes that handle the serving of the streaming calls (exec/attach/port-forward) themselves. In this case, Kubelet should redirect to the runtime server.

                                                                                                                                                                      type SyncAction

                                                                                                                                                                      type SyncAction string

                                                                                                                                                                        SyncAction indicates different kind of actions in SyncPod() and KillPod(). Now there are only actions about start/kill container and setup/teardown network.

                                                                                                                                                                        const (
                                                                                                                                                                        	StartContainer   SyncAction = "StartContainer"
                                                                                                                                                                        	KillContainer    SyncAction = "KillContainer"
                                                                                                                                                                        	SetupNetwork     SyncAction = "SetupNetwork"
                                                                                                                                                                        	TeardownNetwork  SyncAction = "TeardownNetwork"
                                                                                                                                                                        	InitContainer    SyncAction = "InitContainer"
                                                                                                                                                                        	CreatePodSandbox SyncAction = "CreatePodSandbox"
                                                                                                                                                                        	ConfigPodSandbox SyncAction = "ConfigPodSandbox"
                                                                                                                                                                        	KillPodSandbox   SyncAction = "KillPodSandbox"
                                                                                                                                                                        )

                                                                                                                                                                        type SyncResult

                                                                                                                                                                        type SyncResult struct {
                                                                                                                                                                        	// The associated action of the result
                                                                                                                                                                        	Action SyncAction
                                                                                                                                                                        	// The target of the action, now the target can only be:
                                                                                                                                                                        	//  * Container: Target should be container name
                                                                                                                                                                        	//  * Network: Target is useless now, we just set it as pod full name now
                                                                                                                                                                        	Target interface{}
                                                                                                                                                                        	// Brief error reason
                                                                                                                                                                        	Error error
                                                                                                                                                                        	// Human readable error reason
                                                                                                                                                                        	Message string
                                                                                                                                                                        }

                                                                                                                                                                          SyncResult is the result of sync action.

                                                                                                                                                                          func NewSyncResult

                                                                                                                                                                          func NewSyncResult(action SyncAction, target interface{}) *SyncResult

                                                                                                                                                                            NewSyncResult generates new SyncResult with specific Action and Target

                                                                                                                                                                            func (*SyncResult) Fail

                                                                                                                                                                            func (r *SyncResult) Fail(err error, msg string)

                                                                                                                                                                              Fail fails the SyncResult with specific error and message

                                                                                                                                                                              type TestRuntimeCache

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

                                                                                                                                                                                TestRunTimeCache embeds runtimeCache with some additional methods for testing. It must be declared in the container package to have visibility to runtimeCache. It cannot be in a "..._test.go" file in order for runtime_cache_test.go to have cross-package visibility to it. (cross-package declarations in test files cannot be used from dot imports if this package is vendored)

                                                                                                                                                                                func NewTestRuntimeCache

                                                                                                                                                                                func NewTestRuntimeCache(getter podsGetter) *TestRuntimeCache

                                                                                                                                                                                func (*TestRuntimeCache) ForceUpdateIfOlder

                                                                                                                                                                                func (r *TestRuntimeCache) ForceUpdateIfOlder(minExpectedCacheTime time.Time) error

                                                                                                                                                                                func (*TestRuntimeCache) GetCachedPods

                                                                                                                                                                                func (r *TestRuntimeCache) GetCachedPods() []*Pod

                                                                                                                                                                                func (*TestRuntimeCache) GetPods

                                                                                                                                                                                func (r *TestRuntimeCache) GetPods() ([]*Pod, error)

                                                                                                                                                                                  GetPods returns the cached pods if they are not outdated; otherwise, it retrieves the latest pods and return them.

                                                                                                                                                                                  func (*TestRuntimeCache) UpdateCacheWithLock

                                                                                                                                                                                  func (r *TestRuntimeCache) UpdateCacheWithLock() error

                                                                                                                                                                                  type Version

                                                                                                                                                                                  type Version interface {
                                                                                                                                                                                  	// Compare compares two versions of the runtime. On success it returns -1
                                                                                                                                                                                  	// if the version is less than the other, 1 if it is greater than the other,
                                                                                                                                                                                  	// or 0 if they are equal.
                                                                                                                                                                                  	Compare(other string) (int, error)
                                                                                                                                                                                  	// String returns a string that represents the version.
                                                                                                                                                                                  	String() string
                                                                                                                                                                                  }

                                                                                                                                                                                  type VolumeInfo

                                                                                                                                                                                  type VolumeInfo struct {
                                                                                                                                                                                  	// Mounter is the volume's mounter
                                                                                                                                                                                  	Mounter volume.Mounter
                                                                                                                                                                                  	// BlockVolumeMapper is the Block volume's mapper
                                                                                                                                                                                  	BlockVolumeMapper volume.BlockVolumeMapper
                                                                                                                                                                                  	// SELinuxLabeled indicates whether this volume has had the
                                                                                                                                                                                  	// pod's SELinux label applied to it or not
                                                                                                                                                                                  	SELinuxLabeled bool
                                                                                                                                                                                  	// Whether the volume permission is set to read-only or not
                                                                                                                                                                                  	// This value is passed from volume.spec
                                                                                                                                                                                  	ReadOnly bool
                                                                                                                                                                                  	// Inner volume spec name, which is the PV name if used, otherwise
                                                                                                                                                                                  	// it is the same as the outer volume spec name.
                                                                                                                                                                                  	InnerVolumeSpecName string
                                                                                                                                                                                  }

                                                                                                                                                                                    VolumeInfo contains information about the volume.

                                                                                                                                                                                    type VolumeMap

                                                                                                                                                                                    type VolumeMap map[string]VolumeInfo

                                                                                                                                                                                    Directories

                                                                                                                                                                                    Path Synopsis
                                                                                                                                                                                    Code generated by mockery v1.0.0
                                                                                                                                                                                    Code generated by mockery v1.0.0