Documentation

Index

Constants

View Source
const (
	// If a watch drops a delete event for a pod, it'll take this long
	// before a dormant controller waiting for those packets is woken up anyway. It is
	// specifically targeted at the case where some problem prevents an update
	// of expectations, without it the controller could stay asleep forever. This should
	// be set based on the expected latency of watch events.
	//
	// Currently a controller can service (create *and* observe the watch events for said
	// creation) about 10 pods a second, so it takes about 1 min to service
	// 500 pods. Just creation is limited to 20qps, and watching happens with ~10-30s
	// latency/pod at the scale of 3000 pods over 100 nodes.
	ExpectationsTimeout = 5 * time.Minute
	// When batching pod creates, SlowStartInitialBatchSize is the size of the
	// initial batch.  The size of each successive batch is twice the size of
	// the previous batch.  For example, for a value of 1, batch sizes would be
	// 1, 2, 4, 8, ...  and for a value of 10, batch sizes would be
	// 10, 20, 40, 80, ...  Setting the value higher means that quota denials
	// will result in more doomed API calls and associated event spam.  Setting
	// the value lower will result in more API call round trip periods for
	// large batches.
	//
	// Given a number of pods to start "N":
	// The number of doomed calls per sync once quota is exceeded is given by:
	//      min(N,SlowStartInitialBatchSize)
	// The number of batches is given by:
	//      1+floor(log_2(ceil(N/SlowStartInitialBatchSize)))
	SlowStartInitialBatchSize = 1
)
View Source
const (
	// FailedCreatePodReason is added in an event and in a replica set condition
	// when a pod for a replica set is failed to be created.
	FailedCreatePodReason = "FailedCreate"
	// SuccessfulCreatePodReason is added in an event when a pod for a replica set
	// is successfully created.
	SuccessfulCreatePodReason = "SuccessfulCreate"
	// FailedDeletePodReason is added in an event and in a replica set condition
	// when a pod for a replica set is failed to be deleted.
	FailedDeletePodReason = "FailedDelete"
	// SuccessfulDeletePodReason is added in an event when a pod for a replica set
	// is successfully deleted.
	SuccessfulDeletePodReason = "SuccessfulDelete"
)

    Reasons for pod events

    Variables

    View Source
    var ExpKeyFunc = func(obj interface{}) (string, error) {
    	if e, ok := obj.(*ControlleeExpectations); ok {
    		return e.key, nil
    	}
    	return "", fmt.Errorf("could not find key for obj %#v", obj)
    }

      ExpKeyFunc to parse out the key from a ControlleeExpectation

      View Source
      var UIDSetKeyFunc = func(obj interface{}) (string, error) {
      	if u, ok := obj.(*UIDSet); ok {
      		return u.key, nil
      	}
      	return "", fmt.Errorf("could not find key for obj %#v", obj)
      }

        UIDSetKeyFunc to parse out the key from a UIDSet.

        View Source
        var UpdateLabelBackoff = wait.Backoff{
        	Steps:    5,
        	Duration: 100 * time.Millisecond,
        	Jitter:   1.0,
        }
        View Source
        var UpdateTaintBackoff = wait.Backoff{
        	Steps:    5,
        	Duration: 100 * time.Millisecond,
        	Jitter:   1.0,
        }

        Functions

        func AddOrUpdateLabelsOnNode

        func AddOrUpdateLabelsOnNode(kubeClient clientset.Interface, nodeName string, labelsToUpdate map[string]string) error

        func AddOrUpdateTaintOnNode

        func AddOrUpdateTaintOnNode(c clientset.Interface, nodeName string, taints ...*corev1.Taint) error

          AddOrUpdateTaintOnNode add taints to the node. If taint was added into node, it'll issue API calls to update nodes; otherwise, no API calls. Return error if any.

          func ComputeHash

          func ComputeHash(template *v1.PodTemplateSpec, collisionCount *int32) string

            ComputeHash returns a hash value calculated from pod template and a collisionCount to avoid hash collision. The hash will be safe encoded to avoid bad words.

            func FilterActivePods

            func FilterActivePods(pods []*v1.Pod) []*v1.Pod

              FilterActivePods returns pods that have not terminated.

              func FilterActiveReplicaSets

              func FilterActiveReplicaSets(replicaSets []*v1.ReplicaSet) []*v1.ReplicaSet

                FilterActiveReplicaSets returns replica sets that have (or at least ought to have) pods.

                func FilterReplicaSets

                func FilterReplicaSets(RSes []*v1.ReplicaSet, filterFn filterRS) []*v1.ReplicaSet

                  FilterReplicaSets returns replica sets that are filtered by filterFn (all returned ones should match filterFn).

                  func GetPodFromTemplate

                  func GetPodFromTemplate(template *v1.PodTemplateSpec, parentObject runtime.Object, controllerRef *metav1.OwnerReference) (*v1.Pod, error)

                  func IsPodActive

                  func IsPodActive(p *v1.Pod) bool

                  func NoResyncPeriodFunc

                  func NoResyncPeriodFunc() time.Duration

                    Returns 0 for resyncPeriod in case resyncing is not needed.

                    func PatchNodeTaints

                    func PatchNodeTaints(c clientset.Interface, nodeName string, oldNode *corev1.Node, newNode *corev1.Node) error

                      PatchNodeTaints patches node's taints.

                      func PodKey

                      func PodKey(pod *v1.Pod) string

                        PodKey returns a key unique to the given pod within a cluster. It's used so we consistently use the same key scheme in this module. It does exactly what cache.MetaNamespaceKeyFunc would have done except there's not possibility for error since we know the exact type.

                        func RecheckDeletionTimestamp

                        func RecheckDeletionTimestamp(getObject func() (metav1.Object, error)) func() error

                          RecheckDeletionTimestamp returns a CanAdopt() function to recheck deletion.

                          The CanAdopt() function calls getObject() to fetch the latest value, and denies adoption attempts if that object has a non-nil DeletionTimestamp.

                          func RemoveTaintOffNode

                          func RemoveTaintOffNode(c clientset.Interface, nodeName string, node *corev1.Node, taints ...*corev1.Taint) error

                            RemoveTaintOffNode is for cleaning up taints temporarily added to node, won't fail if target taint doesn't exist or has been removed. If passed a node it'll check if there's anything to be done, if taint is not present it won't issue any API calls.

                            Types

                            type ActivePods

                            type ActivePods []*v1.Pod

                              ActivePods type allows custom sorting of pods so a controller can pick the best ones to delete.

                              func (ActivePods) Len

                              func (s ActivePods) Len() int

                              func (ActivePods) Less

                              func (s ActivePods) Less(i, j int) bool

                              func (ActivePods) Swap

                              func (s ActivePods) Swap(i, j int)

                              type ActivePodsWithRanks

                              type ActivePodsWithRanks struct {
                              	// Pods is a list of pods.
                              	Pods []*v1.Pod
                              
                              	// Rank is a ranking of pods.  This ranking is used during sorting when
                              	// comparing two pods that are both scheduled, in the same phase, and
                              	// having the same ready status.
                              	Rank []int
                              }

                                ActivePodsWithRanks is a sortable list of pods and a list of corresponding ranks which will be considered during sorting. The two lists must have equal length. After sorting, the pods will be ordered as follows, applying each rule in turn until one matches:

                                1. If only one of the pods is assigned to a node, the pod that is not

                                assigned comes before the pod that is.
                                

                                2. If the pods' phases differ, a pending pod comes before a pod whose phase

                                is unknown, and a pod whose phase is unknown comes before a running pod.
                                

                                3. If exactly one of the pods is ready, the pod that is not ready comes

                                before the ready pod.
                                

                                4. If the pods' ranks differ, the pod with greater rank comes before the pod

                                with lower rank.
                                

                                5. If both pods are ready but have not been ready for the same amount of

                                time, the pod that has been ready for a shorter amount of time comes
                                before the pod that has been ready for longer.
                                

                                6. If one pod has a container that has restarted more than any container in

                                the other pod, the pod with the container with more restarts comes
                                before the other pod.
                                

                                7. If the pods' creation times differ, the pod that was created more recently

                                comes before the older pod.
                                

                                If none of these rules matches, the second pod comes before the first pod.

                                The intention of this ordering is to put pods that should be preferred for deletion first in the list.

                                func (ActivePodsWithRanks) Len

                                func (s ActivePodsWithRanks) Len() int

                                func (ActivePodsWithRanks) Less

                                func (s ActivePodsWithRanks) Less(i, j int) bool

                                  Less compares two pods with corresponding ranks and returns true if the first one should be preferred for deletion.

                                  func (ActivePodsWithRanks) Swap

                                  func (s ActivePodsWithRanks) Swap(i, j int)

                                  type BaseControllerRefManager

                                  type BaseControllerRefManager struct {
                                  	Controller metav1.Object
                                  	Selector   labels.Selector
                                  
                                  	CanAdoptFunc func() error
                                  	// contains filtered or unexported fields
                                  }

                                  func (*BaseControllerRefManager) CanAdopt

                                  func (m *BaseControllerRefManager) CanAdopt() error

                                  func (*BaseControllerRefManager) ClaimObject

                                  func (m *BaseControllerRefManager) ClaimObject(obj metav1.Object, match func(metav1.Object) bool, adopt, release func(metav1.Object) error) (bool, error)

                                    ClaimObject tries to take ownership of an object for this controller.

                                    It will reconcile the following:

                                    * Adopt orphans if the match function returns true.
                                    * Release owned objects if the match function returns false.
                                    

                                    A non-nil error is returned if some form of reconciliation was attempted and failed. Usually, controllers should try again later in case reconciliation is still needed.

                                    If the error is nil, either the reconciliation succeeded, or no reconciliation was necessary. The returned boolean indicates whether you now own the object.

                                    No reconciliation will be attempted if the controller is being deleted.

                                    type ByLogging

                                    type ByLogging []*v1.Pod

                                      ByLogging allows custom sorting of pods so the best one can be picked for getting its logs.

                                      func (ByLogging) Len

                                      func (s ByLogging) Len() int

                                      func (ByLogging) Less

                                      func (s ByLogging) Less(i, j int) bool

                                      func (ByLogging) Swap

                                      func (s ByLogging) Swap(i, j int)

                                      type ControlleeExpectations

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

                                        ControlleeExpectations track controllee creates/deletes.

                                        func (*ControlleeExpectations) Add

                                        func (e *ControlleeExpectations) Add(add, del int64)

                                          Add increments the add and del counters.

                                          func (*ControlleeExpectations) Fulfilled

                                          func (e *ControlleeExpectations) Fulfilled() bool

                                            Fulfilled returns true if this expectation has been fulfilled.

                                            func (*ControlleeExpectations) GetExpectations

                                            func (e *ControlleeExpectations) GetExpectations() (int64, int64)

                                              GetExpectations returns the add and del expectations of the controllee.

                                              type ControllerExpectations

                                              type ControllerExpectations struct {
                                              	cache.Store
                                              }

                                                ControllerExpectations is a cache mapping controllers to what they expect to see before being woken up for a sync.

                                                func NewControllerExpectations

                                                func NewControllerExpectations() *ControllerExpectations

                                                  NewControllerExpectations returns a store for ControllerExpectations.

                                                  func (*ControllerExpectations) CreationObserved

                                                  func (r *ControllerExpectations) CreationObserved(controllerKey string)

                                                    CreationObserved atomically decrements the `add` expectation count of the given controller.

                                                    func (*ControllerExpectations) DeleteExpectations

                                                    func (r *ControllerExpectations) DeleteExpectations(controllerKey string)

                                                      DeleteExpectations deletes the expectations of the given controller from the TTLStore.

                                                      func (*ControllerExpectations) DeletionObserved

                                                      func (r *ControllerExpectations) DeletionObserved(controllerKey string)

                                                        DeletionObserved atomically decrements the `del` expectation count of the given controller.

                                                        func (*ControllerExpectations) ExpectCreations

                                                        func (r *ControllerExpectations) ExpectCreations(controllerKey string, adds int) error

                                                        func (*ControllerExpectations) ExpectDeletions

                                                        func (r *ControllerExpectations) ExpectDeletions(controllerKey string, dels int) error

                                                        func (*ControllerExpectations) GetExpectations

                                                        func (r *ControllerExpectations) GetExpectations(controllerKey string) (*ControlleeExpectations, bool, error)

                                                          GetExpectations returns the ControlleeExpectations of the given controller.

                                                          func (*ControllerExpectations) LowerExpectations

                                                          func (r *ControllerExpectations) LowerExpectations(controllerKey string, add, del int)

                                                            Decrements the expectation counts of the given controller.

                                                            func (*ControllerExpectations) RaiseExpectations

                                                            func (r *ControllerExpectations) RaiseExpectations(controllerKey string, add, del int)

                                                              Increments the expectation counts of the given controller.

                                                              func (*ControllerExpectations) SatisfiedExpectations

                                                              func (r *ControllerExpectations) SatisfiedExpectations(controllerKey string) bool

                                                                SatisfiedExpectations returns true if the required adds/dels for the given controller have been observed. Add/del counts are established by the controller at sync time, and updated as controllees are observed by the controller manager.

                                                                func (*ControllerExpectations) SetExpectations

                                                                func (r *ControllerExpectations) SetExpectations(controllerKey string, add, del int) error

                                                                  SetExpectations registers new expectations for the given controller. Forgets existing expectations.

                                                                  type ControllerExpectationsInterface

                                                                  type ControllerExpectationsInterface interface {
                                                                  	GetExpectations(controllerKey string) (*ControlleeExpectations, bool, error)
                                                                  	SatisfiedExpectations(controllerKey string) bool
                                                                  	DeleteExpectations(controllerKey string)
                                                                  	SetExpectations(controllerKey string, add, del int) error
                                                                  	ExpectCreations(controllerKey string, adds int) error
                                                                  	ExpectDeletions(controllerKey string, dels int) error
                                                                  	CreationObserved(controllerKey string)
                                                                  	DeletionObserved(controllerKey string)
                                                                  	RaiseExpectations(controllerKey string, add, del int)
                                                                  	LowerExpectations(controllerKey string, add, del int)
                                                                  }

                                                                    ControllerExpectationsInterface is an interface that allows users to set and wait on expectations. Only abstracted out for testing. Warning: if using KeyFunc it is not safe to use a single ControllerExpectationsInterface with different types of controllers, because the keys might conflict across types.

                                                                    type ControllerRevisionControlInterface

                                                                    type ControllerRevisionControlInterface interface {
                                                                    	PatchControllerRevision(namespace, name string, data []byte) error
                                                                    }

                                                                      TODO: merge the controller revision interface in controller_history.go with this one ControllerRevisionControlInterface is an interface that knows how to patch ControllerRevisions, as well as increment or decrement them. It is used by the daemonset controller to ease testing of actions that it takes.

                                                                      type ControllerRevisionControllerRefManager

                                                                      type ControllerRevisionControllerRefManager struct {
                                                                      	BaseControllerRefManager
                                                                      	// contains filtered or unexported fields
                                                                      }

                                                                        ControllerRevisionControllerRefManager is used to manage controllerRef of ControllerRevisions. Three methods are defined on this object 1: Classify 2: AdoptControllerRevision and 3: ReleaseControllerRevision which are used to classify the ControllerRevisions into appropriate categories and accordingly adopt or release them. See comments on these functions for more details.

                                                                        func NewControllerRevisionControllerRefManager

                                                                        func NewControllerRevisionControllerRefManager(
                                                                        	crControl ControllerRevisionControlInterface,
                                                                        	controller metav1.Object,
                                                                        	selector labels.Selector,
                                                                        	controllerKind schema.GroupVersionKind,
                                                                        	canAdopt func() error,
                                                                        ) *ControllerRevisionControllerRefManager

                                                                          NewControllerRevisionControllerRefManager returns a ControllerRevisionControllerRefManager that exposes methods to manage the controllerRef of ControllerRevisions.

                                                                          The canAdopt() function can be used to perform a potentially expensive check (such as a live GET from the API server) prior to the first adoption. It will only be called (at most once) if an adoption is actually attempted. If canAdopt() returns a non-nil error, all adoptions will fail.

                                                                          NOTE: Once canAdopt() is called, it will not be called again by the same

                                                                          ControllerRevisionControllerRefManager instance. Create a new instance if it
                                                                          makes sense to check canAdopt() again (e.g. in a different sync pass).
                                                                          

                                                                          func (*ControllerRevisionControllerRefManager) AdoptControllerRevision

                                                                          func (m *ControllerRevisionControllerRefManager) AdoptControllerRevision(history *v1.ControllerRevision) error

                                                                            AdoptControllerRevision sends a patch to take control of the ControllerRevision. It returns the error if the patching fails.

                                                                            func (*ControllerRevisionControllerRefManager) ClaimControllerRevisions

                                                                            func (m *ControllerRevisionControllerRefManager) ClaimControllerRevisions(histories []*v1.ControllerRevision) ([]*v1.ControllerRevision, error)

                                                                              ClaimControllerRevisions tries to take ownership of a list of ControllerRevisions.

                                                                              It will reconcile the following:

                                                                              * Adopt orphans if the selector matches.
                                                                              * Release owned objects if the selector no longer matches.
                                                                              

                                                                              A non-nil error is returned if some form of reconciliation was attempted and failed. Usually, controllers should try again later in case reconciliation is still needed.

                                                                              If the error is nil, either the reconciliation succeeded, or no reconciliation was necessary. The list of ControllerRevisions that you now own is returned.

                                                                              func (*ControllerRevisionControllerRefManager) ReleaseControllerRevision

                                                                              func (m *ControllerRevisionControllerRefManager) ReleaseControllerRevision(history *v1.ControllerRevision) error

                                                                                ReleaseControllerRevision sends a patch to free the ControllerRevision from the control of its controller. It returns the error if the patching fails. 404 and 422 errors are ignored.

                                                                                type ControllersByCreationTimestamp

                                                                                type ControllersByCreationTimestamp []*corev1.ReplicationController

                                                                                  ControllersByCreationTimestamp sorts a list of ReplicationControllers by creation timestamp, using their names as a tie breaker.

                                                                                  func (ControllersByCreationTimestamp) Len

                                                                                  func (ControllersByCreationTimestamp) Less

                                                                                  func (ControllersByCreationTimestamp) Swap

                                                                                  func (o ControllersByCreationTimestamp) Swap(i, j int)

                                                                                  type Expectations

                                                                                  type Expectations interface {
                                                                                  	Fulfilled() bool
                                                                                  }

                                                                                    Expectations are either fulfilled, or expire naturally.

                                                                                    type FakePodControl

                                                                                    type FakePodControl struct {
                                                                                    	sync.Mutex
                                                                                    	Templates       []v1.PodTemplateSpec
                                                                                    	ControllerRefs  []metav1.OwnerReference
                                                                                    	DeletePodName   []string
                                                                                    	Patches         [][]byte
                                                                                    	Err             error
                                                                                    	CreateLimit     int
                                                                                    	CreateCallCount int
                                                                                    }

                                                                                    func (*FakePodControl) Clear

                                                                                    func (f *FakePodControl) Clear()

                                                                                    func (*FakePodControl) CreatePods

                                                                                    func (f *FakePodControl) CreatePods(namespace string, spec *v1.PodTemplateSpec, object runtime.Object) error

                                                                                    func (*FakePodControl) CreatePodsOnNode

                                                                                    func (f *FakePodControl) CreatePodsOnNode(nodeName, namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error

                                                                                    func (*FakePodControl) CreatePodsWithControllerRef

                                                                                    func (f *FakePodControl) CreatePodsWithControllerRef(number int, obname, namespace string, spec *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error

                                                                                    func (*FakePodControl) DeletePod

                                                                                    func (f *FakePodControl) DeletePod(namespace string, podID string, object runtime.Object) error

                                                                                    func (*FakePodControl) PatchPod

                                                                                    func (f *FakePodControl) PatchPod(namespace, name string, data []byte) error

                                                                                    func (*FakePodControl) SetZeroCount

                                                                                    func (f *FakePodControl) SetZeroCount()

                                                                                    type PodControlInterface

                                                                                    type PodControlInterface interface {
                                                                                    	// CreatePods creates new pods according to the spec.
                                                                                    	CreatePods(namespace string, template *v1.PodTemplateSpec, object runtime.Object) error
                                                                                    	// CreatePodsOnNode creates a new pod according to the spec on the specified node,
                                                                                    	// and sets the ControllerRef.
                                                                                    	CreatePodsOnNode(nodeName, namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error
                                                                                    	// CreatePodsWithControllerRef creates new pods according to the spec, and sets object as the pod's controller.
                                                                                    	CreatePodsWithControllerRef(number int, obname, namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error
                                                                                    	// DeletePod deletes the pod identified by podID.
                                                                                    	DeletePod(namespace string, podID string, object runtime.Object) error
                                                                                    	// PatchPod patches the pod.
                                                                                    	PatchPod(namespace, name string, data []byte) error
                                                                                    	SetZeroCount()
                                                                                    }

                                                                                      PodControlInterface is an interface that knows how to add or delete pods created as an interface to allow testing.

                                                                                      type PodControllerRefManager

                                                                                      type PodControllerRefManager struct {
                                                                                      	BaseControllerRefManager
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                      func NewPodControllerRefManager

                                                                                      func NewPodControllerRefManager(
                                                                                      	podControl PodControlInterface,
                                                                                      	controller metav1.Object,
                                                                                      	selector labels.Selector,
                                                                                      	controllerKind schema.GroupVersionKind,
                                                                                      	canAdopt func() error,
                                                                                      ) *PodControllerRefManager

                                                                                        NewPodControllerRefManager returns a PodControllerRefManager that exposes methods to manage the controllerRef of pods.

                                                                                        The CanAdopt() function can be used to perform a potentially expensive check (such as a live GET from the API server) prior to the first adoption. It will only be called (at most once) if an adoption is actually attempted. If CanAdopt() returns a non-nil error, all adoptions will fail.

                                                                                        NOTE: Once CanAdopt() is called, it will not be called again by the same

                                                                                        PodControllerRefManager instance. Create a new instance if it makes
                                                                                        sense to check CanAdopt() again (e.g. in a different sync pass).
                                                                                        

                                                                                        func (*PodControllerRefManager) AdoptPod

                                                                                        func (m *PodControllerRefManager) AdoptPod(pod *v1.Pod) error

                                                                                          AdoptPod sends a patch to take control of the pod. It returns the error if the patching fails.

                                                                                          func (*PodControllerRefManager) ClaimPods

                                                                                          func (m *PodControllerRefManager) ClaimPods(pods []*v1.Pod, filters ...func(*v1.Pod) bool) ([]*v1.Pod, error)

                                                                                            ClaimPods tries to take ownership of a list of Pods.

                                                                                            It will reconcile the following:

                                                                                            * Adopt orphans if the selector matches.
                                                                                            * Release owned objects if the selector no longer matches.
                                                                                            

                                                                                            Optional: If one or more filters are specified, a Pod will only be claimed if all filters return true.

                                                                                            A non-nil error is returned if some form of reconciliation was attempted and failed. Usually, controllers should try again later in case reconciliation is still needed.

                                                                                            If the error is nil, either the reconciliation succeeded, or no reconciliation was necessary. The list of Pods that you now own is returned.

                                                                                            func (*PodControllerRefManager) ReleasePod

                                                                                            func (m *PodControllerRefManager) ReleasePod(pod *v1.Pod) error

                                                                                              ReleasePod sends a patch to free the pod from the control of the controller. It returns the error if the patching fails. 404 and 422 errors are ignored.

                                                                                              type RSControlInterface

                                                                                              type RSControlInterface interface {
                                                                                              	PatchReplicaSet(namespace, name string, data []byte) error
                                                                                              }

                                                                                                RSControlInterface is an interface that knows how to add or delete ReplicaSets, as well as increment or decrement them. It is used by the deployment controller to ease testing of actions that it takes.

                                                                                                type RealControllerRevisionControl

                                                                                                type RealControllerRevisionControl struct {
                                                                                                	KubeClient clientset.Interface
                                                                                                	KetiClient migration.MigrationV1Interface
                                                                                                }

                                                                                                  RealControllerRevisionControl is the default implementation of ControllerRevisionControlInterface.

                                                                                                  func (RealControllerRevisionControl) PatchControllerRevision

                                                                                                  func (r RealControllerRevisionControl) PatchControllerRevision(namespace, name string, data []byte) error

                                                                                                  type RealPodControl

                                                                                                  type RealPodControl struct {
                                                                                                  	KubeClient clientset.Interface
                                                                                                  	KetiClient migration.MigrationV1Interface
                                                                                                  	Recorder   record.EventRecorder
                                                                                                  	Number     int
                                                                                                  }

                                                                                                    RealPodControl is the default implementation of PodControlInterface.

                                                                                                    func (RealPodControl) CreatePods

                                                                                                    func (r RealPodControl) CreatePods(namespace string, template *v1.PodTemplateSpec, object runtime.Object) error

                                                                                                    func (RealPodControl) CreatePodsOnNode

                                                                                                    func (r RealPodControl) CreatePodsOnNode(nodeName, namespace string, template *v1.PodTemplateSpec, object runtime.Object, controllerRef *metav1.OwnerReference) error

                                                                                                    func (RealPodControl) CreatePodsWithControllerRef

                                                                                                    func (r RealPodControl) CreatePodsWithControllerRef(number int, obname, namespace string, template *v1.PodTemplateSpec, controllerObject runtime.Object, controllerRef *metav1.OwnerReference) error

                                                                                                    func (RealPodControl) DeletePod

                                                                                                    func (r RealPodControl) DeletePod(namespace string, podID string, object runtime.Object) error

                                                                                                    func (RealPodControl) PatchPod

                                                                                                    func (r RealPodControl) PatchPod(namespace, name string, data []byte) error

                                                                                                    func (RealPodControl) SetZeroCount

                                                                                                    func (r RealPodControl) SetZeroCount()

                                                                                                    type RealRSControl

                                                                                                    type RealRSControl struct {
                                                                                                    	KubeClient clientset.Interface
                                                                                                    	Recorder   record.EventRecorder
                                                                                                    }

                                                                                                      RealRSControl is the default implementation of RSControllerInterface.

                                                                                                      func (RealRSControl) PatchReplicaSet

                                                                                                      func (r RealRSControl) PatchReplicaSet(namespace, name string, data []byte) error

                                                                                                      type ReplicaSetControllerRefManager

                                                                                                      type ReplicaSetControllerRefManager struct {
                                                                                                      	BaseControllerRefManager
                                                                                                      	// contains filtered or unexported fields
                                                                                                      }

                                                                                                        ReplicaSetControllerRefManager is used to manage controllerRef of ReplicaSets. Three methods are defined on this object 1: Classify 2: AdoptReplicaSet and 3: ReleaseReplicaSet which are used to classify the ReplicaSets into appropriate categories and accordingly adopt or release them. See comments on these functions for more details.

                                                                                                        func NewReplicaSetControllerRefManager

                                                                                                        func NewReplicaSetControllerRefManager(
                                                                                                        	rsControl RSControlInterface,
                                                                                                        	controller metav1.Object,
                                                                                                        	selector labels.Selector,
                                                                                                        	controllerKind schema.GroupVersionKind,
                                                                                                        	canAdopt func() error,
                                                                                                        ) *ReplicaSetControllerRefManager

                                                                                                          NewReplicaSetControllerRefManager returns a ReplicaSetControllerRefManager that exposes methods to manage the controllerRef of ReplicaSets.

                                                                                                          The CanAdopt() function can be used to perform a potentially expensive check (such as a live GET from the API server) prior to the first adoption. It will only be called (at most once) if an adoption is actually attempted. If CanAdopt() returns a non-nil error, all adoptions will fail.

                                                                                                          NOTE: Once CanAdopt() is called, it will not be called again by the same

                                                                                                          ReplicaSetControllerRefManager instance. Create a new instance if it
                                                                                                          makes sense to check CanAdopt() again (e.g. in a different sync pass).
                                                                                                          

                                                                                                          func (*ReplicaSetControllerRefManager) AdoptReplicaSet

                                                                                                          func (m *ReplicaSetControllerRefManager) AdoptReplicaSet(rs *v1.ReplicaSet) error

                                                                                                            AdoptReplicaSet sends a patch to take control of the ReplicaSet. It returns the error if the patching fails.

                                                                                                            func (*ReplicaSetControllerRefManager) ClaimReplicaSets

                                                                                                            func (m *ReplicaSetControllerRefManager) ClaimReplicaSets(sets []*v1.ReplicaSet) ([]*v1.ReplicaSet, error)

                                                                                                              ClaimReplicaSets tries to take ownership of a list of ReplicaSets.

                                                                                                              It will reconcile the following:

                                                                                                              * Adopt orphans if the selector matches.
                                                                                                              * Release owned objects if the selector no longer matches.
                                                                                                              

                                                                                                              A non-nil error is returned if some form of reconciliation was attempted and failed. Usually, controllers should try again later in case reconciliation is still needed.

                                                                                                              If the error is nil, either the reconciliation succeeded, or no reconciliation was necessary. The list of ReplicaSets that you now own is returned.

                                                                                                              func (*ReplicaSetControllerRefManager) ReleaseReplicaSet

                                                                                                              func (m *ReplicaSetControllerRefManager) ReleaseReplicaSet(replicaSet *v1.ReplicaSet) error

                                                                                                                ReleaseReplicaSet sends a patch to free the ReplicaSet from the control of the Deployment controller. It returns the error if the patching fails. 404 and 422 errors are ignored.

                                                                                                                type ReplicaSetsByCreationTimestamp

                                                                                                                type ReplicaSetsByCreationTimestamp []*v1.ReplicaSet

                                                                                                                  ReplicaSetsByCreationTimestamp sorts a list of ReplicaSet by creation timestamp, using their names as a tie breaker.

                                                                                                                  func (ReplicaSetsByCreationTimestamp) Len

                                                                                                                  func (ReplicaSetsByCreationTimestamp) Less

                                                                                                                  func (ReplicaSetsByCreationTimestamp) Swap

                                                                                                                  func (o ReplicaSetsByCreationTimestamp) Swap(i, j int)

                                                                                                                  type ReplicaSetsBySizeNewer

                                                                                                                  type ReplicaSetsBySizeNewer []*v1.ReplicaSet

                                                                                                                    ReplicaSetsBySizeNewer sorts a list of ReplicaSet by size in descending order, using their creation timestamp or name as a tie breaker. By using the creation timestamp, this sorts from new to old replica sets.

                                                                                                                    func (ReplicaSetsBySizeNewer) Len

                                                                                                                    func (o ReplicaSetsBySizeNewer) Len() int

                                                                                                                    func (ReplicaSetsBySizeNewer) Less

                                                                                                                    func (o ReplicaSetsBySizeNewer) Less(i, j int) bool

                                                                                                                    func (ReplicaSetsBySizeNewer) Swap

                                                                                                                    func (o ReplicaSetsBySizeNewer) Swap(i, j int)

                                                                                                                    type ReplicaSetsBySizeOlder

                                                                                                                    type ReplicaSetsBySizeOlder []*v1.ReplicaSet

                                                                                                                      ReplicaSetsBySizeOlder sorts a list of ReplicaSet by size in descending order, using their creation timestamp or name as a tie breaker. By using the creation timestamp, this sorts from old to new replica sets.

                                                                                                                      func (ReplicaSetsBySizeOlder) Len

                                                                                                                      func (o ReplicaSetsBySizeOlder) Len() int

                                                                                                                      func (ReplicaSetsBySizeOlder) Less

                                                                                                                      func (o ReplicaSetsBySizeOlder) Less(i, j int) bool

                                                                                                                      func (ReplicaSetsBySizeOlder) Swap

                                                                                                                      func (o ReplicaSetsBySizeOlder) Swap(i, j int)

                                                                                                                      type ResyncPeriodFunc

                                                                                                                      type ResyncPeriodFunc func() time.Duration

                                                                                                                      func StaticResyncPeriodFunc

                                                                                                                      func StaticResyncPeriodFunc(resyncPeriod time.Duration) ResyncPeriodFunc

                                                                                                                        StaticResyncPeriodFunc returns the resync period specified

                                                                                                                        type UIDSet

                                                                                                                        type UIDSet struct {
                                                                                                                        	sets.String
                                                                                                                        	// contains filtered or unexported fields
                                                                                                                        }

                                                                                                                          UIDSet holds a key and a set of UIDs. Used by the UIDTrackingControllerExpectations to remember which UID it has seen/still waiting for.

                                                                                                                          type UIDTrackingControllerExpectations

                                                                                                                          type UIDTrackingControllerExpectations struct {
                                                                                                                          	ControllerExpectationsInterface
                                                                                                                          	// contains filtered or unexported fields
                                                                                                                          }

                                                                                                                            UIDTrackingControllerExpectations tracks the UID of the pods it deletes. This cache is needed over plain old expectations to safely handle graceful deletion. The desired behavior is to treat an update that sets the DeletionTimestamp on an object as a delete. To do so consistently, one needs to remember the expected deletes so they aren't double counted. TODO: Track creates as well (#22599)

                                                                                                                            func NewUIDTrackingControllerExpectations

                                                                                                                            func NewUIDTrackingControllerExpectations(ce ControllerExpectationsInterface) *UIDTrackingControllerExpectations

                                                                                                                              NewUIDTrackingControllerExpectations returns a wrapper around ControllerExpectations that is aware of deleteKeys.

                                                                                                                              func (*UIDTrackingControllerExpectations) DeleteExpectations

                                                                                                                              func (u *UIDTrackingControllerExpectations) DeleteExpectations(rcKey string)

                                                                                                                                DeleteExpectations deletes the UID set and invokes DeleteExpectations on the underlying ControllerExpectationsInterface.

                                                                                                                                func (*UIDTrackingControllerExpectations) DeletionObserved

                                                                                                                                func (u *UIDTrackingControllerExpectations) DeletionObserved(rcKey, deleteKey string)

                                                                                                                                  DeletionObserved records the given deleteKey as a deletion, for the given rc.

                                                                                                                                  func (*UIDTrackingControllerExpectations) ExpectDeletions

                                                                                                                                  func (u *UIDTrackingControllerExpectations) ExpectDeletions(rcKey string, deletedKeys []string) error

                                                                                                                                    ExpectDeletions records expectations for the given deleteKeys, against the given controller.

                                                                                                                                    func (*UIDTrackingControllerExpectations) GetUIDs

                                                                                                                                    func (u *UIDTrackingControllerExpectations) GetUIDs(controllerKey string) sets.String

                                                                                                                                      GetUIDs is a convenience method to avoid exposing the set of expected uids. The returned set is not thread safe, all modifications must be made holding the uidStoreLock.