From 0120899f2aa073e531fe5f9c67eb01ac2b4023c3 Mon Sep 17 00:00:00 2001 From: Christopher Tiwald Date: Sun, 26 Apr 2015 17:57:46 -0400 Subject: [PATCH] aws: Add support for aws_lb_cookie_stickiness_policy. This resource represents a session stickiness policy in AWS, and can be applied to an ELB's client-facing listeners. --- builtin/providers/aws/provider.go | 1 + ...esource_aws_lb_cookie_stickiness_policy.go | 156 ++++++++++++++++++ 2 files changed, 157 insertions(+) create mode 100644 builtin/providers/aws/resource_aws_lb_cookie_stickiness_policy.go diff --git a/builtin/providers/aws/provider.go b/builtin/providers/aws/provider.go index 3e534c4b6e..f717a2e55e 100644 --- a/builtin/providers/aws/provider.go +++ b/builtin/providers/aws/provider.go @@ -86,6 +86,7 @@ func Provider() terraform.ResourceProvider { "aws_internet_gateway": resourceAwsInternetGateway(), "aws_key_pair": resourceAwsKeyPair(), "aws_launch_configuration": resourceAwsLaunchConfiguration(), + "aws_lb_cookie_stickiness_policy": resourceAwsLBCookieStickinessPolicy(), "aws_main_route_table_association": resourceAwsMainRouteTableAssociation(), "aws_network_acl": resourceAwsNetworkAcl(), "aws_network_interface": resourceAwsNetworkInterface(), diff --git a/builtin/providers/aws/resource_aws_lb_cookie_stickiness_policy.go b/builtin/providers/aws/resource_aws_lb_cookie_stickiness_policy.go new file mode 100644 index 0000000000..cc3d89c76b --- /dev/null +++ b/builtin/providers/aws/resource_aws_lb_cookie_stickiness_policy.go @@ -0,0 +1,156 @@ +package aws + +import ( + "fmt" + "strings" + + "github.com/awslabs/aws-sdk-go/aws" + "github.com/awslabs/aws-sdk-go/service/elb" + "github.com/hashicorp/terraform/helper/schema" +) + +func resourceAwsLBCookieStickinessPolicy() *schema.Resource { + return &schema.Resource{ + // There is no concept of "updating" an LB Stickiness policy in + // the AWS API. + Create: resourceAwsLBCookieStickinessPolicyCreate, + Update: resourceAwsLBCookieStickinessPolicyCreate, + + Read: resourceAwsLBCookieStickinessPolicyRead, + Delete: resourceAwsLBCookieStickinessPolicyDelete, + + Schema: map[string]*schema.Schema{ + "name": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "load_balancer": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "lb_port": &schema.Schema{ + Type: schema.TypeInt, + Required: true, + ForceNew: true, + }, + + "cookie_expiration_period": &schema.Schema{ + Type: schema.TypeInt, + Optional: true, + ForceNew: true, + }, + }, + } +} + +func resourceAwsLBCookieStickinessPolicyCreate(d *schema.ResourceData, meta interface{}) error { + elbconn := meta.(*AWSClient).elbconn + + // Provision the LBStickinessPolicy + lbspOpts := &elb.CreateLBCookieStickinessPolicyInput{ + CookieExpirationPeriod: aws.Long(int64(d.Get("cookie_expiration_period").(int))), + LoadBalancerName: aws.String(d.Get("load_balancer").(string)), + PolicyName: aws.String(d.Get("name").(string)), + } + + if _, err := elbconn.CreateLBCookieStickinessPolicy(lbspOpts); err != nil { + return fmt.Errorf("Error creating LBCookieStickinessPolicy: %s", err) + } + + setLoadBalancerOpts := &elb.SetLoadBalancerPoliciesOfListenerInput{ + LoadBalancerName: aws.String(d.Get("load_balancer").(string)), + LoadBalancerPort: aws.Long(int64(d.Get("lb_port").(int))), + PolicyNames: []*string{aws.String(d.Get("name").(string))}, + } + + if _, err := elbconn.SetLoadBalancerPoliciesOfListener(setLoadBalancerOpts); err != nil { + return fmt.Errorf("Error setting LBCookieStickinessPolicy: %s", err) + } + + d.SetId(fmt.Sprintf("%s:%d:%s", + *lbspOpts.LoadBalancerName, + *setLoadBalancerOpts.LoadBalancerPort, + *lbspOpts.PolicyName)) + return nil +} + +func resourceAwsLBCookieStickinessPolicyRead(d *schema.ResourceData, meta interface{}) error { + elbconn := meta.(*AWSClient).elbconn + + lbName, lbPort, policyName := resourceAwsLBCookieStickinessPolicyParseId(d.Id()) + + request := &elb.DescribeLoadBalancerPoliciesInput{ + LoadBalancerName: aws.String(lbName), + PolicyNames: []*string{aws.String(policyName)}, + } + + getResp, err := elbconn.DescribeLoadBalancerPolicies(request) + if err != nil { + if ec2err, ok := err.(aws.APIError); ok && ec2err.Code == "PolicyNotFound" { + // The policy is gone. + d.SetId("") + return nil + } + return fmt.Errorf("Error retrieving policy: %s", err) + } + + if len(getResp.PolicyDescriptions) != 1 { + return fmt.Errorf("Unable to find policy %#v", getResp.PolicyDescriptions) + } + + // We can get away with this because there's only one attribute, the + // cookie expiration, in these descriptions. + policyDesc := getResp.PolicyDescriptions[0] + cookieAttr := policyDesc.PolicyAttributeDescriptions[0] + if *cookieAttr.AttributeName != "CookieExpirationPeriod" { + return fmt.Errorf("Unable to find cookie expiration period.") + } + d.Set("cookie_expiration_period", cookieAttr.AttributeValue) + + d.Set("name", policyName) + d.Set("load_balancer", lbName) + d.Set("lb_port", lbPort) + + return nil +} + +func resourceAwsLBCookieStickinessPolicyDelete(d *schema.ResourceData, meta interface{}) error { + elbconn := meta.(*AWSClient).elbconn + + lbName, _, policyName := resourceAwsLBCookieStickinessPolicyParseId(d.Id()) + + // Perversely, if we Set an empty list of PolicyNames, we detach the + // policies attached to a listener, which is required to delete the + // policy itself. + setLoadBalancerOpts := &elb.SetLoadBalancerPoliciesOfListenerInput{ + LoadBalancerName: aws.String(d.Get("load_balancer").(string)), + LoadBalancerPort: aws.Long(int64(d.Get("lb_port").(int))), + PolicyNames: []*string{}, + } + + if _, err := elbconn.SetLoadBalancerPoliciesOfListener(setLoadBalancerOpts); err != nil { + return fmt.Errorf("Error removing LBCookieStickinessPolicy: %s", err) + } + + request := &elb.DeleteLoadBalancerPolicyInput{ + LoadBalancerName: aws.String(lbName), + PolicyName: aws.String(policyName), + } + + if _, err := elbconn.DeleteLoadBalancerPolicy(request); err != nil { + return fmt.Errorf("Error deleting LB stickiness policy %s: %s", d.Id(), err) + } + return nil +} + +// resourceAwsLBCookieStickinessPolicyParseId takes an ID and parses it into +// it's constituent parts. You need three axes (LB name, policy name, and LB +// port) to create or identify a stickiness policy in AWS's API. +func resourceAwsLBCookieStickinessPolicyParseId(id string) (string, string, string) { + parts := strings.SplitN(id, ":", 3) + return parts[0], parts[1], parts[2] +}