kubernetes: k8s.io/kubernetes/pkg/kubelet/lifecycle Index | Files

package lifecycle

import "k8s.io/kubernetes/pkg/kubelet/lifecycle"

Package lifecycle contains handlers for pod lifecycle events and interfaces to integrate with kubelet admission, synchronization, and eviction of pods.

Index

Package Files

admission_failure_handler_stub.go doc.go handlers.go interfaces.go predicate.go

func NewHandlerRunner Uses

func NewHandlerRunner(httpGetter kubetypes.HTTPGetter, commandRunner kubecontainer.CommandRunner, containerManager podStatusProvider) kubecontainer.HandlerRunner

NewHandlerRunner returns a configured lifecycle handler for a container.

type AdmissionFailureHandler Uses

type AdmissionFailureHandler interface {
    HandleAdmissionFailure(admitPod *v1.Pod, failureReasons []PredicateFailureReason) ([]PredicateFailureReason, error)
}

AdmissionFailureHandler is an interface which defines how to deal with a failure to admit a pod. This allows for the graceful handling of pod admission failure.

type AdmissionFailureHandlerStub Uses

type AdmissionFailureHandlerStub struct{}

AdmissionFailureHandlerStub is an AdmissionFailureHandler that does not perform any handling of admission failure. It simply passes the failure on.

func NewAdmissionFailureHandlerStub Uses

func NewAdmissionFailureHandlerStub() *AdmissionFailureHandlerStub

NewAdmissionFailureHandlerStub returns an instance of AdmissionFailureHandlerStub.

func (*AdmissionFailureHandlerStub) HandleAdmissionFailure Uses

func (n *AdmissionFailureHandlerStub) HandleAdmissionFailure(admitPod *v1.Pod, failureReasons []PredicateFailureReason) ([]PredicateFailureReason, error)

HandleAdmissionFailure simply passes admission rejection on, with no special handling.

type InsufficientResourceError Uses

type InsufficientResourceError struct {
    ResourceName v1.ResourceName
    Requested    int64
    Used         int64
    Capacity     int64
}

InsufficientResourceError is an error type that indicates what kind of resource limit is hit and caused the unfitting failure.

func (*InsufficientResourceError) Error Uses

func (e *InsufficientResourceError) Error() string

func (*InsufficientResourceError) GetInsufficientAmount Uses

func (e *InsufficientResourceError) GetInsufficientAmount() int64

GetInsufficientAmount returns the amount of the insufficient resource of the error.

func (*InsufficientResourceError) GetReason Uses

func (e *InsufficientResourceError) GetReason() string

GetReason returns the reason of the InsufficientResourceError.

type PodAdmitAttributes Uses

type PodAdmitAttributes struct {
    // the pod to evaluate for admission
    Pod *v1.Pod
    // all pods bound to the kubelet excluding the pod being evaluated
    OtherPods []*v1.Pod
}

PodAdmitAttributes is the context for a pod admission decision. The member fields of this struct should never be mutated.

type PodAdmitHandler Uses

type PodAdmitHandler interface {
    // Admit evaluates if a pod can be admitted.
    Admit(attrs *PodAdmitAttributes) PodAdmitResult
}

PodAdmitHandler is notified during pod admission.

func NewAppArmorAdmitHandler Uses

func NewAppArmorAdmitHandler(validator apparmor.Validator) PodAdmitHandler

NewAppArmorAdmitHandler returns a PodAdmitHandler which is used to evaluate if a pod can be admitted from the perspective of AppArmor.

func NewNoNewPrivsAdmitHandler Uses

func NewNoNewPrivsAdmitHandler(runtime kubecontainer.Runtime) PodAdmitHandler

NewNoNewPrivsAdmitHandler returns a PodAdmitHandler which is used to evaluate if a pod can be admitted from the perspective of NoNewPrivs.

func NewPredicateAdmitHandler Uses

func NewPredicateAdmitHandler(getNodeAnyWayFunc getNodeAnyWayFuncType, admissionFailureHandler AdmissionFailureHandler, pluginResourceUpdateFunc pluginResourceUpdateFuncType) PodAdmitHandler

NewPredicateAdmitHandler returns a PodAdmitHandler which is used to evaluates if a pod can be admitted from the perspective of predicates.

func NewProcMountAdmitHandler Uses

func NewProcMountAdmitHandler(runtime kubecontainer.Runtime) PodAdmitHandler

NewProcMountAdmitHandler returns a PodAdmitHandler which is used to evaluate if a pod can be admitted from the perspective of ProcMount.

type PodAdmitHandlers Uses

