func GetContainerOOMScoreAdjust(pod *v1.Pod, container *v1.Container, memoryCapacity int64) int {
	switch GetPodQOS(pod) {
	case v1.PodQOSGuaranteed:
		return guaranteedOOMScoreAdj
	case v1.PodQOSBestEffort:
		return besteffortOOMScoreAdj
	}
	memoryRequest := container.Resources.Requests.Memory().Value()
	oomScoreAdjust := 1000 - (1000*memoryRequest)/memoryCapacity

	if int(oomScoreAdjust) < (1000 + guaranteedOOMScoreAdj) {
		return (1000 + guaranteedOOMScoreAdj)
	}
	if int(oomScoreAdjust) == besteffortOOMScoreAdj {
		return int(oomScoreAdjust - 1)
	}
	return int(oomScoreAdjust)
}

func (rsc *ReplicaSetController) manageReplicas(filteredPods []*v1.Pod, rs *apps.ReplicaSet) error {
if diff > 0 { //diff 是当前pod数和rs上的replica数的差，大于0为缩容
    if diff > rsc.burstReplicas {
      diff = rsc.burstReplicas
    }
    klog.V(2).Infof("Too many replicas for %v %s/%s, need %d, deleting %d", rsc.Kind, rs.Namespace, rs.Name, *(rs.Spec.Replicas), diff)
​
    // Choose which Pods to delete, preferring those in earlier phases of startup.
    podsToDelete := getPodsToDelete(filteredPods, diff) //删pod的顺序在这个里面
​
    rsc.expectations.ExpectDeletions(rsKey, getPodKeys(podsToDelete))
​
    errCh := make(chan error, diff)
    var wg sync.WaitGroup
    wg.Add(diff)
    for _, pod := range podsToDelete {
      go func(targetPod *v1.Pod) {
        defer wg.Done()
        if err := rsc.podControl.DeletePod(rs.Namespace, targetPod.Name, rs); err != nil {
          // Decrement the expected number of deletes because the informer won't observe this deletion
          podKey := controller.PodKey(targetPod)
          klog.V(2).Infof("Failed to delete %v, decrementing expectations for %v %s/%s", podKey, rsc.Kind, rs.Namespace, rs.Name)
          rsc.expectations.DeletionObserved(rsKey, podKey)
          errCh <- err
        }
      }(pod)
    }
    wg.Wait()

func getPodsToDelete(filteredPods []*v1.Pod, diff int) []*v1.Pod {
	// No need to sort pods if we are about to delete all of them.
	// diff will always be <= len(filteredPods), so not need to handle > case.
	if diff < len(filteredPods) {
		// Sort the pods in the order such that not-ready < ready, unscheduled
		// < scheduled, and pending < running. This ensures that we delete pods
		// in the earlier stages whenever possible.
		sort.Sort(controller.ActivePods(filteredPods))
	}
	return filteredPods[:diff]
}

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

	// 1. Unassigned < assigned
	// If only one of the pods is unassigned, the unassigned one is smaller
	if s[i].Spec.NodeName != s[j].Spec.NodeName && (len(s[i].Spec.NodeName) == 0 || len(s[j].Spec.NodeName) == 0) {
		return len(s[i].Spec.NodeName) == 0
	}
	// 2. PodPending < PodUnknown < PodRunning
	m := map[v1.PodPhase]int{v1.PodPending: 0, v1.PodUnknown: 1, v1.PodRunning: 2}
	if m[s[i].Status.Phase] != m[s[j].Status.Phase] {
		return m[s[i].Status.Phase] < m[s[j].Status.Phase]
	}
	// 3. Not ready < ready
	// If only one of the pods is not ready, the not ready one is smaller
	if podutil.IsPodReady(s[i]) != podutil.IsPodReady(s[j]) {
		return !podutil.IsPodReady(s[i])
	}
	// TODO: take availability into account when we push minReadySeconds information from deployment into pods,
	//       see https://github.com/kubernetes/kubernetes/issues/22065
	// 4. Been ready for empty time < less time < more time
	// If both pods are ready, the latest ready one is smaller
	if podutil.IsPodReady(s[i]) && podutil.IsPodReady(s[j]) && !podReadyTime(s[i]).Equal(podReadyTime(s[j])) {
		return afterOrZero(podReadyTime(s[i]), podReadyTime(s[j]))
	}
	// 5. Pods with containers with higher restart counts < lower restart counts
	if maxContainerRestarts(s[i]) != maxContainerRestarts(s[j]) {
		return maxContainerRestarts(s[i]) > maxContainerRestarts(s[j])
	}
	// 6. Empty creation time pods < newer pods < older pods
	if !s[i].CreationTimestamp.Equal(&s[j].CreationTimestamp) {
		return afterOrZero(&s[i].CreationTimestamp, &s[j].CreationTimestamp)
	}
	return false
}

//0. controller.alpha.kubernetes.io/delete-priority=1 < controller.alpha.kubernetes.io/delete-priority=0
//If pod has annotation controller.alpha.kubernetes.io/delete-priority the larger is small
if s[i].Annotations[DeletePriorityPodAnnotationKey] != s[j].Annotations[DeletePriorityPodAnnotationKey] {
	s1, err1 := strconv.Atoi(s[i].Annotations[DeletePriorityPodAnnotationKey])
	s2, err2 := strconv.Atoi(s[j].Annotations[DeletePriorityPodAnnotationKey])
	if err1 == nil && err2 == nil {
		return s1 > s2
	}
   }

if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.SupportPodPidsLimit) {
    supportedSubsystems = append(supportedSubsystems, &cgroupfs.PidsGroup{})
  }
  if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.SupportPodPidsLimit) && cgroupConfig.ResourceParameters.PodPidsLimit != nil {
    libcontainerCgroupConfig.PidsLimit = *cgroupConfig.ResourceParameters.PodPidsLimit
  }
  if utilfeature.DefaultFeatureGate.Enabled(kubefeatures.SupportPodPidsLimit) && cgroupConfig.ResourceParameters.PodPidsLimit != nil {
    libcontainerCgroupConfig.PidsLimit = *cgroupConfig.ResourceParameters.PodPidsLimit
  }

  // Process IDs are not a node allocatable, so we have to do this ad hoc
  pidlimits, err := pidlimit.Stats()
  if err == nil && pidlimits != nil && pidlimits.MaxPID != nil {
    allocatablePIDs = resource.NewQuantity(int64(*pidlimits.MaxPID), resource.DecimalSI)
    allocatablePIDs.Sub(resource.MustParse(pids))
  }
  return allocatableCPU, allocatableMemory, allocatablePIDs
}  }

