type PodUpdate struct {
    Pods   []*v1.Pod
    Op     PodOperation
    Source string
}

// PodOperation 定义了将对pod配置进行哪些更改。
type PodOperation int

// These constants identify the PodOperations that can be made on a pod configuration.
const (
    // SET is the current pod configuration.
    SET PodOperation = iota
    // ADD signifies pods that are new to this source.
    ADD
    // DELETE signifies pods that are gracefully deleted from this source.
    DELETE
    // REMOVE signifies pods that have been removed from this source.
    REMOVE
    // UPDATE signifies pods have been updated in this source.
    UPDATE
    // RECONCILE signifies pods that have unexpected status in this source,
    // kubelet should reconcile status with this source.
    RECONCILE
)

func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {
	...
	// Start the pod lifecycle event generator.
	kl.pleg.Start()

	if utilfeature.DefaultFeatureGate.Enabled(features.EventedPLEG) {
		kl.eventedPleg.Start()
	}

	kl.syncLoop(ctx, updates, kl)
}

// SyncHandler is an interface implemented by Kubelet, for testability
type SyncHandler interface {
    HandlePodAdditions(pods []*v1.Pod)
    HandlePodUpdates(pods []*v1.Pod)
    HandlePodRemoves(pods []*v1.Pod)
    HandlePodReconcile(pods []*v1.Pod)
    HandlePodSyncs(pods []*v1.Pod)
    HandlePodCleanups(ctx context.Context) error
}

https://github.com/kubernetes/kubernetes/blob/v1.27.3/pkg/kubelet/kubelet.go#L2251-L2296
func (kl *Kubelet) syncLoop(ctx context.Context, updates <-chan kubetypes.PodUpdate, handler SyncHandler) {

    ...

    for {

        ...
        kl.syncLoopMonitor.Store(kl.clock.Now())
        // 重点
        if !kl.syncLoopIteration(ctx, updates, handler, syncTicker.C, housekeepingTicker.C, plegCh) {
            break
        }
        kl.syncLoopMonitor.Store(kl.clock.Now())
    }
}

func (kl *Kubelet) syncLoopIteration(ctx context.Context, configCh <-chan kubetypes.PodUpdate, handler SyncHandler,
    syncCh <-chan time.Time, housekeepingCh <-chan time.Time, plegCh <-chan *pleg.PodLifecycleEvent) bool {
    select {
    case u, open := <-configCh:
        // 变更回调
        if !open {
            klog.ErrorS(nil, "Update channel is closed, exiting the sync loop")
            return false
        }

        switch u.Op {
        case kubetypes.ADD:
            // After restarting, kubelet will get all existing pods through
            // ADD as if they are new pods. These pods will then go through the
            // admission process and *may* be rejected. This can be resolved
            // once we have checkpointing.
            handler.HandlePodAdditions(u.Pods)
        case kubetypes.UPDATE:
            handler.HandlePodUpdates(u.Pods)
        case kubetypes.REMOVE:
            handler.HandlePodRemoves(u.Pods)
        case kubetypes.RECONCILE:
            handler.HandlePodReconcile(u.Pods)
        case kubetypes.DELETE:
            handler.HandlePodUpdates(u.Pods)
        case kubetypes.SET:
            klog.ErrorS(nil, "Kubelet does not support snapshot update")
        default:
            klog.ErrorS(nil, "Invalid operation type received", "operation", u.Op)
        }

        // 添加配置源
        kl.sourcesReady.AddSource(u.Source)

    case e := <-plegCh:
        ...
    case <-syncCh:
        ...
    case update := <-kl.readinessManager.Updates():
        ...
    case update := <-kl.startupManager.Updates():
        ...
    case <-housekeepingCh:
        ...
    }
    return true
}

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

  // 1. 根据创建时间升序排序
    sort.Sort(sliceutils.PodsByCreationTime(pods))

    for _, pod := range pods {
        // 返回 regularPod及其规范
        existingPods := kl.podManager.GetPods()

        // 2. 添加Pod到podManager
        kl.podManager.AddPod(pod)

        // 3. 如果是 mirrorPod, 则直接 handleMirrorPod() 并返回
        if kubetypes.IsMirrorPod(pod) {
            kl.handleMirrorPod(pod, start)
            continue
        }

        // 4. 当前Pod已被发送 Termination 请求
        if !kl.podWorkers.IsPodTerminationRequested(pod.UID) {
            // We failed pods that we rejected, so activePods include all admitted
            // pods that are alive.
            // 排除 已终止/发送终止请求/处于终止阶段 类的Pods
            activePods := kl.filterOutInactivePods(existingPods)

          // 启用 InPlacePodVerticalScaling 特性
            if utilfeature.DefaultFeatureGate.Enabled(features.InPlacePodVerticalScaling) {
                // 调整cpu 和 内存
                podCopy := pod.DeepCopy()
                for _, c := range podCopy.Spec.Containers {
                    allocatedResources, found := kl.statusManager.GetContainerResourceAllocation(string(pod.UID), c.Name)
                    if c.Resources.Requests != nil && found {
                        c.Resources.Requests[v1.ResourceCPU] = allocatedResources[v1.ResourceCPU]
                        c.Resources.Requests[v1.ResourceMemory] = allocatedResources[v1.ResourceMemory]
                    }
                }

                // 检查当前pod是否允许准入
                if ok, reason, message := kl.canAdmitPod(activePods, podCopy); !ok {
                    kl.rejectPod(pod, reason, message)
                    continue
                }

                // For new pod, checkpoint the resource values at which the Pod has been admitted
                if err := kl.statusManager.SetPodAllocation(podCopy); err != nil {
                    klog.ErrorS(err, "SetPodAllocation failed", "pod", klog.KObj(pod))
                }
            } else {
                // 检查当前pod是否允许准入
                if ok, reason, message := kl.canAdmitPod(activePods, pod); !ok {
                    kl.rejectPod(pod, reason, message)
                    continue
                }
            }
        }

        // 5. 获取对应的mirrorPod，在 pod worker 中异步同步pod
        mirrorPod, _ := kl.podManager.GetMirrorPodByPod(pod)
        kl.dispatchWork(pod, kubetypes.SyncPodCreate, mirrorPod, start)
    }

}