type PodAdmitHandlers []PodAdmitHandler

PodAdmitHandlers maintains a list of handlers to pod admission.

func (*PodAdmitHandlers) AddPodAdmitHandler Uses

func (handlers *PodAdmitHandlers) AddPodAdmitHandler(a PodAdmitHandler)

AddPodAdmitHandler adds the specified observer.

type PodAdmitResult Uses

type PodAdmitResult struct {
    // if true, the pod should be admitted.
    Admit bool
    // a brief single-word reason why the pod could not be admitted.
    Reason string
    // a brief message explaining why the pod could not be admitted.
    Message string
}

PodAdmitResult provides the result of a pod admission decision.

type PodAdmitTarget Uses

type PodAdmitTarget interface {
    // AddPodAdmitHandler adds the specified handler.
    AddPodAdmitHandler(a PodAdmitHandler)
}

PodAdmitTarget maintains a list of handlers to invoke.

type PodLifecycleTarget Uses

type PodLifecycleTarget interface {
    PodAdmitTarget
    PodSyncLoopTarget
    PodSyncTarget
}

PodLifecycleTarget groups a set of lifecycle interfaces for convenience.

type PodSyncHandler Uses

type PodSyncHandler interface {
    // ShouldEvict is invoked during each sync pod operation to determine
    // if the pod should be evicted from the kubelet.  If so, the pod status
    // is updated to mark its phase as failed with the provided reason and message,
    // and the pod is immediately killed.
    // This operation must return immediately as its called for each sync pod.
    // The provided pod should never be modified.
    ShouldEvict(pod *v1.Pod) ShouldEvictResponse
}

PodSyncHandler is invoked during each sync pod operation.

type PodSyncHandlers Uses

type PodSyncHandlers []PodSyncHandler

PodSyncHandlers maintains a list of handlers to pod sync.

func (*PodSyncHandlers) AddPodSyncHandler Uses

func (handlers *PodSyncHandlers) AddPodSyncHandler(a PodSyncHandler)

AddPodSyncHandler adds the specified handler.

type PodSyncLoopHandler Uses

type PodSyncLoopHandler interface {
    // ShouldSync returns true if the pod needs to be synced.
    // This operation must return immediately as its called for each pod.
    // The provided pod should never be modified.
    ShouldSync(pod *v1.Pod) bool
}

PodSyncLoopHandler is invoked during each sync loop iteration.

type PodSyncLoopHandlers Uses

type PodSyncLoopHandlers []PodSyncLoopHandler

PodSyncLoopHandlers maintains a list of handlers to pod sync loop.

func (*PodSyncLoopHandlers) AddPodSyncLoopHandler Uses

func (handlers *PodSyncLoopHandlers) AddPodSyncLoopHandler(a PodSyncLoopHandler)

AddPodSyncLoopHandler adds the specified observer.

type PodSyncLoopTarget Uses

type PodSyncLoopTarget interface {
    // AddPodSyncLoopHandler adds the specified handler.
    AddPodSyncLoopHandler(a PodSyncLoopHandler)
}

PodSyncLoopTarget maintains a list of handlers to pod sync loop.

type PodSyncTarget Uses

type PodSyncTarget interface {
    // AddPodSyncHandler adds the specified handler
    AddPodSyncHandler(a PodSyncHandler)
}

PodSyncTarget maintains a list of handlers to pod sync.

type PredicateFailureError Uses

type PredicateFailureError struct {
    PredicateName string
    PredicateDesc string
}

PredicateFailureError describes a failure error of predicate.

func (*PredicateFailureError) Error Uses

func (e *PredicateFailureError) Error() string

func (*PredicateFailureError) GetReason Uses

func (e *PredicateFailureError) GetReason() string

GetReason returns the reason of the PredicateFailureError.

type PredicateFailureReason Uses

type PredicateFailureReason interface {
    GetReason() string
}

PredicateFailureReason interface represents the failure reason of a predicate.

func GeneralPredicates Uses

func GeneralPredicates(pod *v1.Pod, nodeInfo *schedulerframework.NodeInfo) ([]PredicateFailureReason, error)

GeneralPredicates checks a group of predicates that the kubelet cares about.

type ShouldEvictResponse Uses

type ShouldEvictResponse struct {
    // if true, the pod should be evicted.
    Evict bool
    // a brief CamelCase reason why the pod should be evicted.
    Reason string
    // a brief message why the pod should be evicted.
    Message string
}

ShouldEvictResponse provides the result of a should evict request.

Package lifecycle imports 20 packages (graph) and is imported by 383 packages. Updated 2020-07-10. Refresh now. Tools for package owners.