//
// To clarify the various types:
//
//   - Node.Name is the Name field of the Node in the API.  This should be stored in a NodeName.
//     Unfortunately, because Name is part of ObjectMeta, we can't store it as a NodeName at the API level.
//
//   - Hostname is the hostname of the local machine (from uname -n).
//     However, some components allow the user to pass in a --hostname-override flag,

	nodeAddressesErr     error
	nodeAddresses        []v1.NodeAddress

	nodeName types.NodeName
}

// NewSyncManager creates a manager responsible for collecting resources from a
// cloud provider through requests that are sensitive to timeouts and hanging
func NewSyncManager(cloud cloudprovider.Interface, nodeName types.NodeName, syncPeriod time.Duration) SyncManager {
	return &cloudResourceSyncManager{
		cloud:      cloud,

	dswp.desiredStateOfWorld.AddNode(k8stypes.NodeName(pod.Spec.NodeName))
	logger, _ := ktesting.NewTestContext(t)
	dswp.findAndAddActivePods(logger)

	expectedVolumeName := v1.UniqueVolumeName(generatedVolumeName)

	//check if the given volume referenced by the pod is added to dsw
	volumeExists := dswp.desiredStateOfWorld.VolumeExists(expectedVolumeName, k8stypes.NodeName(pod.Spec.NodeName))
	if !volumeExists {
		t.Fatalf(

	needsUpdate, attachedVolumes := nsu.actualStateOfWorld.GetVolumesToReportAttachedForNode(logger, nodeName)
	if !needsUpdate {
		return nil
	}
	return nsu.processNodeVolumes(logger, nodeName, attachedVolumes)
}

func (nsu *nodeStatusUpdater) processNodeVolumes(logger klog.Logger, nodeName types.NodeName, attachedVolumes []v1.AttachedVolume) error {

limitations under the License.
*/

package nodename

import (
	"context"

	v1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/kubernetes/pkg/scheduler/framework"
	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/names"
)

// NodeName is a plugin that checks if a pod spec node name matches the current node.
type NodeName struct{}

var _ framework.FilterPlugin = &NodeName{}

				Zone: utilpointer.String("zone1"),
			},
		},
		{
			desc: "nodeName and topology[hostname] are populated with different values",
			external: v1beta1.Endpoint{
				NodeName: utilpointer.String("node-1"),
				Topology: map[string]string{
					corev1.LabelHostname: "node-2",
				},
			},
			internal: discovery.Endpoint{
				NodeName: utilpointer.String("node-1"),
				DeprecatedTopology: map[string]string{

// Therefore, hostname is retrieve with uname syscall and the Nodename field.

func hostname() (name string, err error) {
	var u syscall.Utsname
	if errno := syscall.Uname(&u); errno != nil {
		return "", NewSyscallError("uname", errno)
	}
	b := make([]byte, len(u.Nodename))
	i := 0
	for ; i < len(u.Nodename); i++ {
		if u.Nodename[i] == 0 {
			break
		}
		b[i] = byte(u.Nodename[i])
	}
	return string(b[:i]), nil

	}
	for _, slice := range slices {
		if model[slice.NodeName] == nil {
			model[slice.NodeName] = make(map[string]ResourceModels)
		}
		resource := model[slice.NodeName][slice.DriverName]
		namedresourcesmodel.AddResources(&resource.NamedResources, slice.NamedResources)
		model[slice.NodeName][slice.DriverName] = resource
	}

	objs := claimAssumeCache.List(nil)
	for _, obj := range objs {

		IPs: []IPConfig{{
			Address: *addr,
		}},
	}

	setupLogging()
	NodeName = "testnode"
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "pod-bingo",
			Namespace: "funkyns",
		},
		Spec: corev1.PodSpec{
			NodeName: NodeName,
		},
		Status: corev1.PodStatus{
			PodIP: fakePodIP,
		},
	}

// and the user name matches the format system:node:<nodeName>, and populates
// nodeName if isNode is true
func NewDefaultNodeIdentifier() NodeIdentifier {
	return defaultNodeIdentifier{}
}

// defaultNodeIdentifier implements NodeIdentifier
type defaultNodeIdentifier struct{}

// nodeUserNamePrefix is the prefix for usernames in the form `system:node:<nodeName>`
const nodeUserNamePrefix = "system:node:"