func (kl *Kubelet) HandlePodUpdates(pods []*v1.Pod) {
    start := kl.clock.Now()
    for _, pod := range pods {
      // 1. UpdatePod
        kl.podManager.UpdatePod(pod)

        // 2. dispatchWork
        if kubetypes.IsMirrorPod(pod) {
            kl.handleMirrorPod(pod, start)
            continue
        }
        mirrorPod, _ := kl.podManager.GetMirrorPodByPod(pod)
        kl.dispatchWork(pod, kubetypes.SyncPodUpdate, mirrorPod, start)
    }
}

func (kl *Kubelet) HandlePodRemoves(pods []*v1.Pod) {
    start := kl.clock.Now()
    for _, pod := range pods {
        // DeletePod
        kl.podManager.DeletePod(pod)

        // 如果是mirrorPod, 则读取出来其对应的 staticPod, 然后再直接 kl.dispatchWork
        if kubetypes.IsMirrorPod(pod) {
            kl.handleMirrorPod(pod, start)
            continue
        }
        // Deletion is allowed to fail because the periodic cleanup routine
        // will trigger deletion again.
        if err := kl.deletePod(pod); err != nil {
            klog.V(2).InfoS("Failed to delete pod", "pod", klog.KObj(pod), "err", err)
        }
    }
}

func (kl *Kubelet) HandlePodReconcile(pods []*v1.Pod) {
    start := kl.clock.Now()
    for _, pod := range pods {
        // 1. UpdatePod
        kl.podManager.UpdatePod(pod)

        // 2. pod为 ready 状态，则调用 dispatchWork() 进行pod同步
        // Reconcile Pod "Ready" condition if necessary. Trigger sync pod for reconciliation.
        if status.NeedToReconcilePodReadiness(pod) {
            mirrorPod, _ := kl.podManager.GetMirrorPodByPod(pod)
            kl.dispatchWork(pod, kubetypes.SyncPodSync, mirrorPod, start)
        }

        // 如果pod已处于 evicted 状态，则直接删除所有相关containers
        // After an evicted pod is synced, all dead containers in the pod can be removed.
        if eviction.PodIsEvicted(pod.Status) {
            if podStatus, err := kl.podCache.Get(pod.UID); err == nil {
                kl.containerDeletor.deleteContainersInPod("", podStatus, true)
            }
        }
    }
}

