Retrieve ipv4s from linode.Instance instead of calling GetInstanceIPAddresses

We have to manually check whether each IP is public or private, but it
saves us from calling the API once again.

Author: okokes-akamai

cloud/linode/instances.go

@@ -27,32 +27,6 @@ func (e instanceNoIPAddressesError) Error() string {
 	return fmt.Sprintf("instance %d has no IP addresses", e.id)
 }
 
-func (i *instances) nodeAddresses(ctx context.Context, linode *linodego.Instance) ([]v1.NodeAddress, error) {
-	var addresses []v1.NodeAddress
-	addresses = append(addresses, v1.NodeAddress{Type: v1.NodeHostName, Address: linode.Label})
-
-	ips, err := i.client.GetInstanceIPAddresses(ctx, linode.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if (len(ips.IPv4.Public) == 0) && (len(ips.IPv4.Private) == 0) {
-		return nil, instanceNoIPAddressesError{linode.ID}
-	}
-
-	if len(ips.IPv4.Public) > 0 {
-		addresses = append(addresses, v1.NodeAddress{Type: v1.NodeExternalIP, Address: ips.IPv4.Public[0].Address})
-	}
-	// Allow Nodes to not have an ExternalIP, if this proves problematic this will be reverted
-
-	if len(ips.IPv4.Private) > 0 {
-		addresses = append(addresses, v1.NodeAddress{Type: v1.NodeInternalIP, Address: ips.IPv4.Private[0].Address})
-	}
-	// Allow Nodes to not have an InternalIP, if this proves problematic this will be reverted
-
-	return addresses, nil
-}
-
 func (i *instances) lookupLinode(ctx context.Context, node *v1.Node) (*linodego.Instance, error) {
 	providerID := node.Spec.ProviderID
 	nodeName := types.NodeName(node.Name)
@@ -102,9 +76,18 @@ func (i *instances) InstanceMetadata(ctx context.Context, node *v1.Node) (*cloud
 		return nil, err
 	}
 
-	addresses, err := i.nodeAddresses(ctx, linode)
-	if err != nil {
-		return nil, err
+	if len(linode.IPv4) == 0 {
+		return nil, instanceNoIPAddressesError{linode.ID}
+	}
+
+	addresses := []v1.NodeAddress{{Type: v1.NodeHostName, Address: linode.Label}}
+
+	for _, ip := range linode.IPv4 {
+		ipType := v1.NodeExternalIP
+		if ip.IsPrivate() {
+			ipType = v1.NodeInternalIP
+		}
+		addresses = append(addresses, v1.NodeAddress{Type: ipType, Address: ip.String()})
 	}
 
 	// note that Zone is omitted as it's not a thing in Linode

cloud/linode/instances_test.go

@@ -3,6 +3,7 @@ package linode
 import (
 	"context"
 	"errors"
+	"net"
 	"net/http"
 	"strconv"
 	"testing"
@@ -135,12 +136,6 @@ func TestMetadataRetrieval(t *testing.T) {
 		client.EXPECT().ListInstances(gomock.Any(), filter).Times(1).Return([]linodego.Instance{
 			{ID: id, Label: name},
 		}, nil)
-		client.EXPECT().GetInstanceIPAddresses(gomock.Any(), id).Times(1).Return(&linodego.InstanceIPAddressResponse{
-			IPv4: &linodego.InstanceIPv4Response{
-				Public:  []*linodego.InstanceIP{},
-				Private: []*linodego.InstanceIP{},
-			},
-		}, nil)
 
 		meta, err := instances.InstanceMetadata(ctx, node)
 		assert.Error(t, err, instanceNoIPAddressesError{id})
@@ -151,19 +146,13 @@ func TestMetadataRetrieval(t *testing.T) {
 		id := 123
 		name := "mock-instance"
 		node := nodeWithName(name)
-		publicIPv4 := "45.76.101.25"
-		privateIPv4 := "192.168.133.65"
+		publicIPv4 := net.ParseIP("45.76.101.25")
+		privateIPv4 := net.ParseIP("192.168.133.65")
 		linodeType := "g6-standard-1"
 		region := "us-east"
 		filter := linodeFilterListOptions(name)
 		client.EXPECT().ListInstances(gomock.Any(), filter).Times(1).Return([]linodego.Instance{
-			{ID: id, Label: name, Type: linodeType, Region: region},
-		}, nil)
-		client.EXPECT().GetInstanceIPAddresses(gomock.Any(), id).Times(1).Return(&linodego.InstanceIPAddressResponse{
-			IPv4: &linodego.InstanceIPv4Response{
-				Public:  []*linodego.InstanceIP{{Address: publicIPv4}},
-				Private: []*linodego.InstanceIP{{Address: privateIPv4}},
-			},
+			{ID: id, Label: name, Type: linodeType, Region: region, IPv4: []*net.IP{&publicIPv4, &privateIPv4}},
 		}, nil)
 
 		meta, err := instances.InstanceMetadata(ctx, node)
@@ -177,11 +166,11 @@ func TestMetadataRetrieval(t *testing.T) {
 			},
 			{
 				Type:    v1.NodeExternalIP,
-				Address: publicIPv4,
+				Address: publicIPv4.String(),
 			},
 			{
 				Type:    v1.NodeInternalIP,
-				Address: privateIPv4,
+				Address: privateIPv4.String(),
 			},
 		})
 	})
@@ -191,18 +180,12 @@ func TestMetadataRetrieval(t *testing.T) {
 		name := "my-instance"
 		providerID := providerIDPrefix + strconv.Itoa(id)
 		node := nodeWithProviderID(providerID)
-		publicIPv4 := "32.74.121.25"
-		privateIPv4 := "192.168.121.42"
+		publicIPv4 := net.ParseIP("32.74.121.25")
+		privateIPv4 := net.ParseIP("192.168.121.42")
 		linodeType := "g6-standard-1"
 		region := "us-east"
 		client.EXPECT().GetInstance(gomock.Any(), id).Times(1).Return(&linodego.Instance{
-			ID: id, Label: name, Type: linodeType, Region: region,
-		}, nil)
-		client.EXPECT().GetInstanceIPAddresses(gomock.Any(), id).Times(1).Return(&linodego.InstanceIPAddressResponse{
-			IPv4: &linodego.InstanceIPv4Response{
-				Public:  []*linodego.InstanceIP{{Address: publicIPv4}},
-				Private: []*linodego.InstanceIP{{Address: privateIPv4}},
-			},
+			ID: id, Label: name, Type: linodeType, Region: region, IPv4: []*net.IP{&publicIPv4, &privateIPv4},
 		}, nil)
 
 		meta, err := instances.InstanceMetadata(ctx, node)
@@ -217,11 +200,11 @@ func TestMetadataRetrieval(t *testing.T) {
 			},
 			{
 				Type:    v1.NodeExternalIP,
-				Address: publicIPv4,
+				Address: publicIPv4.String(),
 			},
 			{
 				Type:    v1.NodeInternalIP,
-				Address: privateIPv4,
+				Address: privateIPv4.String(),
 			},
 		})
 	})