github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-04 09:49:50 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
Upgrading to aws-sdk-go >= v0.9.0 requires a
source migration via awsmigrate-renamer tool.

see: http://aws.amazon.com/releasenotes/2948141298714307
This commit is contained in:
Trevor Pounds 2015-09-20 14:10:57 -07:00
parent b76f6a021c
commit df0718caa1
5 changed files with 125 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
pkg/cloudprovider/providers/aws/aws.go
View File

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

4
pkg/cloudprovider/providers/aws/aws_instancegroups.go
View File

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

10
pkg/cloudprovider/providers/aws/aws_loadbalancer.go
View File

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

22
pkg/cloudprovider/providers/aws/aws_routes.go
View File

@ -56,8 +56,8 @@ func (s *AWSCloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error
var routes []*cloudprovider.Route var routes []*cloudprovider.Route
for _, r := range table.Routes { for _, r := range table.Routes {
instanceID := orEmpty(r.InstanceID) instanceID := orEmpty(r.InstanceId)
destinationCIDR := orEmpty(r.DestinationCIDRBlock) destinationCIDR := orEmpty(r.DestinationCidrBlock)
if instanceID == "" || destinationCIDR == "" { if instanceID == "" || destinationCIDR == "" {
continue continue
@ -67,7 +67,7 @@ func (s *AWSCloud) ListRoutes(clusterName string) ([]*cloudprovider.Route, error
if err != nil { if err != nil {
return nil, err return nil, err
} }
instanceName := orEmpty(instance.PrivateDNSName) instanceName := orEmpty(instance.PrivateDnsName)
routeName := clusterName + "-" + destinationCIDR routeName := clusterName + "-" + destinationCIDR
routes = append(routes, &cloudprovider.Route{Name: routeName, TargetInstance: instanceName, DestinationCIDR: 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 // Sets the instance attribute "source-dest-check" to the specified value
func (s *AWSCloud) configureInstanceSourceDestCheck(instanceID string, sourceDestCheck bool) error { func (s *AWSCloud) configureInstanceSourceDestCheck(instanceID string, sourceDestCheck bool) error {
request := &ec2.ModifyInstanceAttributeInput{} request := &ec2.ModifyInstanceAttributeInput{}
request.InstanceID = aws.String(instanceID) request.InstanceId = aws.String(instanceID)
request.SourceDestCheck = &ec2.AttributeBooleanValue{Value: aws.Boolean(sourceDestCheck)} request.SourceDestCheck = &ec2.AttributeBooleanValue{Value: aws.Bool(sourceDestCheck)}
_, err := s.ec2.ModifyInstanceAttribute(request) _, err := s.ec2.ModifyInstanceAttribute(request)
if err != nil { 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 // 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 // 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 { if err != nil {
return err return err
} }
@ -110,9 +110,9 @@ func (s *AWSCloud) CreateRoute(clusterName string, nameHint string, route *cloud
request := &ec2.CreateRouteInput{} request := &ec2.CreateRouteInput{}
// TODO: use ClientToken for idempotency? // TODO: use ClientToken for idempotency?
request.DestinationCIDRBlock = aws.String(route.DestinationCIDR) request.DestinationCidrBlock = aws.String(route.DestinationCIDR)
request.InstanceID = instance.InstanceID request.InstanceId = instance.InstanceId
request.RouteTableID = table.RouteTableID request.RouteTableId = table.RouteTableId
_, err = s.ec2.CreateRoute(request) _, err = s.ec2.CreateRoute(request)
if err != nil { if err != nil {
@ -131,8 +131,8 @@ func (s *AWSCloud) DeleteRoute(clusterName string, route *cloudprovider.Route) e
} }
request := &ec2.DeleteRouteInput{} request := &ec2.DeleteRouteInput{}
request.DestinationCIDRBlock = aws.String(route.DestinationCIDR) request.DestinationCidrBlock = aws.String(route.DestinationCIDR)
request.RouteTableID = table.RouteTableID request.RouteTableId = table.RouteTableId
_, err = s.ec2.DeleteRoute(request) _, err = s.ec2.DeleteRoute(request)
if err != nil { if err != nil {

48
pkg/cloudprovider/providers/aws/aws_test.go
View File

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