func (kl *Kubelet) dispatchWork(pod *v1.Pod, syncType kubetypes.SyncPodType, mirrorPod *v1.Pod, start time.Time) {
    // Run the sync in an async worker.
    kl.podWorkers.UpdatePod(UpdatePodOptions{
        Pod:        pod,
        MirrorPod:  mirrorPod,
        UpdateType: syncType,
        StartTime:  start,
    })
    ...
}

type UpdatePodOptions struct {
    UpdateType     types.SyncPodType
    StartTime      time.Time
    Pod            *v1.Pod
    MirrorPod      *v1.Pod
    RunningPod     *container.Pod
    KillPodOptions *KillPodOptions
}

type PodWorkers interface {
    UpdatePod(options UpdatePodOptions)
    SyncKnownPods(desiredPods []*v1.Pod) (knownPods map[types.UID]PodWorkerSync)
    IsPodKnownTerminated(uid types.UID) bool
    CouldHaveRunningContainers(uid types.UID) bool
    ShouldPodBeFinished(uid types.UID) bool
    IsPodTerminationRequested(uid types.UID) bool
    ShouldPodContainersBeTerminating(uid types.UID) bool
    ShouldPodRuntimeBeRemoved(uid types.UID) bool
    ShouldPodContentBeRemoved(uid types.UID) bool
    IsPodForMirrorPodTerminatingByFullName(podFullname string) bool
}

func (p *podWorkers) UpdatePod(options UpdatePodOptions) {
  // 1. 获取Pod信息(Pod或runningPod)，如uid、ns 或 name
    if runningPod := options.RunningPod; runningPod != nil {
        if options.Pod == nil {
            uid, ns, name = runningPod.ID, runningPod.Namespace, runningPod.Name
            isRuntimePod = true
        } else {
            options.RunningPod = nil
            uid, ns, name = options.Pod.UID, options.Pod.Namespace, options.Pod.Name
        }
    } else {
        uid, ns, name = options.Pod.UID, options.Pod.Namespace, options.Pod.Name
    }

    // 2. 根据 pod.UID 获取当前Pod的同步状态，如果为首次同步则设置并记录当前pod的同步状态
    var firstTime bool
    now := p.clock.Now()
    status, ok := p.podSyncStatuses[uid]
    if !ok {
        // 当前Pod为首次同步
        firstTime = true
        status = &podSyncStatus{
            syncedAt: now,
            fullname: kubecontainer.BuildPodFullName(name, ns),
        }

        if options.Pod != nil && (options.Pod.Status.Phase == v1.PodFailed || options.Pod.Status.Phase == v1.PodSucceeded) {
            if statusCache, err := p.podCache.Get(uid); err == nil {
                if isPodStatusCacheTerminal(statusCache) {

                    status = &podSyncStatus{
                        terminatedAt:       now,
                        terminatingAt:      now,
                        syncedAt:           now,
                        startedTerminating: true,
                        finished:           false,
                        fullname:           kubecontainer.BuildPodFullName(name, ns),
                    }
                }
            }
        }
        p.podSyncStatuses[uid] = status
    }

    // 3. RunningPods表示未知的pod执行，并且不包含足以执行除终止之外的任何操作的pod规范信息。这里根据不同情况给 Pod 字段赋值
    pod := options.Pod
    if isRuntimePod {
        ...
    }
    if status.IsFinished() {
        return
    }

    // 非 terminate 请求处理
    // check for a transition to terminating
    var becameTerminating bool
    if !status.IsTerminationRequested() {

    }

    // 4. 创建并启动一个 pod worker 的goroutine
    // start the pod worker goroutine if it doesn't exist
    podUpdates, exists := p.podUpdates[uid]
    if !exists {
        // 为当前Pod 创建一个 PodWorker专用 podUpdates 的channel, 以便于接受后期的变更信号
        podUpdates = make(chan struct{}, 1)
        p.podUpdates[uid] = podUpdates

        // spawn a pod worker
        go func() {
            // 启用一个 podWorkerLoop 服务
            p.podWorkerLoop(uid, outCh)
        }()
    }

    // 5.  发送一个信号到 podUpdates channel, 通知 pod worker 这是一个 pending update
    status.pendingUpdate = &options
    status.working = true
    select {
    case podUpdates <- struct{}{}:
    default:
    }
    if (becameTerminating || wasGracePeriodShortened) && status.cancelFn != nil {
        status.cancelFn()
        return
    }
}