func cmdAdd(args *skel.CmdArgs) error {

func cmdDel(args *skel.CmdArgs) error {

func cmdAdd(args *skel.CmdArgs) error {
	versionDecoder := &cniversion.ConfigDecoder{}
	confVersion, err := versionDecoder.Decode(args.StdinData)
	if err != nil {
		return err
	}

	cniNetns, err := ns.GetNS(args.Netns) //获得当前的NS
	if err != nil {
		return err
	}
    //...
	allocResult, err := terwayBackendClient.AllocIP( //阿里自己的东西去拿ip，我们实现的话也是类似这样逻辑
		timeoutContext,
		&rpc.AllocIPRequest{
			Netns:                  args.Netns,
			K8SPodName:             string(k8sConfig.K8S_POD_NAME),
			K8SPodNamespace:        string(k8sConfig.K8S_POD_NAMESPACE),
			K8SPodInfraContainerId: string(k8sConfig.K8S_POD_INFRA_CONTAINER_ID),
			IfName:                 args.IfName,
		})
	hostVethName := link.VethNameForPod(string(k8sConfig.K8S_POD_NAME), string(k8sConfig.K8S_POD_NAMESPACE), defaultVethPrefix)
	var (
		allocatedIPAddr      net.IPNet
		allocatedGatewayAddr net.IP
	)

	switch allocResult.IPType {
	case rpc.IPType_TypeENIMultiIP:
		

        err = networkDriver.Setup(hostVethName, args.IfName, subnet, gw, nil, int(deviceId), ingress, egress, cniNetns)
        //阿里自己的网络驱动吧，其实也类似，如果我们有类似的东西的话需要去设置下
		if err != nil {
			return fmt.Errorf("setup network failed: %v", err)
		}
		allocatedIPAddr = *subnet
		allocatedGatewayAddr = gw

	case rpc.IPType_TypeVPCIP:
		if allocResult.GetVpcIp() == nil || allocResult.GetVpcIp().GetPodConfig() == nil ||
			allocResult.GetVpcIp().NodeCidr == "" {
			return fmt.Errorf("vpc ip result is empty: %v", allocResult)
		}
		...
        var r types.Result
        //阿里这是调用ipam插件去设置网络
		r, err = ipam.ExecAdd(delegateIpam, []byte(fmt.Sprintf(delegateConf, subnet.String())))
		if err != nil {
			return fmt.Errorf("error allocate ip from delegate ipam %v: %v", delegateIpam, err)
		}
		podIPAddr := ipamResult.IPs[0].Address
		gateway := ipamResult.IPs[0].Gateway

		ingress := allocResult.GetVpcIp().GetPodConfig().GetIngress()
		egress := allocResult.GetVpcIp().GetPodConfig().GetEgress()

		err = networkDriver.Setup(hostVethName, args.IfName, &podIPAddr, gateway, nil, 0, ingress, egress, cniNetns)
		if err != nil {
			return fmt.Errorf("setup network failed: %v", err)
		}
		allocatedIPAddr = podIPAddr
		allocatedGatewayAddr = gateway
	case rpc.IPType_TypeVPCENI:
		if allocResult.GetVpcEni() == nil || allocResult.GetVpcEni().GetServiceCidr() == "" ||
			allocResult.GetVpcEni().GetEniConfig() == nil {
			return fmt.Errorf("vpcEni ip result is empty: %v", allocResult)
		}
		var srvSubnet *net.IPNet
		_, srvSubnet, err = net.ParseCIDR(allocResult.GetVpcEni().GetServiceCidr())
		if err != nil {
			return fmt.Errorf("vpc eni return srv subnet is not vaild: %v", allocResult.GetVpcEni().GetServiceCidr())
		}
        ...
		ingress := allocResult.GetVpcEni().GetPodConfig().GetIngress()
		egress := allocResult.GetVpcEni().GetPodConfig().GetEgress()
        //这个看起来又是另外一个阿里的网络类型
		err = nicDriver.Setup(hostVethName, args.IfName, eniAddrSubnet, gw, nil, int(deviceNumber), 0, 0, cniNetns)
		if err != nil {
			return fmt.Errorf("setup network for vpc eni failed: %v", err)
		}
		allocatedIPAddr = *eniAddrSubnet
		allocatedGatewayAddr = gw
	default:
		return fmt.Errorf("not support this network type")
	}
    //这个是关键，其实我们正常简单实现就是在cmdAdd中加自己的逻辑，并且完成下面这个结构的拼装，其他就是和框架的事情了。
	result := &current.Result{
		IPs: []*current.IPConfig{{
			Version: "4",
			Address: allocatedIPAddr,
			Gateway: allocatedGatewayAddr,
		}},
	}

	return types.PrintResult(result, confVersion)
}

func cmdAdd(args *skel.CmdArgs) error {
    types.LoadArgs()//加载参数，取你需要的东西
    /*type CmdArgs struct {  
	ContainerID string
	Netns       string
	IfName      string
	Args        string //这里应该是k8s传过来，只看到有K8S_POD_NAMESPACE K8S_POD_NAME K8S_POD_INFRA_CONTAINER_ID
	Path        string
    StdinData   []byte
    }*/
    
    //写你自己的逻辑去拿下IP
    //填写下面的结构
	result := &current.Result{
		IPs: []*current.IPConfig{{
			Version: "4",
			Address: allocatedIPAddr,
			Gateway: allocatedGatewayAddr,
		}},
	}
	
	return types.PrintResult(result, CONF_VERSION)
}

// NetConf describes a network.
type NetConf struct {
	CNIVersion string `json:"cniVersion,omitempty"`

	Name         string          `json:"name,omitempty"`
	Type         string          `json:"type,omitempty"`
	Capabilities map[string]bool `json:"capabilities,omitempty"`
	IPAM         struct {
		Type string `json:"type,omitempty"`
	} `json:"ipam,omitempty"`
	DNS DNS `json:"dns"`
}