为什么删除Pod时webhook收到三次delete请求

1case "DELETE": // Delete a resource.
2    // ...
3
4    handler := metrics.InstrumentRouteFunc(action.Verb, group, version, resource, subresource, requestScope, metrics.APIServerComponent, deprecated, removedRelease, restfulDeleteResource(gracefulDeleter, isGracefulDeleter, reqScope, admit))
5
6    ...

1func restfulDeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope handlers.RequestScope, admit admission.Interface) restful.RouteFunction {
2	return func(req *restful.Request, res *restful.Response) {
3		handlers.DeleteResource(r, allowsOptions, &scope, admit)(res.ResponseWriter, req.Request)
4	}
5}

 1func DeleteResource(r rest.GracefulDeleter, allowsOptions bool, scope *RequestScope, admit admission.Interface) http.HandlerFunc {
 2    //...
 3
 4    trace.Step("About to delete object from database")
 5		wasDeleted := true
 6		userInfo, _ := request.UserFrom(ctx)
 7		staticAdmissionAttrs := admission.NewAttributesRecord(nil, nil, scope.Kind, namespace, name, scope.Resource, scope.Subresource, admission.Delete, options, dryrun.IsDryRun(options.DryRun), userInfo)
 8		result, err := finishRequest(timeout, func() (runtime.Object, error) {
 9			obj, deleted, err := r.Delete(ctx, name, rest.AdmissionToValidateObjectDeleteFunc(admit, staticAdmissionAttrs, scope), options)
10			wasDeleted = deleted
11			return obj, err
12		})
13		if err != nil {
14			scope.err(err, w, req)
15			return
16		}
17        trace.Step("Object deleted from database")
18        
19        ...
20}

 1func (kl *Kubelet) syncLoopIteration(configCh <-chan kubetypes.PodUpdate, handler SyncHandler,
 2	syncCh <-chan time.Time, housekeepingCh <-chan time.Time, plegCh <-chan *pleg.PodLifecycleEvent) bool {
 3	select {
 4	case u, open := <-configCh:
 5		// Update from a config source; dispatch it to the right handler
 6		// callback.
 7		if !open {
 8			klog.Errorf("Update channel is closed. Exiting the sync loop.")
 9			return false
10		}
11
12		switch u.Op {
13		case kubetypes.ADD:
14			klog.V(2).Infof("SyncLoop (ADD, %q): %q", u.Source, format.Pods(u.Pods))
15			// After restarting, kubelet will get all existing pods through
16			// ADD as if they are new pods. These pods will then go through the
17			// admission process and *may* be rejected. This can be resolved
18			// once we have checkpointing.
19			handler.HandlePodAdditions(u.Pods)
20		case kubetypes.UPDATE:
21			klog.V(2).Infof("SyncLoop (UPDATE, %q): %q", u.Source, format.PodsWithDeletionTimestamps(u.Pods))
22			handler.HandlePodUpdates(u.Pods)
23		case kubetypes.REMOVE:
24			klog.V(2).Infof("SyncLoop (REMOVE, %q): %q", u.Source, format.Pods(u.Pods))
25			handler.HandlePodRemoves(u.Pods)
26		case kubetypes.RECONCILE:
27			klog.V(4).Infof("SyncLoop (RECONCILE, %q): %q", u.Source, format.Pods(u.Pods))
28			handler.HandlePodReconcile(u.Pods)
29		case kubetypes.DELETE:
30			klog.V(2).Infof("SyncLoop (DELETE, %q): %q", u.Source, format.Pods(u.Pods))
31			// DELETE is treated as a UPDATE because of graceful deletion.
32			handler.HandlePodUpdates(u.Pods)
33		case kubetypes.RESTORE:
34			klog.V(2).Infof("SyncLoop (RESTORE, %q): %q", u.Source, format.Pods(u.Pods))
35			// These are pods restored from the checkpoint. Treat them as new
36			// pods.
37			handler.HandlePodAdditions(u.Pods)
38		case kubetypes.SET:
39			// TODO: Do we want to support this?
40			klog.Errorf("Kubelet does not support snapshot update")
41        }
42
43        ...

 1func (m *kubeGenericRuntimeManager) killContainer(pod *v1.Pod, containerID kubecontainer.ContainerID, containerName string, message string, gracePeriodOverride *int64) error {
 2	...
 3
 4	// From this point, pod and container must be non-nil.
 5	gracePeriod := int64(minimumGracePeriodInSeconds)
 6	switch {
 7	case pod.DeletionGracePeriodSeconds != nil:
 8		gracePeriod = *pod.DeletionGracePeriodSeconds
 9	case pod.Spec.TerminationGracePeriodSeconds != nil:
10		gracePeriod = *pod.Spec.TerminationGracePeriodSeconds
11	}
12
13	if len(message) == 0 {
14		message = fmt.Sprintf("Stopping container %s", containerSpec.Name)
15	}
16	m.recordContainerEvent(pod, containerSpec, containerID.ID, v1.EventTypeNormal, events.KillingContainer, message)
17
18	// Run internal pre-stop lifecycle hook
19	if err := m.internalLifecycle.PreStopContainer(containerID.ID); err != nil {
20		return err
21	}
22
23	// Run the pre-stop lifecycle hooks if applicable and if there is enough time to run it
24	if containerSpec.Lifecycle != nil && containerSpec.Lifecycle.PreStop != nil && gracePeriod > 0 {
25		gracePeriod = gracePeriod - m.executePreStopHook(pod, containerID, containerSpec, gracePeriod)
26	}
27	// always give containers a minimal shutdown window to avoid unnecessary SIGKILLs
28	if gracePeriod < minimumGracePeriodInSeconds {
29		gracePeriod = minimumGracePeriodInSeconds
30	}
31	if gracePeriodOverride != nil {
32		gracePeriod = *gracePeriodOverride
33		klog.V(3).Infof("Killing container %q, but using %d second grace period override", containerID, gracePeriod)
34	}
35
36	klog.V(2).Infof("Killing container %q with %d second grace period", containerID.String(), gracePeriod)
37
38	err := m.runtimeService.StopContainer(containerID.ID, gracePeriod)
39	if err != nil {
40		klog.Errorf("Container %q termination failed with gracePeriod %d: %v", containerID.String(), gracePeriod, err)
41	} else {
42		klog.V(3).Infof("Container %q exited normally", containerID.String())
43	}
44
45	m.containerRefManager.ClearRef(containerID)
46
47	return err
48}  

 1func (m *manager) syncPod(uid types.UID, status versionedPodStatus) {
 2    ...
 3
 4    if m.canBeDeleted(pod, status.status) {
 5		deleteOptions := metav1.DeleteOptions{
 6			GracePeriodSeconds: new(int64),
 7			// Use the pod UID as the precondition for deletion to prevent deleting a
 8			// newly created pod with the same name and namespace.
 9			Preconditions: metav1.NewUIDPreconditions(string(pod.UID)),
10		}
11		err = m.kubeClient.CoreV1().Pods(pod.Namespace).Delete(context.TODO(), pod.Name, deleteOptions)
12		if err != nil {
13			klog.Warningf("Failed to delete status for pod %q: %v", format.Pod(pod), err)
14			return
15		}
16		klog.V(3).Infof("Pod %q fully terminated and removed from etcd", format.Pod(pod))
17		m.deletePodStatus(uid)
18	}
19}

 1func (e *Store) Delete(ctx context.Context, name string, deleteValidation rest.ValidateObjectFunc, options *metav1.DeleteOptions) (runtime.Object, bool, error) {
 2    ...
 3    // delete immediately, or no graceful deletion supported
 4    klog.V(6).Infof("going to delete %s from registry: ", name)
 5    out = e.NewFunc()
 6    if err := e.Storage.Delete(ctx, key, out, &preconditions, storage.ValidateObjectFunc(deleteValidation), dryrun.IsDryRun(options.DryRun)); err != nil {
 7        // Please refer to the place where we set ignoreNotFound for the reason
 8        // why we ignore the NotFound error .
 9        if storage.IsNotFound(err) && ignoreNotFound && lastExisting != nil {
10            // The lastExisting object may not be the last state of the object
11            // before its deletion, but it's the best approximation.
12            out, err := e.finalizeDelete(ctx, lastExisting, true)
13            return out, true, err
14        }
15        return nil, false, storeerr.InterpretDeleteError(err, qualifiedResource, name)
16    }
17    ...
18}

 1func (s *store) conditionalDelete(ctx context.Context, key string, out runtime.Object, v reflect.Value, preconditions *storage.Preconditions, validateDeletion storage.ValidateObjectFunc) error {
 2    ...
 3    for {
 4		origState, err := s.getState(getResp, key, v, false)
 5		if err != nil {
 6			return err
 7		}
 8		if preconditions != nil {
 9			if err := preconditions.Check(key, origState.obj); err != nil {
10				return err
11			}
12		}
13		if err := validateDeletion(ctx, origState.obj); err != nil {
14			return err
15		}
16		startTime := time.Now()
17		txnResp, err := s.client.KV.Txn(ctx).If(
18			clientv3.Compare(clientv3.ModRevision(key), "=", origState.rev),
19		).Then(
20			clientv3.OpDelete(key),
21		).Else(
22			clientv3.OpGet(key),
23        ).Commit()
24    ...
25
26}