From df0718caa1908763dfb124c9b4f2e7808ef1c33e Mon Sep 17 00:00:00 2001 From: Trevor Pounds Date: Sun, 20 Sep 2015 14:10:57 -0700 Subject: [PATCH] Migrate source to aws-sdk-go v0.9.9. Upgrading to aws-sdk-go >= v0.9.0 requires a source migration via awsmigrate-renamer tool. see: http://aws.amazon.com/releasenotes/2948141298714307 --- pkg/cloudprovider/providers/aws/aws.go | 165 +++++++++--------- .../providers/aws/aws_instancegroups.go | 4 +- .../providers/aws/aws_loadbalancer.go | 10 +- pkg/cloudprovider/providers/aws/aws_routes.go | 22 +-- pkg/cloudprovider/providers/aws/aws_test.go | 48 ++--- 5 files changed, 125 insertions(+), 124 deletions(-) diff --git a/pkg/cloudprovider/providers/aws/aws.go b/pkg/cloudprovider/providers/aws/aws.go index 69c8b99aacc..d4d13ebc91b 100644 --- a/pkg/cloudprovider/providers/aws/aws.go +++ b/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: ®ionName, 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: ®ionName, 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: ®ionName, 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: // // - 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) diff --git a/pkg/cloudprovider/providers/aws/aws_instancegroups.go b/pkg/cloudprovider/providers/aws/aws_instancegroups.go index 6e5ae1053fb..643c8fa7c55 100644 --- a/pkg/cloudprovider/providers/aws/aws_instancegroups.go +++ b/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) diff --git a/pkg/cloudprovider/providers/aws/aws_loadbalancer.go b/pkg/cloudprovider/providers/aws/aws_loadbalancer.go index c96e1155176..2958f2ff701 100644 --- a/pkg/cloudprovider/providers/aws/aws_loadbalancer.go +++ b/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) } diff --git a/pkg/cloudprovider/providers/aws/aws_routes.go b/pkg/cloudprovider/providers/aws/aws_routes.go index b81763fc8f4..cfa5db37006 100644 --- a/pkg/cloudprovider/providers/aws/aws_routes.go +++ b/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 { diff --git a/pkg/cloudprovider/providers/aws/aws_test.go b/pkg/cloudprovider/providers/aws/aws_test.go index 67fa86de33f..be6a94bb419 100644 --- a/pkg/cloudprovider/providers/aws/aws_test.go +++ b/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"),