logger.V(4).Info("Node has no CIDR, ignoring", "node", klog.KObj(&node))
				continue
			}
			logger.V(4).Info("Node has CIDR, occupying it in CIDR map", "node", klog.KObj(&node), "podCIDR", node.Spec.PodCIDR)
			if err := ra.occupyCIDRs(&node); err != nil {
				// This will happen if:
				// 1. We find garbage in the podCIDRs field. Retrying is useless.
				// 2. CIDR out of range: This means a node CIDR has changed.

	}
	// If both fields (v1.PodCIDRs and v1.PodCIDR) are provided and differ, then PodCIDR is authoritative for compatibility with older clients
	if (len(in.PodCIDR) > 0 && len(in.PodCIDRs) > 0) && (in.PodCIDR != in.PodCIDRs[0]) {
		out.PodCIDRs = []string{in.PodCIDR}
	}

	// at the this point, autoConvert copied v1.PodCIDRs -> core.PodCIDRs
	// if v1.PodCIDRs was empty but v1.PodCIDR is not, then set core.PodCIDRs[0] with v1.PodCIDR

	}
	return 0, nil
}

func waitForPodCIDR(ctx context.Context, client clientset.Interface, nodeName string) (*v1.Node, error) {
	// since allocators can assign the podCIDR after the node registers, we do a watch here to wait
	// for podCIDR to be assigned, instead of assuming that the Get() on startup will have it.
	ctx, cancelFunc := context.WithTimeout(ctx, timeoutForNodePodCIDR)
	defer cancelFunc()

        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "podCIDR": "podCIDRValue",
    "podCIDRs": [
      "podCIDRsValue"
    ],
    "providerID": "providerIDValue",
    "unschedulable": true,
    "taints": [
      {
        "key": "keyValue",

        "time": "2004-01-01T01:01:01Z",
        "fieldsType": "fieldsTypeValue",
        "fieldsV1": {},
        "subresource": "subresourceValue"
      }
    ]
  },
  "spec": {
    "podCIDR": "podCIDRValue",
    "podCIDRs": [
      "podCIDRsValue"
    ],
    "providerID": "providerIDValue",
    "unschedulable": true,
    "taints": [
      {
        "key": "keyValue",

    configMap:
      kubeletConfigKey: kubeletConfigKeyValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  externalID: externalIDValue
  podCIDR: podCIDRValue
  podCIDRs:
  - podCIDRsValue
  providerID: providerIDValue
  taints:
  - effect: effectValue
    key: keyValue
    timeAdded: "2004-01-01T01:01:01Z"
    value: valueValue
  unschedulable: true

    configMap:
      kubeletConfigKey: kubeletConfigKeyValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  externalID: externalIDValue
  podCIDR: podCIDRValue
  podCIDRs:
  - podCIDRsValue
  providerID: providerIDValue
  taints:
  - effect: effectValue
    key: keyValue
    timeAdded: "2004-01-01T01:01:01Z"
    value: valueValue
  unschedulable: true

	"sync"

	v1 "k8s.io/api/core/v1"
	"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/proxy/config"
	"k8s.io/kubernetes/pkg/proxy/healthcheck"
)

// NodePodCIDRHandler handles the life cycle of kube-proxy based on the node PodCIDR assigned
// Implements the config.NodeHandler interface
// https://issues.k8s.io/111321
type NodePodCIDRHandler struct {
	mu       sync.Mutex
	podCIDRs []string
	logger   klog.Logger
}

	s.Lock()
	defer s.Unlock()
	s.storageError = err
}

func (s *runtimeState) setPodCIDR(cidr string) {
	s.Lock()
	defer s.Unlock()
	s.cidr = cidr
}

func (s *runtimeState) podCIDR() string {
	s.RLock()
	defer s.RUnlock()
	return s.cidr
}

func (s *runtimeState) runtimeErrors() error {
	s.RLock()
	defer s.RUnlock()
	errs := []error{}
	if s.lastBaseRuntimeSync.IsZero() {

		},
		Spec: v1.NodeSpec{
			PodCIDR:  "10.0.0.0/24",
			PodCIDRs: []string{"10.0.0.0/24", "2001:db2:1/64"},
		},
	}
	node := &v1.Node{
		ObjectMeta: metav1.ObjectMeta{
			Name:            nodeName,
			ResourceVersion: "1",
		},
	}
	updatedNode := node.DeepCopy()
	updatedNode.Spec.PodCIDRs = expected
	updatedNode.Spec.PodCIDR = expected[0]

	// start with the new node