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) {