func (p *podWorkers) podWorkerLoop(podUID types.UID, podUpdates <-chan struct{}) {
    var lastSyncTime time.Time
    for range podUpdates {
        // 一、修改Pod状态为 started
        ctx, update, canStart, canEverStart, ok := p.startPodSync(podUID)
	if !ok {
		continue
	}
        ...

        // 二、同步Pod，针对update.WorkType的三种情况：SyncPod、TerminatingPod 和 TerminatedPod
        err := func() error {
            // 采取适当的操作（UpdatePod阻止非法阶段）
            switch {
            // TerminatedPod 表示pod已停止，不能再有正在运行的容器，并且可以执行任何前台清理。
            case update.WorkType == TerminatedPod:
                err = p.podSyncer.SyncTerminatedPod(ctx, update.Options.Pod, status)

            // TerminatingPod 是指Pod不再被设置，但某些容器可能正在运行并被销毁。
            case update.WorkType == TerminatingPod:
                var gracePeriod *int64
                if opt := update.Options.KillPodOptions; opt != nil {
                    gracePeriod = opt.PodTerminationGracePeriodSecondsOverride
                }
                podStatusFn := p.acknowledgeTerminating(podUID)

                // if we only have a running pod, terminate it directly
                if update.Options.RunningPod != nil {
                    err = p.podSyncer.SyncTerminatingRuntimePod(ctx, update.Options.RunningPod)
                } else {
                    err = p.podSyncer.SyncTerminatingPod(ctx, update.Options.Pod, status, gracePeriod, podStatusFn)
                }

            default:
                // 重点:同步Pod
                isTerminal, err = p.podSyncer.SyncPod(ctx, update.Options.UpdateType, update.Options.Pod, update.Options.MirrorPod, status)
            }

            lastSyncTime = p.clock.Now()
            return err
        }

        // switch语句里的 err 是表示上面定义的匿名函数
        var phaseTransition bool
        switch {
        case err == context.Canceled:
            // when the context is cancelled we expect an update to already be queued

        case err != nil:
            // we will queue a retry

        case update.WorkType == TerminatedPod:
            // 1. we can shut down the worker
            p.completeTerminated(podUID)

            return

        case update.WorkType == TerminatingPod:
          // 2. completeTerminatingRuntimePod(podUID)
            if update.Options.RunningPod != nil {
                p.completeTerminatingRuntimePod(podUID)
                return
            }
            // 3. otherwise we move to the terminating phase
            p.completeTerminating(podUID)
            phaseTransition = true

        case isTerminal:
          // 4 p.completeSync(podUID)
            p.completeSync(podUID)
            phaseTransition = true
        }

        // 三、重新入队 p.workQueue 队列
        p.completeWork(podUID, phaseTransition, err)
    }
}

func (p *podWorkers) startPodSync(podUID types.UID) (ctx context.Context, update podWork, canStart, canEverStart, ok bool) {
	// verify we are known to the pod worker still
	status, ok := p.podSyncStatuses[podUID]
	if !ok {
		return nil, update, false, false, false
	}

	// consume the pending update
	update.WorkType = status.WorkType()
	update.Options = *status.pendingUpdate
	status.pendingUpdate = nil

	select {
	case <-p.podUpdates[podUID]:
		// ensure the pod update channel is empty (it is only ever written to under lock)
	default:
	}

	// initialize a context for the worker if one does not exist
	if status.ctx == nil || status.ctx.Err() == context.Canceled {
		status.ctx, status.cancelFn = context.WithCancel(context.Background())
	}
	ctx = status.ctx

	// if we are already started, make our state visible to downstream components
	if status.IsStarted() {
		status.mergeLastUpdate(update.Options)
		return ctx, update, true, true, true
	}

	// verify we can start
	canStart, canEverStart = p.allowPodStart(update.Options.Pod)
	switch {
	case !canEverStart:
		p.cleanupUnstartedPod(update.Options.Pod, status)
		status.working = false
		return ctx, update, canStart, canEverStart, true
	case !canStart:
		// this is the only path we don't start the pod, so we need to put the change back in pendingUpdate
		status.pendingUpdate = &update.Options
		status.working = false
		return ctx, update, canStart, canEverStart, true
	}

	// 修改Pod状态为 started
	status.startedAt = p.clock.Now()
	status.mergeLastUpdate(update.Options)

	return ctx, update, true, true, true
}

