// is added to the array of nodes in that zone.
func (nt *nodeTree) addNode(logger klog.Logger, n *v1.Node) {
	zone := utilnode.GetZoneKey(n)
	if na, ok := nt.tree[zone]; ok {
		for _, nodeName := range na {
			if nodeName == n.Name {
				logger.Info("Did not add to the NodeTree because it already exists", "node", klog.KObj(n))
				return
			}
		}
		nt.tree[zone] = append(na, n.Name)
	} else {

  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:
      apiVersion: apiVersionValue
      fieldPath: fieldPathValue
      kind: kindValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  notReadyAddresses:
  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:

        "subresource": "subresourceValue"
      }
    ]
  },
  "subsets": [
    {
      "addresses": [
        {
          "ip": "ipValue",
          "hostname": "hostnameValue",
          "nodeName": "nodeNameValue",
          "targetRef": {
            "kind": "kindValue",
            "namespace": "namespaceValue",
            "name": "nameValue",
            "uid": "uidValue",

  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:
      apiVersion: apiVersionValue
      fieldPath: fieldPathValue
      kind: kindValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  notReadyAddresses:
  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:

			},

			Client:      client,
			Proxier:     &FakeProxier{},
			Broadcaster: broadcaster,
			Recorder:    recorder,
			NodeRef: &v1.ObjectReference{
				Kind:      "Node",
				Name:      nodeName,
				UID:       types.UID(nodeName),
				Namespace: "",
			},
		},
	}
}

func (hp *HollowProxy) Run() error {

	if err := hp.ProxyServer.Run(context.TODO()); err != nil {

	DynamicResources                = "DynamicResources"
	ImageLocality                   = "ImageLocality"
	InterPodAffinity                = "InterPodAffinity"
	NodeAffinity                    = "NodeAffinity"
	NodeName                        = "NodeName"
	NodePorts                       = "NodePorts"
	NodeResourcesBalancedAllocation = "NodeResourcesBalancedAllocation"
	NodeResourcesFit                = "NodeResourcesFit"

	compare := CacheComparer{}
	nodes := []*v1.Node{}
	for _, nodeName := range actual {
		node := &v1.Node{}
		node.Name = nodeName
		nodes = append(nodes, node)
	}

	nodeInfo := make(map[string]*framework.NodeInfo)
	for _, nodeName := range cached {
		nodeInfo[nodeName] = &framework.NodeInfo{}
	}

	m, r := compare.CompareNodes(nodes, nodeInfo)

}

// NewActualStateOfWorld returns a new instance of ActualStateOfWorld.
func NewActualStateOfWorld(
	nodeName types.NodeName,
	volumePluginMgr *volume.VolumePluginMgr) ActualStateOfWorld {
	return &actualStateOfWorld{
		nodeName:                  nodeName,
		attachedVolumes:           make(map[v1.UniqueVolumeName]attachedVolume),

// or returns an error.
func NewKubeletServerCertificateManager(kubeClient clientset.Interface, kubeCfg *kubeletconfig.KubeletConfiguration, nodeName types.NodeName, getAddresses func() []v1.NodeAddress, certDirectory string) (certificate.Manager, error) {
	var clientsetFn certificate.ClientsetFunc
	if kubeClient != nil {

	UninstallCSIDriver(driverName string) error
}

// NewNodeInfoManager initializes nodeInfoManager
func NewNodeInfoManager(
	nodeName types.NodeName,
	volumeHost volume.VolumeHost,
	migratedPlugins map[string](func() bool)) Interface {
	return &nodeInfoManager{
		nodeName:        nodeName,
		volumeHost:      volumeHost,
		migratedPlugins: migratedPlugins,
	}
}