// Determine if a particular policy is assigned to an ELB listener
func resourceAwsELBSticknessPolicyAssigned(policyName, lbName, lbPort string, elbconn *elb.ELB) (bool, error) {
describeElbOpts := &elb.DescribeLoadBalancersInput{
LoadBalancerNames: []*string{aws.String(lbName)},
}
describeResp, err := elbconn.DescribeLoadBalancers(describeElbOpts)
if err != nil {
if ec2err, ok := err.(awserr.Error); ok {
if ec2err.Code() == "LoadBalancerNotFound" {
return false, nil
}
}
return false, fmt.Errorf("Error retrieving ELB description: %s", err)
}
if len(describeResp.LoadBalancerDescriptions) != 1 {
return false, fmt.Errorf("Unable to find ELB: %#v", describeResp.LoadBalancerDescriptions)
}
lb := describeResp.LoadBalancerDescriptions[0]
assigned := false
for _, listener := range lb.ListenerDescriptions {
if lbPort != strconv.Itoa(int(*listener.Listener.LoadBalancerPort)) {
continue
}
for _, name := range listener.PolicyNames {
if policyName == *name {
assigned = true
break
}
}
}
return assigned, nil
}
func awsGetLoadBalancers(lb elb.ELB) ([]*elb.LoadBalancerDescription, error) {
lbList := []*elb.LoadBalancerDescription{}
resp, err := lb.DescribeLoadBalancers(nil)
if err != nil {
return nil, fmt.Errorf("unable to describe ELB Balancers")
}
for _, loadBalancer := range resp.LoadBalancerDescriptions {
lbList = append(lbList, loadBalancer)
}
return lbList, nil
}
// setTags is a helper to set the tags for a resource. It expects the
// tags field to be named "tags"
func setTagsELB(conn *elb.ELB, d *schema.ResourceData) error {
if d.HasChange("tags") {
oraw, nraw := d.GetChange("tags")
o := oraw.(map[string]interface{})
n := nraw.(map[string]interface{})
create, remove := diffTagsELB(tagsFromMapELB(o), tagsFromMapELB(n))
// Set tags
if len(remove) > 0 {
log.Printf("[DEBUG] Removing tags: %#v", remove)
k := make([]*elb.TagKeyOnly, 0, len(remove))
for _, t := range remove {
k = append(k, &elb.TagKeyOnly{Key: t.Key})
}
_, err := conn.RemoveTags(&elb.RemoveTagsInput{
LoadBalancerNames: []*string{aws.String(d.Get("name").(string))},
Tags: k,
})
if err != nil {
return err
}
}
if len(create) > 0 {
log.Printf("[DEBUG] Creating tags: %#v", create)
_, err := conn.AddTags(&elb.AddTagsInput{
LoadBalancerNames: []*string{aws.String(d.Get("name").(string))},
Tags: create,
})
if err != nil {
return err
}
}
}
return nil
}
func createRoute53Upsert(r53Api *route53.Route53, elbApi *elb.ELB, domain string, hn string) (*route53.ChangeResourceRecordSetsInput, error) {
domainParts := strings.Split(domain, ".")
segments := len(domainParts)
tld := strings.Join(domainParts[segments-2:], ".")
// subdomain := strings.Join(domainParts[:segments-2], ".")
elbName := strings.Split(hn, "-")[0]
lbInput := &elb.DescribeLoadBalancersInput{
LoadBalancerNames: []*string{
&elbName,
},
}
resp, err := elbApi.DescribeLoadBalancers(lbInput)
if err != nil {
glog.Warningf("Could not describe load balancer: %v", err)
return nil, err
}
descs := resp.LoadBalancerDescriptions
if len(descs) < 1 {
glog.Warningf("No lb found for %s: %v", tld, err)
return nil, err
}
if len(descs) > 1 {
glog.Warningf("Multiple lbs found for %s: %v", tld, err)
return nil, err
}
hzId := descs[0].CanonicalHostedZoneNameID
listHostedZoneInput := route53.ListHostedZonesByNameInput{
DNSName: &tld,
}
hzOut, err := r53Api.ListHostedZonesByName(&listHostedZoneInput)
if err != nil {
glog.Warningf("No zone found for %s: %v", tld, err)
return nil, err
}
zones := hzOut.HostedZones
if len(zones) < 1 {
glog.Warningf("No zone found for %s", tld)
return nil, err
}
// The AWS API may return more than one zone, the first zone should be the relevant one
tldWithDot := fmt.Sprint(tld, ".")
if *zones[0].Name != tldWithDot {
glog.Warningf("Zone found %s does not match tld given %s", *zones[0].Name, tld)
return nil, err
}
zoneId := *zones[0].ID
zoneParts := strings.Split(zoneId, "/")
zoneId = zoneParts[len(zoneParts)-1]
at := route53.AliasTarget{
DNSName: &hn,
EvaluateTargetHealth: aws.Boolean(false),
HostedZoneID: hzId,
}
rrs := route53.ResourceRecordSet{
AliasTarget: &at,
Name: &domain,
Type: aws.String("A"),
}
change := route53.Change{
Action: aws.String("UPSERT"),
ResourceRecordSet: &rrs,
}
batch := route53.ChangeBatch{
Changes: []*route53.Change{&change},
Comment: aws.String("Kubernetes Update to Service"),
}
crrsInput := route53.ChangeResourceRecordSetsInput{
ChangeBatch: &batch,
HostedZoneID: &zoneId,
}
//glog.Infof("Created dns record set: tld=%s, subdomain=%s, zoneId=%s", tld, subdomain, zoneId)
return &crrsInput, nil
}
func resourceAwsLoadBalancerPolicyUnassign(policyName, loadBalancerName string, elbconn *elb.ELB) (Reassignment, error) {
reassignments := Reassignment{}
describeElbOpts := &elb.DescribeLoadBalancersInput{
LoadBalancerNames: []*string{aws.String(loadBalancerName)},
}
describeResp, err := elbconn.DescribeLoadBalancers(describeElbOpts)
if err != nil {
if ec2err, ok := err.(awserr.Error); ok {
if ec2err.Code() == "LoadBalancerNotFound" {
return reassignments, nil
}
}
return reassignments, fmt.Errorf("Error retrieving ELB description: %s", err)
}
if len(describeResp.LoadBalancerDescriptions) != 1 {
return reassignments, fmt.Errorf("Unable to find ELB: %#v", describeResp.LoadBalancerDescriptions)
}
lb := describeResp.LoadBalancerDescriptions[0]
for _, backendServer := range lb.BackendServerDescriptions {
policies := []*string{}
for _, name := range backendServer.PolicyNames {
if policyName != *name {
policies = append(policies, name)
}
}
if len(backendServer.PolicyNames) != len(policies) {
setOpts := &elb.SetLoadBalancerPoliciesForBackendServerInput{
LoadBalancerName: aws.String(loadBalancerName),
InstancePort: aws.Int64(*backendServer.InstancePort),
PolicyNames: policies,
}
reassignOpts := &elb.SetLoadBalancerPoliciesForBackendServerInput{
LoadBalancerName: aws.String(loadBalancerName),
InstancePort: aws.Int64(*backendServer.InstancePort),
PolicyNames: backendServer.PolicyNames,
}
reassignments.backendServerPolicies = append(reassignments.backendServerPolicies, reassignOpts)
_, err = elbconn.SetLoadBalancerPoliciesForBackendServer(setOpts)
if err != nil {
return reassignments, fmt.Errorf("Error Setting Load Balancer Policies for Backend Server: %s", err)
}
}
}
for _, listener := range lb.ListenerDescriptions {
policies := []*string{}
for _, name := range listener.PolicyNames {
if policyName != *name {
policies = append(policies, name)
}
}
if len(listener.PolicyNames) != len(policies) {
setOpts := &elb.SetLoadBalancerPoliciesOfListenerInput{
LoadBalancerName: aws.String(loadBalancerName),
LoadBalancerPort: aws.Int64(*listener.Listener.LoadBalancerPort),
PolicyNames: policies,
}
reassignOpts := &elb.SetLoadBalancerPoliciesOfListenerInput{
LoadBalancerName: aws.String(loadBalancerName),
LoadBalancerPort: aws.Int64(*listener.Listener.LoadBalancerPort),
PolicyNames: listener.PolicyNames,
}
reassignments.listenerPolicies = append(reassignments.listenerPolicies, reassignOpts)
_, err = elbconn.SetLoadBalancerPoliciesOfListener(setOpts)
if err != nil {
return reassignments, fmt.Errorf("Error Setting Load Balancer Policies of Listener: %s", err)
}
}
}
return reassignments, nil
}