// https://github.com/kubernetes/kubernetes/blob/v1.27.3/pkg/kubelet/kubelet.go#L1656
func (kl *Kubelet) SyncPod(_ context.Context, updateType kubetypes.SyncPodType, pod, mirrorPod *v1.Pod, podStatus *kubecontainer.PodStatus) (isTerminal bool, err error) {

	var firstSeenTime time.Time
	if firstSeenTimeStr, ok := pod.Annotations[kubetypes.ConfigFirstSeenAnnotationKey]; ok {
		firstSeenTime = kubetypes.ConvertToTimestamp(firstSeenTimeStr).Get()
	}

	// 如果pod操作为create，则记录pod工作程序启动延迟
	if updateType == kubetypes.SyncPodCreate {
		metrics.PodWorkerStartDuration.Observe(metrics.SinceInSeconds(firstSeenTime))
	}

	// 根据pod和 status manager 生成最终 API pod status, 如果已是最终的状态，则直接中止操作
	apiPodStatus := kl.generateAPIPodStatus(pod, podStatus, false)
	...

	// 如果Pod不应该运行，则请求将其容器停止
	runnable := kl.canRunPod(pod)
	if !runnable.Admit {
		// Pod无法运行；并根据原因更新Pod和Container状态。
		if apiPodStatus.Phase != v1.PodFailed && apiPodStatus.Phase != v1.PodSucceeded {
			apiPodStatus.Phase = v1.PodPending
		}
		apiPodStatus.Reason = runnable.Reason
		apiPodStatus.Message = runnable.Message
		// Waiting containers are not creating.
		const waitingReason = "Blocked"
		for _, cs := range apiPodStatus.InitContainerStatuses {
			if cs.State.Waiting != nil {
				cs.State.Waiting.Reason = waitingReason
			}
		}
		for _, cs := range apiPodStatus.ContainerStatuses {
			if cs.State.Waiting != nil {
				cs.State.Waiting.Reason = waitingReason
			}
		}
	}

	// 记录Pod变为 running 所花费的时间
	existingStatus, ok := kl.statusManager.GetPodStatus(pod.UID)
	if !ok || existingStatus.Phase == v1.PodPending && apiPodStatus.Phase == v1.PodRunning &&
		!firstSeenTime.IsZero() {
		metrics.PodStartDuration.Observe(metrics.SinceInSeconds(firstSeenTime))
	}

	// 在 status manager 中更新pod 状态
	kl.statusManager.SetPodStatus(pod, apiPodStatus)

	// 如果Pod不能运行则必须停止，并返回一个已知类型的错误给pod worker
	if !runnable.Admit {
		var syncErr error
		// 将当前处于运行中的 container，组合成一个新的pod
		p := kubecontainer.ConvertPodStatusToRunningPod(kl.getRuntime().Type(), podStatus)
		if err := kl.killPod(ctx, pod, p, nil); err != nil {
			syncErr = fmt.Errorf("error killing pod: %v", err)
			utilruntime.HandleError(syncErr)
		} else {
			syncErr = fmt.Errorf("pod cannot be run: %s", runnable.Message)
		}
		return false, syncErr
	}

}

