Make the AWS provider target the metadata server for local data lookup

pkg/cloudprovider/providers/aws/aws.go

@@ -624,6 +624,24 @@ func (aws *AWSCloud) Routes() (cloudprovider.Routes, bool) {
 
 // NodeAddresses is an implementation of Instances.NodeAddresses.
 func (aws *AWSCloud) NodeAddresses(name string) ([]api.NodeAddress, error) {
+	self, err := aws.getSelfAWSInstance()
+	if err != nil {
+		return nil, err
+	}
+	if self.nodeName == name || len(name) == 0 {
+		internalIP, err := aws.metadata.GetMetadata("local-ipv4")
+		if err != nil {
+			return nil, err
+		}
+		externalIP, err := aws.metadata.GetMetadata("public-ipv4")
+		if err != nil {
+			return nil, err
+		}
+		return []api.NodeAddress{
+			{Type: api.NodeInternalIP, Address: internalIP},
+			{Type: api.NodeExternalIP, Address: externalIP},
+		}, nil
+	}
 	instance, err := aws.getInstanceByNodeName(name)
 	if err != nil {
 		return nil, err

pkg/cloudprovider/providers/aws/aws_test.go

@@ -111,6 +111,8 @@ type FakeAWSServices struct {
 	privateDnsName          string
 	networkInterfacesMacs   []string
 	networkInterfacesVpcIDs []string
+	internalIP              string
+	externalIP              string
 
 	ec2      *FakeEC2
 	elb      *FakeELB
@@ -323,6 +325,10 @@ func (self *FakeMetadata) GetMetadata(key string) (string, error) {
 		return self.aws.instanceId, nil
 	} else if key == "local-hostname" {
 		return self.aws.privateDnsName, nil
+	} else if key == "local-ipv4" {
+		return self.aws.internalIP, nil
+	} else if key == "public-ipv4" {
+		return self.aws.externalIP, nil
 	} else if strings.HasPrefix(key, networkInterfacesPrefix) {
 		if key == networkInterfacesPrefix {
 			return strings.Join(self.aws.networkInterfacesMacs, "/\n") + "/\n", nil
@@ -467,12 +473,13 @@ func (a *FakeASG) DescribeAutoScalingGroups(*autoscaling.DescribeAutoScalingGrou
 	panic("Not implemented")
 }
 
-func mockInstancesResp(instances []*ec2.Instance) *AWSCloud {
+func mockInstancesResp(instances []*ec2.Instance) (*AWSCloud, *FakeAWSServices) {
 	awsServices := NewFakeAWSServices().withInstances(instances)
 	return &AWSCloud{
 		ec2:              awsServices.ec2,
 		availabilityZone: awsServices.availabilityZone,
-	}
+		metadata:         &FakeMetadata{aws: awsServices},
+	}, awsServices
 }
 
 func mockAvailabilityZone(region string, availabilityZone string) *AWSCloud {
@@ -544,7 +551,7 @@ func TestList(t *testing.T) {
 	instance3.State = &state3
 
 	instances := []*ec2.Instance{&instance0, &instance1, &instance2, &instance3}
-	aws := mockInstancesResp(instances)
+	aws, _ := mockInstancesResp(instances)
 
 	table := []struct {
 		input  string
@@ -604,19 +611,19 @@ func TestNodeAddresses(t *testing.T) {
 
 	instances := []*ec2.Instance{&instance0, &instance1}
 
-	aws1 := mockInstancesResp([]*ec2.Instance{})
+	aws1, _ := mockInstancesResp([]*ec2.Instance{})
 	_, err1 := aws1.NodeAddresses("instance-mismatch.ec2.internal")
 	if err1 == nil {
 		t.Errorf("Should error when no instance found")
 	}
 
-	aws2 := mockInstancesResp(instances)
+	aws2, _ := mockInstancesResp(instances)
 	_, err2 := aws2.NodeAddresses("instance-same.ec2.internal")
 	if err2 == nil {
 		t.Errorf("Should error when multiple instances found")
 	}
 
-	aws3 := mockInstancesResp(instances[0:1])
+	aws3, _ := mockInstancesResp(instances[0:1])
 	addrs3, err3 := aws3.NodeAddresses("instance-same.ec2.internal")
 	if err3 != nil {
 		t.Errorf("Should not error when instance found")
@@ -627,6 +634,18 @@ func TestNodeAddresses(t *testing.T) {
 	testHasNodeAddress(t, addrs3, api.NodeInternalIP, "192.168.0.1")
 	testHasNodeAddress(t, addrs3, api.NodeLegacyHostIP, "192.168.0.1")
 	testHasNodeAddress(t, addrs3, api.NodeExternalIP, "1.2.3.4")
+
+	aws4, fakeServices := mockInstancesResp([]*ec2.Instance{})
+	fakeServices.externalIP = "2.3.4.5"
+	fakeServices.internalIP = "192.168.0.2"
+	aws4.selfAWSInstance = &awsInstance{nodeName: fakeServices.instanceId}
+
+	addrs4, err4 := aws4.NodeAddresses(fakeServices.instanceId)
+	if err4 != nil {
+		t.Errorf("unexpected error: %v", err4)
+	}
+	testHasNodeAddress(t, addrs4, api.NodeInternalIP, "192.168.0.2")
+	testHasNodeAddress(t, addrs4, api.NodeExternalIP, "2.3.4.5")
 }
 
 func TestGetRegion(t *testing.T) {