func()

in pkg/cloudprovider/vsphere/nodemanager.go [181:340]

• 135 lines of code
• 29 McCabe index (conditional complexity)

func (nm *NodeManager) DiscoverNode(nodeID string, searchBy cm.FindVM) error {
	ctx := context.Background()

	vmDI, err := nm.shakeOutNodeIDLookup(ctx, nodeID, searchBy)
	if err != nil {
		klog.Errorf("shakeOutNodeIDLookup failed. Err=%v", err)
		return err
	}

	if vmDI.UUID == "" {
		return errors.New("discovered VM UUID is empty")
	}

	var oVM mo.VirtualMachine
	err = vmDI.VM.Properties(ctx, vmDI.VM.Reference(), []string{"guest", "summary"}, &oVM)
	if err != nil {
		klog.Errorf("Error collecting properties for vm=%+v in vc=%s and datacenter=%s: %v",
			vmDI.VM, vmDI.VcServer, vmDI.DataCenter.Name(), err)
		return err
	}

	if oVM.Guest == nil {
		return errors.New("VirtualMachine Guest property was nil")
	}

	if oVM.Guest.HostName == "" {
		return errors.New("VM Guest hostname is empty")
	}

	tenantRef := vmDI.VcServer
	if vmDI.TenantRef != "" {
		tenantRef = vmDI.TenantRef
	}
	vcInstance := nm.connectionManager.VsphereInstanceMap[tenantRef]

	ipFamilies := []string{vcfg.DefaultIPFamily}
	if vcInstance != nil {
		ipFamilies = vcInstance.Cfg.IPFamilyPriority
	} else {
		klog.Warningf("Unable to find vcInstance for %s. Defaulting to ipv4.", tenantRef)
	}

	var internalNetworkSubnets []*net.IPNet
	var externalNetworkSubnets []*net.IPNet
	var excludeInternalNetworkSubnets []*net.IPNet
	var excludeExternalNetworkSubnets []*net.IPNet
	var internalVMNetworkName string
	var externalVMNetworkName string

	if nm.cfg != nil {
		internalNetworkSubnets, err = parseCIDRs(nm.cfg.Nodes.InternalNetworkSubnetCIDR)
		if err != nil {
			return err
		}
		externalNetworkSubnets, err = parseCIDRs(nm.cfg.Nodes.ExternalNetworkSubnetCIDR)
		if err != nil {
			return err
		}
		excludeInternalNetworkSubnets, err = parseCIDRs(nm.cfg.Nodes.ExcludeInternalNetworkSubnetCIDR)
		if err != nil {
			return err
		}
		excludeExternalNetworkSubnets, err = parseCIDRs(nm.cfg.Nodes.ExcludeExternalNetworkSubnetCIDR)
		if err != nil {
			return err
		}
		internalVMNetworkName = nm.cfg.Nodes.InternalVMNetworkName
		externalVMNetworkName = nm.cfg.Nodes.ExternalVMNetworkName
	}

	addrs := []v1.NodeAddress{}
	klog.V(2).Infof("Adding Hostname: %s", oVM.Guest.HostName)
	v1helper.AddToNodeAddresses(&addrs,
		v1.NodeAddress{
			Type:    v1.NodeHostName,
			Address: oVM.Guest.HostName,
		},
	)

	nonVNICDevices := collectNonVNICDevices(oVM.Guest.Net)
	for _, v := range nonVNICDevices {
		klog.V(6).Infof("internalVMNetworkName = %s", internalVMNetworkName)
		klog.V(6).Infof("externalVMNetworkName = %s", externalVMNetworkName)
		klog.V(6).Infof("v.Network = %s", v.Network)

		if (internalVMNetworkName != "" && !strings.EqualFold(internalVMNetworkName, v.Network)) &&
			(externalVMNetworkName != "" && !strings.EqualFold(externalVMNetworkName, v.Network)) {
			klog.V(4).Infof("Skipping device because vNIC Network=%s doesn't match internal=%s or external=%s network names",
				v.Network, internalVMNetworkName, externalVMNetworkName)
		}
	}

	existingNetworkNames := toNetworkNames(nonVNICDevices)
	if internalVMNetworkName != "" && externalVMNetworkName != "" {
		if !ArrayContainsCaseInsensitive(existingNetworkNames, internalVMNetworkName) &&
			!ArrayContainsCaseInsensitive(existingNetworkNames, externalVMNetworkName) {
			return fmt.Errorf("unable to find suitable IP address for node")
		}
	}

	ipAddrNetworkNames := toIPAddrNetworkNames(nonVNICDevices)
	nonLocalhostIPs := excludeLocalhostIPs(ipAddrNetworkNames)

	for _, ipFamily := range ipFamilies {
		klog.V(6).Infof("ipFamily: %q nonLocalhostIPs: %q", ipFamily, nonLocalhostIPs)
		discoveredInternal, discoveredExternal := discoverIPs(
			nonLocalhostIPs,
			ipFamily,
			internalNetworkSubnets,
			externalNetworkSubnets,
			excludeInternalNetworkSubnets,
			excludeExternalNetworkSubnets,
			internalVMNetworkName,
			externalVMNetworkName,
		)

		klog.V(6).Infof("ipFamily: %q discovered Internal: %q discoveredExternal: %q",
			ipFamily, discoveredInternal, discoveredExternal)

		if discoveredInternal != nil {
			v1helper.AddToNodeAddresses(&addrs,
				v1.NodeAddress{Type: v1.NodeInternalIP, Address: discoveredInternal.ipAddr},
			)
		}

		if discoveredExternal != nil {
			v1helper.AddToNodeAddresses(&addrs,
				v1.NodeAddress{Type: v1.NodeExternalIP, Address: discoveredExternal.ipAddr},
			)
		}

		if len(oVM.Guest.Net) > 0 {
			if discoveredInternal == nil && discoveredExternal == nil {
				return fmt.Errorf("unable to find suitable IP address for node %s with IP family %s", nodeID, ipFamilies)
			}
		}
	}

	klog.V(2).Infof("Found node %s as vm=%+v in vc=%s and datacenter=%s",
		nodeID, vmDI.VM, vmDI.VcServer, vmDI.DataCenter.Name())
	klog.V(2).Info("Hostname: ", oVM.Guest.HostName, " UUID: ", vmDI.UUID)

	os := "unknown"
	if g, ok := GuestOSLookup[oVM.Summary.Config.GuestId]; ok {
		os = g
	}

	// store instance type in nodeinfo map
	instanceType := fmt.Sprintf("vsphere-vm.cpu-%d.mem-%dgb.os-%s",
		oVM.Summary.Config.NumCpu,
		(oVM.Summary.Config.MemorySizeMB / 1024),
		os,
	)

	nodeInfo := &NodeInfo{tenantRef: tenantRef, dataCenter: vmDI.DataCenter, vm: vmDI.VM, vcServer: vmDI.VcServer,
		UUID: vmDI.UUID, NodeName: vmDI.NodeName, NodeType: instanceType, NodeAddresses: addrs}
	nm.addNodeInfo(nodeInfo)

	return nil
}