// https://github.com/kubernetes/kubernetes/blob/v1.27.3/pkg/kubelet/kubelet.go#L1656
func (kl *Kubelet) SyncPod(_ context.Context, updateType kubetypes.SyncPodType, pod, mirrorPod *v1.Pod, podStatus *kubecontainer.PodStatus) (isTerminal bool, err error) {

	// 网络插件未准备好（未安装cni插件，如 flannel、calico或cilium），且不是 host network ，则返回错误
	if err := kl.runtimeState.networkErrors(); err != nil && !kubecontainer.IsHostNetworkPod(pod) {
		return false, fmt.Errorf("%s: %v", NetworkNotReadyErrorMsg, err)
	}

	// kubelet知道pod引用了configMap 或 secret 资源
	if !kl.podWorkers.IsPodTerminationRequested(pod.UID) {
		if kl.secretManager != nil {
			kl.secretManager.RegisterPod(pod)
		}
		if kl.configMapManager != nil {
			kl.configMapManager.RegisterPod(pod)
		}
	}

	// 为 Pod 创建Cgroup
	pcm := kl.containerManager.NewPodContainerManager()

	// 如果为 staticPod，则为其创建 mirrorPod
	if kubetypes.IsStaticPod(pod) {...}

	// 为Pod创建data 目录（每个pod都有自己三类目录 1. Pod目录 2.Volumes 目录 3.插件目录，其中volumes和 插件目录属于pod目录的子目录）
	if err := kl.makePodDataDirs(pod); err != nil {}

	// 为 Pod attach/mount volumes
	if !kl.podWorkers.IsPodTerminationRequested(pod.UID) {
		// Wait for volumes to attach/mount
		if err := kl.volumeManager.WaitForAttachAndMount(pod); err != nil {
			kl.recorder.Eventf(pod, v1.EventTypeWarning, events.FailedMountVolume, "Unable to attach or mount volumes: %v", err)
			klog.ErrorS(err, "Unable to attach or mount volumes for pod; skipping pod", "pod", klog.KObj(pod))
			return false, err
		}
	}

}

    // Fetch the pull secrets for the pod
	pullSecrets := kl.getPullSecretsForPod(pod)

	// 为Pod添加Probe（最多三类探针：StartupProbe、ReadinessProbe、LivenessProbe, 每一类都启动一个goroutine来运行）
	kl.probeManager.AddPod(pod)

func (kl *Kubelet) getPullSecretsForPod(pod *v1.Pod) []v1.Secret {
	pullSecrets := []v1.Secret{}

	for _, secretRef := range pod.Spec.ImagePullSecrets {
		if len(secretRef.Name) == 0 {
			// API validation permitted entries with empty names (https://issue.k8s.io/99454#issuecomment-787838112).
			// Ignore to avoid unnecessary warnings.
			continue
		}
		secret, err := kl.secretManager.GetSecret(pod.Namespace, secretRef.Name)
		if err != nil {
			klog.InfoS("Unable to retrieve pull secret, the image pull may not succeed.", "pod", klog.KObj(pod), "secret", klog.KObj(secret), "err", err)
			continue
		}

		pullSecrets = append(pullSecrets, *secret)
	}

	return pullSecrets
}

func (m *manager) AddPod(pod *v1.Pod) {
	m.workerLock.Lock()
	defer m.workerLock.Unlock()

	key := probeKey{podUID: pod.UID}
	for _, c := range pod.Spec.Containers {
		key.containerName = c.Name

		if c.StartupProbe != nil {
			key.probeType = startup
			...
			w := newWorker(m, startup, pod, c)
			m.workers[key] = w
			go w.run()
		}

		if c.ReadinessProbe != nil {
			key.probeType = readiness
			...
			w := newWorker(m, readiness, pod, c)
			m.workers[key] = w
			go w.run()
		}

		if c.LivenessProbe != nil {
			key.probeType = liveness
			...
			w := newWorker(m, liveness, pod, c)
			m.workers[key] = w
			go w.run()
		}
	}
}

// Call the container runtime's SyncPod callback
	result := kl.containerRuntime.SyncPod(ctx, pod, podStatus, pullSecrets, kl.backOff)
	kl.reasonCache.Update(pod.UID, result)
	if err := result.Error(); err != nil {
		for _, r := range result.SyncResults {
			if r.Error != kubecontainer.ErrCrashLoopBackOff && r.Error != images.ErrImagePullBackOff {
				return false, err
			}
		}

		return false, nil
	}

func (p *podWorkers) completeWork(podUID types.UID, phaseTransition bool, syncErr error) {
    // Requeue the last update if the last sync returned error.
    switch {
    case phaseTransition:
        p.workQueue.Enqueue(podUID, 0)
    case syncErr == nil:
        // No error; requeue at the regular resync interval.
        p.workQueue.Enqueue(podUID, wait.Jitter(p.resyncInterval, workerResyncIntervalJitterFactor))
    case strings.Contains(syncErr.Error(), NetworkNotReadyErrorMsg):
        // Network is not ready; back off for short period of time and retry as network might be ready soon.
        p.workQueue.Enqueue(podUID, wait.Jitter(backOffOnTransientErrorPeriod, workerBackOffPeriodJitterFactor))
    default:
        // Error occurred during the sync; back off and then retry.
        p.workQueue.Enqueue(podUID, wait.Jitter(p.backOffPeriod, workerBackOffPeriodJitterFactor))
    }

    //  如果这是一个 pending update ，则直接添加到 workQueue队列，否则 status.working = false
    p.podLock.Lock()
    defer p.podLock.Unlock()
    if status, ok := p.podSyncStatuses[podUID]; ok {
        if status.pendingUpdate != nil {
            select {
            case p.podUpdates[podUID] <- struct{}{}:
                klog.V(4).InfoS("Requeueing pod due to pending update", "podUID", podUID)
            default:
                klog.V(4).InfoS("Pending update already queued", "podUID", podUID)
            }
        } else {
            status.working = false
        }
    }
}

