func()

in providers/gce/gce_instances.go [91:200]
88 lines of code
22 McCabe index (conditional complexity)

func (g *Cloud) NodeAddresses(ctx context.Context, nodeName types.NodeName) ([]v1.NodeAddress, error) {
	timeoutCtx, cancel := context.WithTimeout(ctx, 1*time.Hour)
	defer cancel()

	instanceName := string(nodeName)

	if g.useMetadataServer {
		// Use metadata server if possible
		if g.isCurrentInstance(instanceName) {

			nics, err := metadata.Get("instance/network-interfaces/")
			if err != nil {
				return nil, fmt.Errorf("couldn't get network interfaces: %v", err)
			}

			nicsArr := strings.Split(nics, "/\n")
			nodeAddresses := []v1.NodeAddress{}

			for _, nic := range nicsArr {

				if nic == "" {
					continue
				}

				internalIP, err := metadata.Get(fmt.Sprintf(networkInterfaceIP, nic))
				if err != nil {
					return nil, fmt.Errorf("couldn't get internal IP: %v", err)
				}
				nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeInternalIP, Address: internalIP})

				if g.stackType == NetworkStackDualStack {
					// Both internal and external IPv6 addresses are written to this array
					ipv6s, err := metadata.Get(fmt.Sprintf(networkInterfaceIPV6, nic))
					if err != nil {
						return nil, fmt.Errorf("couldn't get internal IPV6 addresses for node %v: %v", nodeName, err)
					}
					ipv6Arr := strings.Split(ipv6s, "/\n")
					var internalIPV6 string
					for _, ip := range ipv6Arr {
						if ip == "" {
							continue
						}
						internalIPV6 = ip
						break
					}
					if internalIPV6 != "" {
						nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeInternalIP, Address: internalIPV6})
					} else {
						klog.Warningf("internal IPV6 range is empty for node %v", nodeName)
					}
				}
				acs, err := metadata.Get(fmt.Sprintf(networkInterfaceAccessConfigs, nic))
				if err != nil {
					return nil, fmt.Errorf("couldn't get access configs: %v", err)
				}

				acsArr := strings.Split(acs, "/\n")

				for _, ac := range acsArr {

					if ac == "" {
						continue
					}

					externalIP, err := metadata.Get(fmt.Sprintf(networkInterfaceExternalIP, nic, ac))
					if err != nil {
						return nil, fmt.Errorf("couldn't get external IP: %v", err)
					}

					if externalIP != "" {
						nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeExternalIP, Address: externalIP})
					}
				}
			}

			internalDNSFull, err := metadata.Get("instance/hostname")
			if err != nil {
				klog.Warningf("couldn't get full internal DNS name: %v", err)
			} else {
				nodeAddresses = append(nodeAddresses,
					v1.NodeAddress{Type: v1.NodeInternalDNS, Address: internalDNSFull},
					v1.NodeAddress{Type: v1.NodeHostName, Address: internalDNSFull},
				)
			}
			return nodeAddresses, nil
		}
	}

	// Use GCE API
	instanceObj, err := g.getInstanceByName(instanceName)
	if err != nil {
		return nil, fmt.Errorf("couldn't get instance details: %v", err)
	}

	if g.stackType == NetworkStackDualStack {
		instance, err := g.c.Instances().Get(timeoutCtx, meta.ZonalKey(canonicalizeInstanceName(instanceObj.Name), instanceObj.Zone))
		if err != nil {
			return nil, fmt.Errorf("error while querying for instance: %v", err)
		}

		return g.nodeAddressesFromInstance(instance)
	}

	instance, err := g.c.Instances().Get(timeoutCtx, meta.ZonalKey(canonicalizeInstanceName(instanceObj.Name), instanceObj.Zone))
	if err != nil {
		return nil, fmt.Errorf("error while querying for instance: %v", err)
	}

	return g.nodeAddressesFromInstance(instance)
}