const BurstReplicas … const StatusUpdateRetries … const BackoffGCInterval … const SelectingAllReason … const FailedPlacementReason … const FailedDaemonPodReason … const SucceededDaemonPodReason … var controllerKind … type DaemonSetsController … // NewDaemonSetsController creates a new DaemonSetsController func NewDaemonSetsController( ctx context.Context, daemonSetInformer appsinformers.DaemonSetInformer, historyInformer appsinformers.ControllerRevisionInformer, podInformer coreinformers.PodInformer, nodeInformer coreinformers.NodeInformer, kubeClient clientset.Interface, failedPodsBackoff *flowcontrol.Backoff, ) (*DaemonSetsController, error) { … } func (dsc *DaemonSetsController) addDaemonset(logger klog.Logger, obj interface{ … } func (dsc *DaemonSetsController) updateDaemonset(logger klog.Logger, cur, old interface{ … } func (dsc *DaemonSetsController) deleteDaemonset(logger klog.Logger, obj interface{ … } // Run begins watching and syncing daemon sets. func (dsc *DaemonSetsController) Run(ctx context.Context, workers int) { … } func (dsc *DaemonSetsController) runWorker(ctx context.Context) { … } // processNextWorkItem deals with one key off the queue. It returns false when it's time to quit. func (dsc *DaemonSetsController) processNextWorkItem(ctx context.Context) bool { … } func (dsc *DaemonSetsController) enqueue(ds *apps.DaemonSet) { … } func (dsc *DaemonSetsController) enqueueDaemonSetAfter(obj interface{ … } // getDaemonSetsForPod returns a list of DaemonSets that potentially match the pod. func (dsc *DaemonSetsController) getDaemonSetsForPod(pod *v1.Pod) []*apps.DaemonSet { … } // getDaemonSetsForHistory returns a list of DaemonSets that potentially // match a ControllerRevision. func (dsc *DaemonSetsController) getDaemonSetsForHistory(logger klog.Logger, history *apps.ControllerRevision) []*apps.DaemonSet { … } // addHistory enqueues the DaemonSet that manages a ControllerRevision when the ControllerRevision is created // or when the controller manager is restarted. func (dsc *DaemonSetsController) addHistory(logger klog.Logger, obj interface{ … } // updateHistory figures out what DaemonSet(s) manage a ControllerRevision when the ControllerRevision // is updated and wake them up. If anything of the ControllerRevision has changed, we need to awaken // both the old and new DaemonSets. func (dsc *DaemonSetsController) updateHistory(logger klog.Logger, old, cur interface{ … } // deleteHistory enqueues the DaemonSet that manages a ControllerRevision when // the ControllerRevision is deleted. obj could be an *app.ControllerRevision, or // a DeletionFinalStateUnknown marker item. func (dsc *DaemonSetsController) deleteHistory(logger klog.Logger, obj interface{ … } func (dsc *DaemonSetsController) addPod(logger klog.Logger, obj interface{ … } // When a pod is updated, figure out what sets manage it and wake them // up. If the labels of the pod have changed we need to awaken both the old // and new set. old and cur must be *v1.Pod types. func (dsc *DaemonSetsController) updatePod(logger klog.Logger, old, cur interface{ … } func (dsc *DaemonSetsController) deletePod(logger klog.Logger, obj interface{ … } func (dsc *DaemonSetsController) addNode(logger klog.Logger, obj interface{ … } // shouldIgnoreNodeUpdate returns true if Node labels and taints have not changed, otherwise returns false. // If other calling functions need to use other properties of Node, shouldIgnoreNodeUpdate needs to be updated. func shouldIgnoreNodeUpdate(oldNode, curNode v1.Node) bool { … } func (dsc *DaemonSetsController) updateNode(logger klog.Logger, old, cur interface{ … } // getDaemonPods returns daemon pods owned by the given ds. // This also reconciles ControllerRef by adopting/orphaning. // Note that returned Pods are pointers to objects in the cache. // If you want to modify one, you need to deep-copy it first. func (dsc *DaemonSetsController) getDaemonPods(ctx context.Context, ds *apps.DaemonSet) ([]*v1.Pod, error) { … } // getNodesToDaemonPods returns a map from nodes to daemon pods (corresponding to ds) created for the nodes. // This also reconciles ControllerRef by adopting/orphaning. // Note that returned Pods are pointers to objects in the cache. // If you want to modify one, you need to deep-copy it first. func (dsc *DaemonSetsController) getNodesToDaemonPods(ctx context.Context, ds *apps.DaemonSet, includeDeletedTerminal bool) (map[string][]*v1.Pod, error) { … } // resolveControllerRef returns the controller referenced by a ControllerRef, // or nil if the ControllerRef could not be resolved to a matching controller // of the correct Kind. func (dsc *DaemonSetsController) resolveControllerRef(namespace string, controllerRef *metav1.OwnerReference) *apps.DaemonSet { … } // podsShouldBeOnNode figures out the DaemonSet pods to be created and deleted on the given node: // - nodesNeedingDaemonPods: the pods need to start on the node // - podsToDelete: the Pods need to be deleted on the node // - err: unexpected error func (dsc *DaemonSetsController) podsShouldBeOnNode( logger klog.Logger, node *v1.Node, nodeToDaemonPods map[string][]*v1.Pod, ds *apps.DaemonSet, hash string, ) (nodesNeedingDaemonPods, podsToDelete []string) { … } func (dsc *DaemonSetsController) updateDaemonSet(ctx context.Context, ds *apps.DaemonSet, nodeList []*v1.Node, hash, key string, old []*apps.ControllerRevision) error { … } // manage manages the scheduling and running of Pods of ds on nodes. // After figuring out which nodes should run a Pod of ds but not yet running one and // which nodes should not run a Pod of ds but currently running one, it calls function // syncNodes with a list of pods to remove and a list of nodes to run a Pod of ds. func (dsc *DaemonSetsController) manage(ctx context.Context, ds *apps.DaemonSet, nodeList []*v1.Node, hash string) error { … } // syncNodes deletes given pods and creates new daemon set pods on the given nodes // returns slice with errors if any func (dsc *DaemonSetsController) syncNodes(ctx context.Context, ds *apps.DaemonSet, podsToDelete, nodesNeedingDaemonPods []string, hash string) error { … } func storeDaemonSetStatus( ctx context.Context, dsClient unversionedapps.DaemonSetInterface, ds *apps.DaemonSet, desiredNumberScheduled, currentNumberScheduled, numberMisscheduled, numberReady, updatedNumberScheduled, numberAvailable, numberUnavailable int, updateObservedGen bool) error { … } func (dsc *DaemonSetsController) updateDaemonSetStatus(ctx context.Context, ds *apps.DaemonSet, nodeList []*v1.Node, hash string, updateObservedGen bool) error { … } func (dsc *DaemonSetsController) syncDaemonSet(ctx context.Context, key string) error { … } // NodeShouldRunDaemonPod checks a set of preconditions against a (node,daemonset) and returns a // summary. Returned booleans are: // - shouldRun: // Returns true when a daemonset should run on the node if a daemonset pod is not already // running on that node. // - shouldContinueRunning: // Returns true when a daemonset should continue running on a node if a daemonset pod is already // running on that node. func NodeShouldRunDaemonPod(node *v1.Node, ds *apps.DaemonSet) (bool, bool) { … } // predicates checks if a DaemonSet's pod can run on a node. func predicates(pod *v1.Pod, node *v1.Node, taints []v1.Taint) (fitsNodeName, fitsNodeAffinity, fitsTaints bool) { … } // NewPod creates a new pod func NewPod(ds *apps.DaemonSet, nodeName string) *v1.Pod { … } type podByCreationTimestampAndPhase … func (o podByCreationTimestampAndPhase) Len() int { … } func (o podByCreationTimestampAndPhase) Swap(i, j int) { … } func (o podByCreationTimestampAndPhase) Less(i, j int) bool { … } func failedPodsBackoffKey(ds *apps.DaemonSet, nodeName string) string { … } // getUnscheduledPodsWithoutNode returns list of unscheduled pods assigned to not existing nodes. // Returned pods can't be deleted by PodGCController so they should be deleted by DaemonSetController. func getUnscheduledPodsWithoutNode(runningNodesList []*v1.Node, nodeToDaemonPods map[string][]*v1.Pod) []string { … }
Codebase Browser
kubernetes