Migrate source to aws-sdk-go v0.9.9.

pkg/cloudprovider/providers/aws/aws.go

@@ -33,6 +33,7 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
 	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/aws/aws-sdk-go/service/elb"
@@ -89,7 +90,7 @@ type EC2 interface {
 	AuthorizeSecurityGroupIngress(*ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error)
 	RevokeSecurityGroupIngress(*ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error)
 
-	DescribeVPCs(*ec2.DescribeVPCsInput) ([]*ec2.VPC, error)
+	DescribeVPCs(*ec2.DescribeVpcsInput) ([]*ec2.Vpc, error)
 
 	DescribeSubnets(*ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error)
 
@@ -208,7 +209,7 @@ type awsSDKProvider struct {
 func (p *awsSDKProvider) Compute(regionName string) (EC2, error) {
 	ec2 := &awsSdkEC2{
 		ec2: ec2.New(&aws.Config{
-			Region:      regionName,
+			Region:      &regionName,
 			Credentials: p.creds,
 		}),
 	}
@@ -217,7 +218,7 @@ func (p *awsSDKProvider) Compute(regionName string) (EC2, error) {
 
 func (p *awsSDKProvider) LoadBalancing(regionName string) (ELB, error) {
 	elbClient := elb.New(&aws.Config{
-		Region:      regionName,
+		Region:      &regionName,
 		Credentials: p.creds,
 	})
 	return elbClient, nil
@@ -225,7 +226,7 @@ func (p *awsSDKProvider) LoadBalancing(regionName string) (ELB, error) {
 
 func (p *awsSDKProvider) Autoscaling(regionName string) (ASG, error) {
 	client := autoscaling.New(&aws.Config{
-		Region:      regionName,
+		Region:      &regionName,
 		Credentials: p.creds,
 	})
 	return client, nil
@@ -349,8 +350,8 @@ func (s *awsSdkEC2) DescribeSecurityGroups(request *ec2.DescribeSecurityGroupsIn
 func (s *awsSdkEC2) AttachVolume(volumeID, instanceId, device string) (resp *ec2.VolumeAttachment, err error) {
 	request := ec2.AttachVolumeInput{
 		Device:     &device,
-		InstanceID: &instanceId,
-		VolumeID:   &volumeID,
+		InstanceId: &instanceId,
+		VolumeId:   &volumeID,
 	}
 	return s.ec2.AttachVolume(&request)
 }
@@ -388,17 +389,17 @@ func (s *awsSdkEC2) CreateVolume(request *ec2.CreateVolumeInput) (resp *ec2.Volu
 }
 
 func (s *awsSdkEC2) DeleteVolume(volumeID string) (resp *ec2.DeleteVolumeOutput, err error) {
-	request := ec2.DeleteVolumeInput{VolumeID: &volumeID}
+	request := ec2.DeleteVolumeInput{VolumeId: &volumeID}
 	return s.ec2.DeleteVolume(&request)
 }
 
-func (s *awsSdkEC2) DescribeVPCs(request *ec2.DescribeVPCsInput) ([]*ec2.VPC, error) {
+func (s *awsSdkEC2) DescribeVPCs(request *ec2.DescribeVpcsInput) ([]*ec2.Vpc, error) {
 	// VPCs are not paged
-	response, err := s.ec2.DescribeVPCs(request)
+	response, err := s.ec2.DescribeVpcs(request)
 	if err != nil {
 		return nil, fmt.Errorf("error listing AWS VPCs: %v", err)
 	}
-	return response.VPCs, nil
+	return response.Vpcs, nil
 }
 
 func (s *awsSdkEC2) DescribeSubnets(request *ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error) {
@@ -456,7 +457,7 @@ func init() {
 		creds := credentials.NewChainCredentials(
 			[]credentials.Provider{
 				&credentials.EnvProvider{},
-				&credentials.EC2RoleProvider{},
+				&ec2rolecreds.EC2RoleProvider{},
 				&credentials.SharedCredentialsProvider{},
 			})
 		aws := &awsSDKProvider{creds: creds}
@@ -635,11 +636,11 @@ func (aws *AWSCloud) NodeAddresses(name string) ([]api.NodeAddress, error) {
 
 	addresses := []api.NodeAddress{}
 
-	if !isNilOrEmpty(instance.PrivateIPAddress) {
-		ipAddress := *instance.PrivateIPAddress
+	if !isNilOrEmpty(instance.PrivateIpAddress) {
+		ipAddress := *instance.PrivateIpAddress
 		ip := net.ParseIP(ipAddress)
 		if ip == nil {
-			return nil, fmt.Errorf("EC2 instance had invalid private address: %s (%s)", orEmpty(instance.InstanceID), ipAddress)
+			return nil, fmt.Errorf("EC2 instance had invalid private address: %s (%s)", orEmpty(instance.InstanceId), ipAddress)
 		}
 		addresses = append(addresses, api.NodeAddress{Type: api.NodeInternalIP, Address: ip.String()})
 
@@ -648,11 +649,11 @@ func (aws *AWSCloud) NodeAddresses(name string) ([]api.NodeAddress, error) {
 	}
 
 	// TODO: Other IP addresses (multiple ips)?
-	if !isNilOrEmpty(instance.PublicIPAddress) {
-		ipAddress := *instance.PublicIPAddress
+	if !isNilOrEmpty(instance.PublicIpAddress) {
+		ipAddress := *instance.PublicIpAddress
 		ip := net.ParseIP(ipAddress)
 		if ip == nil {
-			return nil, fmt.Errorf("EC2 instance had invalid public address: %s (%s)", orEmpty(instance.InstanceID), ipAddress)
+			return nil, fmt.Errorf("EC2 instance had invalid public address: %s (%s)", orEmpty(instance.InstanceId), ipAddress)
 		}
 		addresses = append(addresses, api.NodeAddress{Type: api.NodeExternalIP, Address: ip.String()})
 	}
@@ -671,7 +672,7 @@ func (aws *AWSCloud) ExternalID(name string) (string, error) {
 	if instance == nil || !isAlive(instance) {
 		return "", cloudprovider.InstanceNotFound
 	}
-	return orEmpty(instance.InstanceID), nil
+	return orEmpty(instance.InstanceId), nil
 }
 
 // InstanceID returns the cloud provider ID of the specified instance.
@@ -683,7 +684,7 @@ func (aws *AWSCloud) InstanceID(name string) (string, error) {
 	}
 	// In the future it is possible to also return an endpoint as:
 	// <endpoint>/<zone>/<instanceid>
-	return "/" + orEmpty(inst.Placement.AvailabilityZone) + "/" + orEmpty(inst.InstanceID), nil
+	return "/" + orEmpty(inst.Placement.AvailabilityZone) + "/" + orEmpty(inst.InstanceId), nil
 }
 
 // Check if the instance is alive (running or pending)
@@ -741,14 +742,14 @@ func (s *AWSCloud) getInstancesByRegex(regex string) ([]string, error) {
 		// Only return fully-ready instances when listing instances
 		// (vs a query by name, where we will return it if we find it)
 		if orEmpty(instance.State.Name) == "pending" {
-			glog.V(2).Infof("skipping EC2 instance (pending): %s", *instance.InstanceID)
+			glog.V(2).Infof("skipping EC2 instance (pending): %s", *instance.InstanceId)
 			continue
 		}
 
-		privateDNSName := orEmpty(instance.PrivateDNSName)
+		privateDNSName := orEmpty(instance.PrivateDnsName)
 		if privateDNSName == "" {
 			glog.V(2).Infof("skipping EC2 instance (no PrivateDNSName): %s",
-				orEmpty(instance.InstanceID))
+				orEmpty(instance.InstanceId))
 			continue
 		}
 
@@ -832,7 +833,7 @@ func (self *awsInstance) getInstanceType() *awsInstanceType {
 func (self *awsInstance) getInfo() (*ec2.Instance, error) {
 	instanceID := self.awsID
 	request := &ec2.DescribeInstancesInput{
-		InstanceIDs: []*string{&instanceID},
+		InstanceIds: []*string{&instanceID},
 	}
 
 	instances, err := self.ec2.DescribeInstances(request)
@@ -877,7 +878,7 @@ func (self *awsInstance) assignMountpoint(volumeID string) (mountpoint string, a
 			if strings.HasPrefix(mountpoint, "/dev/xvd") {
 				mountpoint = mountpoint[8:]
 			}
-			deviceMappings[mountpoint] = orEmpty(blockDevice.EBS.VolumeID)
+			deviceMappings[mountpoint] = orEmpty(blockDevice.Ebs.VolumeId)
 		}
 		self.deviceMappings = deviceMappings
 	}
@@ -979,7 +980,7 @@ func (self *awsDisk) getInfo() (*ec2.Volume, error) {
 	volumeID := self.awsID
 
 	request := &ec2.DescribeVolumesInput{
-		VolumeIDs: []*string{&volumeID},
+		VolumeIds: []*string{&volumeID},
 	}
 
 	volumes, err := self.ec2.DescribeVolumes(request)
@@ -1090,7 +1091,7 @@ func (aws *AWSCloud) getAwsInstance(nodeName string) (*awsInstance, error) {
 			return nil, fmt.Errorf("error finding instance %s: %v", nodeName, err)
 		}
 
-		awsInstance = newAWSInstance(aws.ec2, orEmpty(instance.InstanceID), orEmpty(instance.PrivateDNSName))
+		awsInstance = newAWSInstance(aws.ec2, orEmpty(instance.InstanceId), orEmpty(instance.PrivateDnsName))
 	}
 
 	return awsInstance, nil
@@ -1168,8 +1169,8 @@ func (aws *AWSCloud) DetachDisk(instanceName string, diskName string) error {
 	}
 
 	request := ec2.DetachVolumeInput{
-		InstanceID: &awsInstance.awsID,
-		VolumeID:   &disk.awsID,
+		InstanceId: &awsInstance.awsID,
+		VolumeId:   &disk.awsID,
 	}
 
 	response, err := aws.ec2.DetachVolume(&request)
@@ -1202,7 +1203,7 @@ func (aws *AWSCloud) CreateVolume(volumeOptions *VolumeOptions) (string, error)
 	}
 
 	az := orEmpty(response.AvailabilityZone)
-	awsID := orEmpty(response.VolumeID)
+	awsID := orEmpty(response.VolumeId)
 
 	volumeName := "aws://" + az + "/" + awsID
 
@@ -1277,8 +1278,8 @@ func (self *AWSCloud) findVPCID() (string, error) {
 }
 
 // Find the VPC which self is attached to.
-func (self *AWSCloud) findVPC() (*ec2.VPC, error) {
-	request := &ec2.DescribeVPCsInput{}
+func (self *AWSCloud) findVPC() (*ec2.Vpc, error) {
+	request := &ec2.DescribeVpcsInput{}
 
 	// find by vpcID from metadata
 	vpcID, err := self.findVPCID()
@@ -1308,7 +1309,7 @@ func (self *AWSCloud) findVPC() (*ec2.VPC, error) {
 // Retrieves the specified security group from the AWS API, or returns nil if not found
 func (s *AWSCloud) findSecurityGroup(securityGroupId string) (*ec2.SecurityGroup, error) {
 	describeSecurityGroupsRequest := &ec2.DescribeSecurityGroupsInput{
-		GroupIDs: []*string{&securityGroupId},
+		GroupIds: []*string{&securityGroupId},
 	}
 
 	groups, err := s.ec2.DescribeSecurityGroups(describeSecurityGroupsRequest)
@@ -1347,34 +1348,34 @@ func isEqualStringPointer(l, r *string) bool {
 	return *l == *r
 }
 
-func isEqualIPPermission(l, r *ec2.IPPermission, compareGroupUserIDs bool) bool {
+func isEqualIPPermission(l, r *ec2.IpPermission, compareGroupUserIDs bool) bool {
 	if !isEqualIntPointer(l.FromPort, r.FromPort) {
 		return false
 	}
 	if !isEqualIntPointer(l.ToPort, r.ToPort) {
 		return false
 	}
-	if !isEqualStringPointer(l.IPProtocol, r.IPProtocol) {
+	if !isEqualStringPointer(l.IpProtocol, r.IpProtocol) {
 		return false
 	}
-	if len(l.IPRanges) != len(r.IPRanges) {
+	if len(l.IpRanges) != len(r.IpRanges) {
 		return false
 	}
-	for j := range l.IPRanges {
-		if !isEqualStringPointer(l.IPRanges[j].CIDRIP, r.IPRanges[j].CIDRIP) {
+	for j := range l.IpRanges {
+		if !isEqualStringPointer(l.IpRanges[j].CidrIp, r.IpRanges[j].CidrIp) {
 			return false
 		}
 	}
 
-	if len(l.UserIDGroupPairs) != len(r.UserIDGroupPairs) {
+	if len(l.UserIdGroupPairs) != len(r.UserIdGroupPairs) {
 		return false
 	}
-	for j := range l.UserIDGroupPairs {
-		if !isEqualStringPointer(l.UserIDGroupPairs[j].GroupID, r.UserIDGroupPairs[j].GroupID) {
+	for j := range l.UserIdGroupPairs {
+		if !isEqualStringPointer(l.UserIdGroupPairs[j].GroupId, r.UserIdGroupPairs[j].GroupId) {
 			return false
 		}
 		if compareGroupUserIDs {
-			if !isEqualStringPointer(l.UserIDGroupPairs[j].UserID, r.UserIDGroupPairs[j].UserID) {
+			if !isEqualStringPointer(l.UserIdGroupPairs[j].UserId, r.UserIdGroupPairs[j].UserId) {
 				return false
 			}
 		}
@@ -1386,7 +1387,7 @@ func isEqualIPPermission(l, r *ec2.IPPermission, compareGroupUserIDs bool) bool
 // Makes sure the security group includes the specified permissions
 // Returns true if and only if changes were made
 // The security group must already exist
-func (s *AWSCloud) ensureSecurityGroupIngress(securityGroupId string, addPermissions []*ec2.IPPermission) (bool, error) {
+func (s *AWSCloud) ensureSecurityGroupIngress(securityGroupId string, addPermissions []*ec2.IpPermission) (bool, error) {
 	group, err := s.findSecurityGroup(securityGroupId)
 	if err != nil {
 		glog.Warning("error retrieving security group", err)
@@ -1397,17 +1398,17 @@ func (s *AWSCloud) ensureSecurityGroupIngress(securityGroupId string, addPermiss
 		return false, fmt.Errorf("security group not found: %s", securityGroupId)
 	}
 
-	changes := []*ec2.IPPermission{}
+	changes := []*ec2.IpPermission{}
 	for _, addPermission := range addPermissions {
 		hasUserID := false
-		for i := range addPermission.UserIDGroupPairs {
-			if addPermission.UserIDGroupPairs[i].UserID != nil {
+		for i := range addPermission.UserIdGroupPairs {
+			if addPermission.UserIdGroupPairs[i].UserId != nil {
 				hasUserID = true
 			}
 		}
 
 		found := false
-		for _, groupPermission := range group.IPPermissions {
+		for _, groupPermission := range group.IpPermissions {
 			if isEqualIPPermission(addPermission, groupPermission, hasUserID) {
 				found = true
 				break
@@ -1426,8 +1427,8 @@ func (s *AWSCloud) ensureSecurityGroupIngress(securityGroupId string, addPermiss
 	glog.V(2).Infof("Adding security group ingress: %s %v", securityGroupId, changes)
 
 	request := &ec2.AuthorizeSecurityGroupIngressInput{}
-	request.GroupID = &securityGroupId
-	request.IPPermissions = changes
+	request.GroupId = &securityGroupId
+	request.IpPermissions = changes
 	_, err = s.ec2.AuthorizeSecurityGroupIngress(request)
 	if err != nil {
 		glog.Warning("error authorizing security group ingress", err)
@@ -1440,7 +1441,7 @@ func (s *AWSCloud) ensureSecurityGroupIngress(securityGroupId string, addPermiss
 // Makes sure the security group no longer includes the specified permissions
 // Returns true if and only if changes were made
 // If the security group no longer exists, will return (false, nil)
-func (s *AWSCloud) removeSecurityGroupIngress(securityGroupId string, removePermissions []*ec2.IPPermission) (bool, error) {
+func (s *AWSCloud) removeSecurityGroupIngress(securityGroupId string, removePermissions []*ec2.IpPermission) (bool, error) {
 	group, err := s.findSecurityGroup(securityGroupId)
 	if err != nil {
 		glog.Warning("error retrieving security group", err)
@@ -1452,17 +1453,17 @@ func (s *AWSCloud) removeSecurityGroupIngress(securityGroupId string, removePerm
 		return false, nil
 	}
 
-	changes := []*ec2.IPPermission{}
+	changes := []*ec2.IpPermission{}
 	for _, removePermission := range removePermissions {
 		hasUserID := false
-		for i := range removePermission.UserIDGroupPairs {
-			if removePermission.UserIDGroupPairs[i].UserID != nil {
+		for i := range removePermission.UserIdGroupPairs {
+			if removePermission.UserIdGroupPairs[i].UserId != nil {
 				hasUserID = true
 			}
 		}
 
-		var found *ec2.IPPermission
-		for _, groupPermission := range group.IPPermissions {
+		var found *ec2.IpPermission
+		for _, groupPermission := range group.IpPermissions {
 			if isEqualIPPermission(groupPermission, removePermission, hasUserID) {
 				found = groupPermission
 				break
@@ -1481,8 +1482,8 @@ func (s *AWSCloud) removeSecurityGroupIngress(securityGroupId string, removePerm
 	glog.V(2).Infof("Removing security group ingress: %s %v", securityGroupId, changes)
 
 	request := &ec2.RevokeSecurityGroupIngressInput{}
-	request.GroupID = &securityGroupId
-	request.IPPermissions = changes
+	request.GroupId = &securityGroupId
+	request.IpPermissions = changes
 	_, err = s.ec2.RevokeSecurityGroupIngress(request)
 	if err != nil {
 		glog.Warning("error revoking security group ingress", err)
@@ -1516,11 +1517,11 @@ func (s *AWSCloud) ensureSecurityGroup(name string, description string, vpcID st
 			if len(securityGroups) > 1 {
 				glog.Warning("Found multiple security groups with name:", name)
 			}
-			return orEmpty(securityGroups[0].GroupID), nil
+			return orEmpty(securityGroups[0].GroupId), nil
 		}
 
 		createRequest := &ec2.CreateSecurityGroupInput{}
-		createRequest.VPCID = &vpcID
+		createRequest.VpcId = &vpcID
 		createRequest.GroupName = &name
 		createRequest.Description = &description
 
@@ -1540,7 +1541,7 @@ func (s *AWSCloud) ensureSecurityGroup(name string, description string, vpcID st
 			}
 			time.Sleep(1 * time.Second)
 		} else {
-			groupID = orEmpty(createResponse.GroupID)
+			groupID = orEmpty(createResponse.GroupId)
 			break
 		}
 	}
@@ -1629,7 +1630,7 @@ func (s *AWSCloud) EnsureTCPLoadBalancer(name, region string, publicIP net.IP, p
 	{
 		request := &ec2.DescribeSubnetsInput{}
 		filters := []*ec2.Filter{}
-		filters = append(filters, newEc2Filter("vpc-id", orEmpty(vpc.VPCID)))
+		filters = append(filters, newEc2Filter("vpc-id", orEmpty(vpc.VpcId)))
 		// Note, this will only return subnets tagged with the cluster identifier for this Kubernetes cluster.
 		// In the case where an AZ has public & private subnets per AWS best practices, the deployment should ensure
 		// only the public subnet (where the ELB will go) is so tagged.
@@ -1644,7 +1645,7 @@ func (s *AWSCloud) EnsureTCPLoadBalancer(name, region string, publicIP net.IP, p
 
 		//	zones := []string{}
 		for _, subnet := range subnets {
-			subnetIDs = append(subnetIDs, orEmpty(subnet.SubnetID))
+			subnetIDs = append(subnetIDs, orEmpty(subnet.SubnetId))
 			if !strings.HasPrefix(orEmpty(subnet.AvailabilityZone), region) {
 				glog.Error("found AZ that did not match region", orEmpty(subnet.AvailabilityZone), " vs ", region)
 				return nil, fmt.Errorf("invalid AZ for region")
@@ -1658,23 +1659,23 @@ func (s *AWSCloud) EnsureTCPLoadBalancer(name, region string, publicIP net.IP, p
 	{
 		sgName := "k8s-elb-" + name
 		sgDescription := "Security group for Kubernetes ELB " + name
-		securityGroupID, err = s.ensureSecurityGroup(sgName, sgDescription, orEmpty(vpc.VPCID))
+		securityGroupID, err = s.ensureSecurityGroup(sgName, sgDescription, orEmpty(vpc.VpcId))
 		if err != nil {
 			glog.Error("error creating load balancer security group: ", err)
 			return nil, err
 		}
 
-		permissions := []*ec2.IPPermission{}
+		permissions := []*ec2.IpPermission{}
 		for _, port := range ports {
 			portInt64 := int64(port.Port)
 			protocol := strings.ToLower(string(port.Protocol))
 			sourceIp := "0.0.0.0/0"
 
-			permission := &ec2.IPPermission{}
+			permission := &ec2.IpPermission{}
 			permission.FromPort = &portInt64
 			permission.ToPort = &portInt64
-			permission.IPRanges = []*ec2.IPRange{{CIDRIP: &sourceIp}}
-			permission.IPProtocol = &protocol
+			permission.IpRanges = []*ec2.IpRange{{CidrIp: &sourceIp}}
+			permission.IpProtocol = &protocol
 
 			permissions = append(permissions, permission)
 		}
@@ -1772,23 +1773,23 @@ func toStatus(lb *elb.LoadBalancerDescription) *api.LoadBalancerStatus {
 func findSecurityGroupForInstance(instance *ec2.Instance) *string {
 	var securityGroupId *string
 	for _, securityGroup := range instance.SecurityGroups {
-		if securityGroup == nil || securityGroup.GroupID == nil {
+		if securityGroup == nil || securityGroup.GroupId == nil {
 			// Not expected, but avoid panic
-			glog.Warning("Unexpected empty security group for instance: ", orEmpty(instance.InstanceID))
+			glog.Warning("Unexpected empty security group for instance: ", orEmpty(instance.InstanceId))
 			continue
 		}
 
 		if securityGroupId != nil {
 			// We create instances with one SG
-			glog.Warningf("Multiple security groups found for instance (%s); will use first group (%s)", orEmpty(instance.InstanceID), *securityGroupId)
+			glog.Warningf("Multiple security groups found for instance (%s); will use first group (%s)", orEmpty(instance.InstanceId), *securityGroupId)
 			continue
 		} else {
-			securityGroupId = securityGroup.GroupID
+			securityGroupId = securityGroup.GroupId
 		}
 	}
 
 	if securityGroupId == nil {
-		glog.Warning("No security group found for instance ", orEmpty(instance.InstanceID))
+		glog.Warning("No security group found for instance ", orEmpty(instance.InstanceId))
 	}
 
 	return securityGroupId
@@ -1835,7 +1836,7 @@ func (s *AWSCloud) updateInstanceSecurityGroupsForLoadBalancer(lb *elb.LoadBalan
 	for _, instance := range allInstances {
 		securityGroupId := findSecurityGroupForInstance(instance)
 		if isNilOrEmpty(securityGroupId) {
-			glog.Warning("ignoring instance without security group: ", orEmpty(instance.InstanceID))
+			glog.Warning("ignoring instance without security group: ", orEmpty(instance.InstanceId))
 			continue
 		}
 
@@ -1844,12 +1845,12 @@ func (s *AWSCloud) updateInstanceSecurityGroupsForLoadBalancer(lb *elb.LoadBalan
 
 	// Compare to actual groups
 	for _, actualGroup := range actualGroups {
-		if isNilOrEmpty(actualGroup.GroupID) {
+		if isNilOrEmpty(actualGroup.GroupId) {
 			glog.Warning("ignoring group without ID: ", actualGroup)
 			continue
 		}
 
-		actualGroupID := *actualGroup.GroupID
+		actualGroupID := *actualGroup.GroupId
 
 		adding, found := instanceSecurityGroupIds[actualGroupID]
 		if found && adding {
@@ -1867,16 +1868,16 @@ func (s *AWSCloud) updateInstanceSecurityGroupsForLoadBalancer(lb *elb.LoadBalan
 		} else {
 			glog.V(2).Infof("Removing rule for traffic from the load balancer (%s) to instance (%s)", loadBalancerSecurityGroupId, instanceSecurityGroupId)
 		}
-		sourceGroupId := &ec2.UserIDGroupPair{}
-		sourceGroupId.GroupID = &loadBalancerSecurityGroupId
+		sourceGroupId := &ec2.UserIdGroupPair{}
+		sourceGroupId.GroupId = &loadBalancerSecurityGroupId
 
 		allProtocols := "-1"
 
-		permission := &ec2.IPPermission{}
-		permission.IPProtocol = &allProtocols
-		permission.UserIDGroupPairs = []*ec2.UserIDGroupPair{sourceGroupId}
+		permission := &ec2.IpPermission{}
+		permission.IpProtocol = &allProtocols
+		permission.UserIdGroupPairs = []*ec2.UserIdGroupPair{sourceGroupId}
 
-		permissions := []*ec2.IPPermission{permission}
+		permissions := []*ec2.IpPermission{permission}
 
 		if add {
 			changed, err := s.ensureSecurityGroupIngress(instanceSecurityGroupId, permissions)
@@ -1958,7 +1959,7 @@ func (s *AWSCloud) EnsureTCPLoadBalancerDeleted(name, region string) error {
 		for {
 			for securityGroupID := range securityGroupIDs {
 				request := &ec2.DeleteSecurityGroupInput{}
-				request.GroupID = &securityGroupID
+				request.GroupId = &securityGroupID
 				_, err := s.ec2.DeleteSecurityGroup(request)
 				if err == nil {
 					delete(securityGroupIDs, securityGroupID)
@@ -2046,7 +2047,7 @@ func (a *AWSCloud) getInstancesByIds(ids []string) ([]*ec2.Instance, error) {
 // Returns the instance with the specified ID
 func (a *AWSCloud) getInstanceById(instanceID string) (*ec2.Instance, error) {
 	request := &ec2.DescribeInstancesInput{
-		InstanceIDs: []*string{&instanceID},
+		InstanceIds: []*string{&instanceID},
 	}
 
 	instances, err := a.ec2.DescribeInstances(request)

pkg/cloudprovider/providers/aws/aws_instancegroups.go

@@ -32,8 +32,8 @@ var _ InstanceGroups = &AWSCloud{}
 func (a *AWSCloud) ResizeInstanceGroup(instanceGroupName string, size int) error {
 	request := &autoscaling.UpdateAutoScalingGroupInput{
 		AutoScalingGroupName: aws.String(instanceGroupName),
-		MinSize:              aws.Long(int64(size)),
-		MaxSize:              aws.Long(int64(size)),
+		MinSize:              aws.Int64(int64(size)),
+		MaxSize:              aws.Int64(int64(size)),
 	}
 	if _, err := a.asg.UpdateAutoScalingGroup(request); err != nil {
 		return fmt.Errorf("error resizing AWS autoscaling group: %v", err)

pkg/cloudprovider/providers/aws/aws_loadbalancer.go

@@ -133,7 +133,7 @@ func (s *AWSCloud) ensureLoadBalancer(name string, listeners []*elb.Listener, su
 					if orZero(actual.LoadBalancerPort) != orZero(expected.LoadBalancerPort) {
 						continue
 					}
-					if orEmpty(actual.SSLCertificateID) != orEmpty(expected.SSLCertificateID) {
+					if orEmpty(actual.SSLCertificateId) != orEmpty(expected.SSLCertificateId) {
 						continue
 					}
 					found = i
@@ -247,12 +247,12 @@ func (s *AWSCloud) ensureLoadBalancerHealthCheck(loadBalancer *elb.LoadBalancerD
 func (s *AWSCloud) ensureLoadBalancerInstances(loadBalancerName string, lbInstances []*elb.Instance, instances []*ec2.Instance) error {
 	expected := sets.NewString()
 	for _, instance := range instances {
-		expected.Insert(orEmpty(instance.InstanceID))
+		expected.Insert(orEmpty(instance.InstanceId))
 	}
 
 	actual := sets.NewString()
 	for _, lbInstance := range lbInstances {
-		actual.Insert(orEmpty(lbInstance.InstanceID))
+		actual.Insert(orEmpty(lbInstance.InstanceId))
 	}
 
 	additions := expected.Difference(actual)
@@ -261,14 +261,14 @@ func (s *AWSCloud) ensureLoadBalancerInstances(loadBalancerName string, lbInstan
 	addInstances := []*elb.Instance{}
 	for instanceId := range additions {
 		addInstance := &elb.Instance{}
-		addInstance.InstanceID = aws.String(instanceId)
+		addInstance.InstanceId = aws.String(instanceId)
 		addInstances = append(addInstances, addInstance)
 	}
 
 	removeInstances := []*elb.Instance{}
 	for instanceId := range removals {
 		removeInstance := &elb.Instance{}
-		removeInstance.InstanceID = aws.String(instanceId)
+		removeInstance.InstanceId = aws.String(instanceId)
 		removeInstances = append(removeInstances, removeInstance)
 	}
 

pkg/cloudprovider/providers/aws/aws_routes.go

@@ -56,8 +56,8 @@ func (s *AWSCloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error
 
 	var routes []*cloudprovider.Route
 	for _, r := range table.Routes {
-		instanceID := orEmpty(r.InstanceID)
-		destinationCIDR := orEmpty(r.DestinationCIDRBlock)
+		instanceID := orEmpty(r.InstanceId)
+		destinationCIDR := orEmpty(r.DestinationCidrBlock)
 
 		if instanceID == "" || destinationCIDR == "" {
 			continue
@@ -67,7 +67,7 @@ func (s *AWSCloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error
 		if err != nil {
 			return nil, err
 		}
-		instanceName := orEmpty(instance.PrivateDNSName)
+		instanceName := orEmpty(instance.PrivateDnsName)
 		routeName := clusterName + "-" + destinationCIDR
 		routes = append(routes, &cloudprovider.Route{Name: routeName, TargetInstance: instanceName, DestinationCIDR: destinationCIDR})
 	}
@@ -78,8 +78,8 @@ func (s *AWSCloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error
 // Sets the instance attribute "source-dest-check" to the specified value
 func (s *AWSCloud) configureInstanceSourceDestCheck(instanceID string, sourceDestCheck bool) error {
 	request := &ec2.ModifyInstanceAttributeInput{}
-	request.InstanceID = aws.String(instanceID)
-	request.SourceDestCheck = &ec2.AttributeBooleanValue{Value: aws.Boolean(sourceDestCheck)}
+	request.InstanceId = aws.String(instanceID)
+	request.SourceDestCheck = &ec2.AttributeBooleanValue{Value: aws.Bool(sourceDestCheck)}
 
 	_, err := s.ec2.ModifyInstanceAttribute(request)
 	if err != nil {
@@ -98,7 +98,7 @@ func (s *AWSCloud) CreateRoute(clusterName string, nameHint string, route *cloud
 
 	// In addition to configuring the route itself, we also need to configure the instance to accept that traffic
 	// On AWS, this requires turning source-dest checks off
-	err = s.configureInstanceSourceDestCheck(orEmpty(instance.InstanceID), false)
+	err = s.configureInstanceSourceDestCheck(orEmpty(instance.InstanceId), false)
 	if err != nil {
 		return err
 	}
@@ -110,9 +110,9 @@ func (s *AWSCloud) CreateRoute(clusterName string, nameHint string, route *cloud
 
 	request := &ec2.CreateRouteInput{}
 	// TODO: use ClientToken for idempotency?
-	request.DestinationCIDRBlock = aws.String(route.DestinationCIDR)
-	request.InstanceID = instance.InstanceID
-	request.RouteTableID = table.RouteTableID
+	request.DestinationCidrBlock = aws.String(route.DestinationCIDR)
+	request.InstanceId = instance.InstanceId
+	request.RouteTableId = table.RouteTableId
 
 	_, err = s.ec2.CreateRoute(request)
 	if err != nil {
@@ -131,8 +131,8 @@ func (s *AWSCloud) DeleteRoute(clusterName string, route *cloudprovider.Route) e
 	}
 
 	request := &ec2.DeleteRouteInput{}
-	request.DestinationCIDRBlock = aws.String(route.DestinationCIDR)
-	request.RouteTableID = table.RouteTableID
+	request.DestinationCidrBlock = aws.String(route.DestinationCIDR)
+	request.RouteTableId = table.RouteTableId
 
 	_, err = s.ec2.DeleteRoute(request)
 	if err != nil {

pkg/cloudprovider/providers/aws/aws_test.go

@@ -132,8 +132,8 @@ func NewFakeAWSServices() *FakeAWSServices {
 	s.instanceId = "i-self"
 	s.privateDnsName = "ip-172-20-0-100.ec2.internal"
 	var selfInstance ec2.Instance
-	selfInstance.InstanceID = &s.instanceId
-	selfInstance.PrivateDNSName = &s.privateDnsName
+	selfInstance.InstanceId = &s.instanceId
+	selfInstance.PrivateDnsName = &s.privateDnsName
 	s.instances = []*ec2.Instance{&selfInstance}
 
 	var tag ec2.Tag
@@ -263,10 +263,10 @@ func contains(haystack []*string, needle string) bool {
 func instanceMatchesFilter(instance *ec2.Instance, filter *ec2.Filter) bool {
 	name := *filter.Name
 	if name == "private-dns-name" {
-		if instance.PrivateDNSName == nil {
+		if instance.PrivateDnsName == nil {
 			return false
 		}
-		return contains(filter.Values, *instance.PrivateDNSName)
+		return contains(filter.Values, *instance.PrivateDnsName)
 	}
 	panic("Unknown filter name: " + name)
 }
@@ -274,15 +274,15 @@ func instanceMatchesFilter(instance *ec2.Instance, filter *ec2.Filter) bool {
 func (self *FakeEC2) DescribeInstances(request *ec2.DescribeInstancesInput) ([]*ec2.Instance, error) {
 	matches := []*ec2.Instance{}
 	for _, instance := range self.aws.instances {
-		if request.InstanceIDs != nil {
-			if instance.InstanceID == nil {
+		if request.InstanceIds != nil {
+			if instance.InstanceId == nil {
 				glog.Warning("Instance with no instance id: ", instance)
 				continue
 			}
 
 			found := false
-			for _, instanceId := range request.InstanceIDs {
-				if *instanceId == *instance.InstanceID {
+			for _, instanceId := range request.InstanceIds {
+				if *instanceId == *instance.InstanceId {
 					found = true
 					break
 				}
@@ -381,7 +381,7 @@ func (ec2 *FakeEC2) RevokeSecurityGroupIngress(*ec2.RevokeSecurityGroupIngressIn
 	panic("Not implemented")
 }
 
-func (ec2 *FakeEC2) DescribeVPCs(*ec2.DescribeVPCsInput) ([]*ec2.VPC, error) {
+func (ec2 *FakeEC2) DescribeVPCs(*ec2.DescribeVpcsInput) ([]*ec2.Vpc, error) {
 	panic("Not implemented")
 }
 
@@ -500,8 +500,8 @@ func TestList(t *testing.T) {
 		Value: aws.String("foo"),
 	}
 	instance0.Tags = []*ec2.Tag{&tag0}
-	instance0.InstanceID = aws.String("instance0")
-	instance0.PrivateDNSName = aws.String("instance0.ec2.internal")
+	instance0.InstanceId = aws.String("instance0")
+	instance0.PrivateDnsName = aws.String("instance0.ec2.internal")
 	state0 := ec2.InstanceState{
 		Name: aws.String("running"),
 	}
@@ -513,8 +513,8 @@ func TestList(t *testing.T) {
 		Value: aws.String("bar"),
 	}
 	instance1.Tags = []*ec2.Tag{&tag1}
-	instance1.InstanceID = aws.String("instance1")
-	instance1.PrivateDNSName = aws.String("instance1.ec2.internal")
+	instance1.InstanceId = aws.String("instance1")
+	instance1.PrivateDnsName = aws.String("instance1.ec2.internal")
 	state1 := ec2.InstanceState{
 		Name: aws.String("running"),
 	}
@@ -526,8 +526,8 @@ func TestList(t *testing.T) {
 		Value: aws.String("baz"),
 	}
 	instance2.Tags = []*ec2.Tag{&tag2}
-	instance2.InstanceID = aws.String("instance2")
-	instance2.PrivateDNSName = aws.String("instance2.ec2.internal")
+	instance2.InstanceId = aws.String("instance2")
+	instance2.PrivateDnsName = aws.String("instance2.ec2.internal")
 	state2 := ec2.InstanceState{
 		Name: aws.String("running"),
 	}
@@ -539,8 +539,8 @@ func TestList(t *testing.T) {
 		Value: aws.String("quux"),
 	}
 	instance3.Tags = []*ec2.Tag{&tag3}
-	instance3.InstanceID = aws.String("instance3")
-	instance3.PrivateDNSName = aws.String("instance3.ec2.internal")
+	instance3.InstanceId = aws.String("instance3")
+	instance3.PrivateDnsName = aws.String("instance3.ec2.internal")
 	state3 := ec2.InstanceState{
 		Name: aws.String("running"),
 	}
@@ -585,10 +585,10 @@ func TestNodeAddresses(t *testing.T) {
 	var instance1 ec2.Instance
 
 	//0
-	instance0.InstanceID = aws.String("instance-same")
-	instance0.PrivateDNSName = aws.String("instance-same.ec2.internal")
-	instance0.PrivateIPAddress = aws.String("192.168.0.1")
-	instance0.PublicIPAddress = aws.String("1.2.3.4")
+	instance0.InstanceId = aws.String("instance-same")
+	instance0.PrivateDnsName = aws.String("instance-same.ec2.internal")
+	instance0.PrivateIpAddress = aws.String("192.168.0.1")
+	instance0.PublicIpAddress = aws.String("1.2.3.4")
 	instance0.InstanceType = aws.String("c3.large")
 	state0 := ec2.InstanceState{
 		Name: aws.String("running"),
@@ -596,9 +596,9 @@ func TestNodeAddresses(t *testing.T) {
 	instance0.State = &state0
 
 	//1
-	instance1.InstanceID = aws.String("instance-same")
-	instance1.PrivateDNSName = aws.String("instance-same.ec2.internal")
-	instance1.PrivateIPAddress = aws.String("192.168.0.2")
+	instance1.InstanceId = aws.String("instance-same")
+	instance1.PrivateDnsName = aws.String("instance-same.ec2.internal")
+	instance1.PrivateIpAddress = aws.String("192.168.0.2")
 	instance1.InstanceType = aws.String("c3.large")
 	state1 := ec2.InstanceState{
 		Name: aws.String("running"),