acs, api: consume eni private hostname model changes

Author: adnxn

agent/acs/model/api/api-2.json

@@ -206,7 +206,8 @@
         "ipv4Addresses":{"shape":"IPv4AddressList"},
         "ipv6Addresses":{"shape":"IPv6AddressList"},
         "domainName":{"shape":"StringList"},
-        "domainNameServers":{"shape":"StringList"}
+        "domainNameServers":{"shape":"StringList"},
+        "privateDnsName":{"shape":"String"}
       }
     },
     "ElasticNetworkInterfaceList":{

agent/acs/model/ecsacs/api.go

@@ -217,6 +217,8 @@ type ElasticNetworkInterface struct {
 	Ipv6Addresses []*IPv6AddressAssignment `locationName:"ipv6Addresses" type:"list"`
 
 	MacAddress *string `locationName:"macAddress" type:"string"`
+
+	PrivateDnsName *string `locationName:"privateDnsName" type:"string"`
 }
 
 // String returns the string representation

agent/api/eni.go

@@ -38,6 +38,9 @@ type ENI struct {
 	// DomainNameSearchList specifies the search list for the domain
 	// name lookup, for the eni
 	DomainNameSearchList []string `json:",omitempty"`
+
+	// PrivateDnsName is the dns name assigned by the vpc to this eni
+	PrivateDnsName string `json:",omitempty"`
 }
 
 // GetIPV4Addresses returns a list of ipv4 addresses allocated to the ENI
@@ -62,10 +65,7 @@ func (eni *ENI) GetIPV6Addresses() []string {
 
 // GetHostname returns the hostname assigned to the ENI
 func (eni *ENI) GetHostname() string {
-	// WIP
-	// pending acs model change to include hostname
-	// return eni.Hostname
-	return "ip.region.compute.internal"
+	return eni.PrivateDnsName
 }
 
 // String returns a human readable version of the ENI object
@@ -79,8 +79,8 @@ func (eni *ENI) String() string {
 		ipv6Addresses = append(ipv6Addresses, addr.Address)
 	}
 	return fmt.Sprintf(
-		"eni id:%s, mac: %s, ipv4addresses: [%s], ipv6addresses: [%s], dns: [%s], dns search: [%s]",
-		eni.ID, eni.MacAddress, strings.Join(ipv4Addresses, ","), strings.Join(ipv6Addresses, ","),
+		"eni id:%s, mac: %s, hostname: %s, ipv4addresses: [%s], ipv6addresses: [%s], dns: [%s], dns search: [%s]",
+		eni.ID, eni.MacAddress, eni.PrivateDnsName, strings.Join(ipv4Addresses, ","), strings.Join(ipv6Addresses, ","),
 		strings.Join(eni.DomainNameServers, ","), strings.Join(eni.DomainNameSearchList, ","))
 }
 
@@ -124,10 +124,11 @@ func ENIFromACS(acsenis []*ecsacs.ElasticNetworkInterface) (*ENI, error) {
 	}
 
 	eni := &ENI{
-		ID:            aws.StringValue(acsenis[0].Ec2Id),
-		IPV4Addresses: ipv4,
-		IPV6Addresses: ipv6,
-		MacAddress:    aws.StringValue(acsenis[0].MacAddress),
+		ID:             aws.StringValue(acsenis[0].Ec2Id),
+		IPV4Addresses:  ipv4,
+		IPV6Addresses:  ipv6,
+		MacAddress:     aws.StringValue(acsenis[0].MacAddress),
+		PrivateDnsName: aws.StringValue(acsenis[0].PrivateDnsName),
 	}
 	for _, nameserverIP := range acsenis[0].DomainNameServers {
 		eni.DomainNameServers = append(eni.DomainNameServers, aws.StringValue(nameserverIP))

agent/api/eni_test.go

@@ -46,6 +46,7 @@ func TestENIFromACS(t *testing.T) {
 			MacAddress:        aws.String("mac"),
 			DomainNameServers: []*string{aws.String(defaultDNS), aws.String(customDNS)},
 			DomainName:        []*string{aws.String(customSearchDomain)},
+			PrivateDnsName:    aws.String("ip.region.compute.internal"),
 		},
 	}
 
@@ -66,6 +67,7 @@ func TestENIFromACS(t *testing.T) {
 	assert.Equal(t, customDNS, eni.DomainNameServers[1])
 	assert.Len(t, eni.DomainNameSearchList, 1)
 	assert.Equal(t, customSearchDomain, eni.DomainNameSearchList[0])
+	assert.Equal(t, aws.StringValue(acsenis[0].PrivateDnsName), eni.PrivateDnsName)
 }
 
 // TestValidateENIFromACS tests the validation of enis from acs

agent/api/task.go

@@ -474,8 +474,7 @@ func (task *Task) dockerConfig(container *Container, apiVersion dockerclient.Doc
 	}
 
 	if container.Type == ContainerCNIPause {
-		// WIP
-		// hostname to pause container's docker config
+		// apply hostname to pause container's docker config
 		return task.applyENIHostname(config), nil
 	}
 
@@ -632,7 +631,6 @@ func (task *Task) dockerHostConfig(container *Container, dockerContainerMap map[
 	// Override 'awsvpc' parameters if needed
 	if container.Type == ContainerCNIPause {
 
-		// WIP
 		// apply ExtraHosts to HostConfig for pause container
 		if hosts := task.generateENIExtraHosts(); hosts != nil {
 			hostConfig.ExtraHosts = append(hostConfig.ExtraHosts, hosts...)
@@ -741,7 +739,7 @@ func (task *Task) generateENIExtraHosts() []string {
 
 	extraHosts := []string{}
 
-	for _, ip := range eni.GetIPV6Addresses() {
+	for _, ip := range eni.GetIPV4Addresses() {
 		host := fmt.Sprintf("%s:%s", hostname, ip)
 		extraHosts = append(extraHosts, host)
 	}

agent/api/task_test.go

@@ -282,7 +282,19 @@ func TestDockerHostConfigPauseContainer(t *testing.T) {
 	assert.Equal(t, []string{"169.254.169.253"}, config.DNS)
 	assert.Equal(t, []string{"us-west-2.compute.internal"}, config.DNSSearch)
 
-	// Verify ExtraHosts are added for eni IPs
+	// Verify eni ExtraHosts  added to HostConfig for "pause" container
+	ipaddr := &ENIIPV4Address{Primary: true, Address: "10.0.1.1"}
+	testTask.ENI.IPV4Addresses = []*ENIIPV4Address{ipaddr}
+	testTask.ENI.PrivateDnsName = "eni.ip.region.compute.internal"
+
+	config, err = testTask.DockerHostConfig(testTask.Containers[2], dockerMap(testTask), defaultDockerClientAPIVersion)
+	assert.Nil(t, err)
+	assert.Equal(t, []string{"eni.ip.region.compute.internal:10.0.1.1"}, config.ExtraHosts)
+
+	// Verify eni Hostname is added to DockerConfig for "pause" container
+	dockerconfig, dockerConfigErr := testTask.DockerConfig(testTask.Containers[2], defaultDockerClientAPIVersion)
+	assert.Nil(t, dockerConfigErr)
+	assert.Equal(t, "eni.ip.region.compute.internal", dockerconfig.Hostname)
 
 }