// https://github.com/kubernetes/kubernetes/blob/v1.27.3/pkg/kubelet/pod_workers.go#L243-L270

type podSyncer interface {
    SyncPod(ctx context.Context, updateType types.SyncPodType, pod *v1.Pod, mirrorPod *v1.Pod, podStatus *container.PodStatus) (bool, error)
    SyncTerminatingPod(ctx context.Context, pod *v1.Pod, podStatus *container.PodStatus, gracePeriod *int64, podStatusFn func(*v1.PodStatus)) error
    SyncTerminatingRuntimePod(ctx context.Context, runningPod *container.Pod) error
    SyncTerminatedPod(ctx context.Context, pod *v1.Pod, podStatus *container.PodStatus) error
}

type basicManager struct {
    // Protects all internal maps.
    lock sync.RWMutex

    // Regular pods indexed by UID.
    podByUID map[kubetypes.ResolvedPodUID]*v1.Pod
    // Mirror pods indexed by UID.
    mirrorPodByUID map[kubetypes.MirrorPodUID]*v1.Pod

    // Pods indexed by full name for easy access.
    podByFullName       map[string]*v1.Pod
    mirrorPodByFullName map[string]*v1.Pod

    // Mirror pod UID to pod UID map.
    translationByUID map[kubetypes.MirrorPodUID]kubetypes.ResolvedPodUID

    // A mirror pod client to create/delete mirror pods.
    MirrorClient  // 对应 basicMirrorClient 对象
}

// pkg/kubelet/pod/mirror_client.go#L54
// 实现了 MirrorClient 接口
type basicMirrorClient struct {
    apiserverClient clientset.Interface
    nodeGetter      nodeGetter
    nodeName        string
}

// MirrorClient knows how to create/delete a mirror pod in the API server.
type MirrorClient interface {
    // CreateMirrorPod creates a mirror pod in the API server for the given
    // pod or returns an error.  The mirror pod will have the same annotations
    // as the given pod as well as an extra annotation containing the hash of
    // the static pod.
    CreateMirrorPod(pod *v1.Pod) error
    // DeleteMirrorPod deletes the mirror pod with the given full name from
    // the API server or returns an error.
    DeleteMirrorPod(podFullName string, uid *types.UID) (bool, error)
}

type Manager interface {
    GetPods() []*v1.Pod
    GetPodByFullName(podFullName string) (*v1.Pod, bool)
    GetPodByName(namespace string, name string) (*v1.Pod, bool)
    GetPodByUID(types.UID) (*v1.Pod, bool)
    GetPodByMirrorPod(*v1.Pod) (*v1.Pod, bool)
    GetMirrorPodByPod(*v1.Pod) (*v1.Pod, bool)
    GetPodsAndMirrorPods() ([]*v1.Pod, []*v1.Pod)
    SetPods(pods []*v1.Pod)
    AddPod(pod *v1.Pod)
    UpdatePod(pod *v1.Pod)
    DeletePod(pod *v1.Pod)
    GetOrphanedMirrorPodNames() []string
    TranslatePodUID(uid types.UID) types.ResolvedPodUID
    GetUIDTranslations() (podToMirror map[types.ResolvedPodUID]types.MirrorPodUID, mirrorToPod map[types.MirrorPodUID]types.ResolvedPodUID)
    IsMirrorPodOf(mirrorPod *v1.Pod, pod *v1.Pod) bool
    MirrorClient
}

apiVersion: v1
kind: Pod
metadata:
  name: my-static-pod
spec:
  containers:
  - name: my-container
    image: nginx:1.16