Merge pull request #61 from justinsb/upup_elb_healthchecks

cloudup: Add support for ELB health checks

upup/cmd/cloudup/main.go

@@ -204,7 +204,6 @@ func (c *CreateClusterCmd) Run() error {
 			c.Config.NodeUpTags = append(c.Config.NodeUpTags, "_aws")
 
 			l.AddTypes(map[string]interface{}{
-				"autoscalingGroup":            &awstasks.AutoscalingGroup{},
 				"dhcpOptions":                 &awstasks.DHCPOptions{},
 				"elasticIP":                   &awstasks.ElasticIP{},
 				"iamInstanceProfile":          &awstasks.IAMInstanceProfile{},
@@ -226,6 +225,18 @@ func (c *CreateClusterCmd) Run() error {
 				"subnet":                      &awstasks.Subnet{},
 				"vpc":                         &awstasks.VPC{},
 				"vpcDHDCPOptionsAssociation": &awstasks.VPCDHCPOptionsAssociation{},
+
+				// ELB
+				"loadBalancer":             &awstasks.LoadBalancer{},
+				"loadBalancerAttachment":   &awstasks.LoadBalancerAttachment{},
+				"loadBalancerHealthChecks": &awstasks.LoadBalancerHealthChecks{},
+
+				// Autoscaling
+				"autoscalingGroup": &awstasks.AutoscalingGroup{},
+
+				// Route53
+				"dnsName": &awstasks.DNSName{},
+				"dnsZone": &awstasks.DNSZone{},
 			})
 
 			// For now a zone to be specified...

upup/pkg/fi/cloudup/awstasks/load_balancer.go

@@ -16,6 +16,8 @@ import (
 type LoadBalancer struct {
 	Name *string
 
+	// ID is the name in ELB, possibly different from our name
+	// (ELB is restricted as to names, so we have limited choices!)
 	ID *string
 
 	DNSName      *string
@@ -27,6 +29,12 @@ type LoadBalancer struct {
 	Listeners map[string]*LoadBalancerListener
 }
 
+var _ fi.CompareWithID = &LoadBalancer{}
+
+func (e *LoadBalancer) CompareWithID() *string {
+	return e.ID
+}
+
 type LoadBalancerListener struct {
 	InstancePort int
 }
@@ -90,7 +98,12 @@ func findELB(cloud *awsup.AWSCloud, name string) (*elb.LoadBalancerDescription,
 func (e *LoadBalancer) Find(c *fi.Context) (*LoadBalancer, error) {
 	cloud := c.Cloud.(*awsup.AWSCloud)
 
-	lb, err := findELB(cloud, fi.StringValue(e.Name))
+	elbName := fi.StringValue(e.ID)
+	if elbName == "" {
+		elbName = fi.StringValue(e.Name)
+	}
+
+	lb, err := findELB(cloud, elbName)
 	if err != nil {
 		return nil, err
 	}
@@ -100,7 +113,7 @@ func (e *LoadBalancer) Find(c *fi.Context) (*LoadBalancer, error) {
 
 	actual := &LoadBalancer{}
 	actual.Name = e.Name
-	actual.ID = e.DNSName
+	actual.ID = lb.LoadBalancerName
 	actual.DNSName = lb.DNSName
 	actual.HostedZoneId = lb.CanonicalHostedZoneNameID
 	for _, subnet := range lb.Subnets {
@@ -126,13 +139,15 @@ func (e *LoadBalancer) Find(c *fi.Context) (*LoadBalancer, error) {
 	if subnetSlicesEqualIgnoreOrder(actual.Subnets, e.Subnets) {
 		actual.Subnets = e.Subnets
 	}
-
 	if e.DNSName == nil {
 		e.DNSName = actual.DNSName
 	}
 	if e.HostedZoneId == nil {
 		e.HostedZoneId = actual.HostedZoneId
 	}
+	if e.ID == nil {
+		e.ID = actual.ID
+	}
 
 	return actual, nil
 }
@@ -157,9 +172,18 @@ func (s *LoadBalancer) CheckChanges(a, e, changes *LoadBalancer) error {
 }
 
 func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalancer) error {
+	elbName := e.ID
+	if elbName == nil {
+		elbName = e.Name
+	}
+
+	if elbName == nil {
+		return fi.RequiredField("ID")
+	}
+
 	if a == nil {
 		request := &elb.CreateLoadBalancerInput{}
-		request.LoadBalancerName = e.Name
+		request.LoadBalancerName = elbName
 
 		for _, subnet := range e.Subnets {
 			request.Subnets = append(request.Subnets, subnet.ID)
@@ -180,7 +204,7 @@ func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalan
 			request.Listeners = append(request.Listeners, awsListener)
 		}
 
-		glog.V(2).Infof("Creating ELB with Name:%q", *e.Name)
+		glog.V(2).Infof("Creating ELB with Name:%q", *e.ID)
 
 		response, err := t.Cloud.ELB.CreateLoadBalancer(request)
 		if err != nil {
@@ -188,9 +212,9 @@ func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalan
 		}
 
 		e.DNSName = response.DNSName
-		e.ID = response.DNSName
+		e.ID = elbName
 
-		lb, err := findELB(t.Cloud, *e.Name)
+		lb, err := findELB(t.Cloud, *e.ID)
 		if err != nil {
 			return err
 		}
@@ -207,7 +231,7 @@ func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalan
 
 		if changes.Listeners != nil {
 			request := &elb.CreateLoadBalancerListenersInput{}
-			request.LoadBalancerName = e.Name
+			request.LoadBalancerName = elbName
 
 			for loadBalancerPort, listener := range changes.Listeners {
 				loadBalancerPortInt, err := strconv.ParseInt(loadBalancerPort, 10, 64)
@@ -227,5 +251,5 @@ func (_ *LoadBalancer) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalan
 		}
 	}
 
-	return t.AddAWSTags(*e.ID, t.Cloud.BuildTags(e.Name, nil))
+	return t.AddELBTags(*e.ID, t.Cloud.BuildTags(e.Name, nil))
 }

upup/pkg/fi/cloudup/awstasks/load_balancer_attachment.go

@@ -32,7 +32,7 @@ func (e *LoadBalancerAttachment) Find(c *fi.Context) (*LoadBalancerAttachment, e
 		}
 
 		for _, name := range g.LoadBalancerNames {
-			if aws.StringValue(name) != *e.AutoscalingGroup.Name {
+			if aws.StringValue(name) != *e.LoadBalancer.ID {
 				continue
 			}
 
@@ -65,7 +65,7 @@ func (s *LoadBalancerAttachment) CheckChanges(a, e, changes *LoadBalancerAttachm
 func (_ *LoadBalancerAttachment) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalancerAttachment) error {
 	request := &autoscaling.AttachLoadBalancersInput{}
 	request.AutoScalingGroupName = e.AutoscalingGroup.Name
-	request.LoadBalancerNames = []*string{e.LoadBalancer.Name}
+	request.LoadBalancerNames = []*string{e.LoadBalancer.ID}
 
 	glog.V(2).Infof("Attaching autoscaling group %q to ELB %q", *e.AutoscalingGroup.Name, *e.LoadBalancer.Name)
 

upup/pkg/fi/cloudup/awstasks/loadbalancer_healthchecks.go

@@ -0,0 +1,90 @@
+package awstasks
+
+import (
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/service/elb"
+	"github.com/golang/glog"
+	"k8s.io/kube-deploy/upup/pkg/fi"
+	"k8s.io/kube-deploy/upup/pkg/fi/cloudup/awsup"
+)
+
+type LoadBalancerHealthChecks struct {
+	LoadBalancer *LoadBalancer
+
+	Target *string
+
+	HealthyThreshold   *int64
+	UnhealthyThreshold *int64
+
+	Interval *int64
+	Timeout  *int64
+}
+
+func (e *LoadBalancerHealthChecks) String() string {
+	return fi.TaskAsString(e)
+}
+
+func (e *LoadBalancerHealthChecks) Find(c *fi.Context) (*LoadBalancerHealthChecks, error) {
+	cloud := c.Cloud.(*awsup.AWSCloud)
+
+	elbName := fi.StringValue(e.LoadBalancer.ID)
+
+	lb, err := findELB(cloud, elbName)
+	if err != nil {
+		return nil, err
+	}
+	if lb == nil {
+		return nil, nil
+	}
+
+	actual := &LoadBalancerHealthChecks{}
+	actual.LoadBalancer = e.LoadBalancer
+
+	if lb.HealthCheck != nil {
+		actual.Target = lb.HealthCheck.Target
+		actual.HealthyThreshold = lb.HealthCheck.HealthyThreshold
+		actual.UnhealthyThreshold = lb.HealthCheck.UnhealthyThreshold
+		actual.Interval = lb.HealthCheck.Interval
+		actual.Timeout = lb.HealthCheck.Timeout
+	}
+	return actual, nil
+
+}
+
+func (e *LoadBalancerHealthChecks) Run(c *fi.Context) error {
+	return fi.DefaultDeltaRunMethod(e, c)
+}
+
+func (s *LoadBalancerHealthChecks) CheckChanges(a, e, changes *LoadBalancerHealthChecks) error {
+	if a == nil {
+		if e.LoadBalancer == nil {
+			return fi.RequiredField("LoadBalancer")
+		}
+		if e.Target == nil {
+			return fi.RequiredField("Target")
+		}
+	}
+	return nil
+}
+
+func (_ *LoadBalancerHealthChecks) RenderAWS(t *awsup.AWSAPITarget, a, e, changes *LoadBalancerHealthChecks) error {
+	request := &elb.ConfigureHealthCheckInput{}
+	request.LoadBalancerName = e.LoadBalancer.ID
+	request.HealthCheck = &elb.HealthCheck{
+		Target:             e.Target,
+		HealthyThreshold:   e.HealthyThreshold,
+		UnhealthyThreshold: e.UnhealthyThreshold,
+		Interval:           e.Interval,
+		Timeout:            e.Timeout,
+	}
+
+	glog.V(2).Infof("Configuring health checks on ELB %q", *e.LoadBalancer.ID)
+
+	_, err := t.Cloud.ELB.ConfigureHealthCheck(request)
+	if err != nil {
+		return fmt.Errorf("error attaching autoscaling group to ELB: %v", err)
+	}
+
+	return nil
+}