github.com/mohanarpit/terraform@v0.6.16-0.20160909104007-291f29853544/builtin/providers/aws/resource_aws_alb_listener.go (about) 1 package aws 2 3 import ( 4 "errors" 5 "fmt" 6 "log" 7 "strings" 8 9 "github.com/aws/aws-sdk-go/aws" 10 "github.com/aws/aws-sdk-go/aws/awserr" 11 "github.com/aws/aws-sdk-go/service/elbv2" 12 "github.com/hashicorp/errwrap" 13 "github.com/hashicorp/terraform/helper/schema" 14 ) 15 16 func resourceAwsAlbListener() *schema.Resource { 17 return &schema.Resource{ 18 Create: resourceAwsAlbListenerCreate, 19 Read: resourceAwsAlbListenerRead, 20 Update: resourceAwsAlbListenerUpdate, 21 Delete: resourceAwsAlbListenerDelete, 22 Importer: &schema.ResourceImporter{ 23 State: schema.ImportStatePassthrough, 24 }, 25 26 Schema: map[string]*schema.Schema{ 27 "arn": { 28 Type: schema.TypeString, 29 Computed: true, 30 }, 31 32 "load_balancer_arn": { 33 Type: schema.TypeString, 34 Required: true, 35 ForceNew: true, 36 }, 37 38 "port": { 39 Type: schema.TypeInt, 40 Required: true, 41 ValidateFunc: validateAwsAlbListenerPort, 42 }, 43 44 "protocol": { 45 Type: schema.TypeString, 46 Optional: true, 47 Default: "HTTP", 48 StateFunc: func(v interface{}) string { 49 return strings.ToUpper(v.(string)) 50 }, 51 ValidateFunc: validateAwsAlbListenerProtocol, 52 }, 53 54 "ssl_policy": { 55 Type: schema.TypeString, 56 Optional: true, 57 Computed: true, 58 }, 59 60 "certificate_arn": { 61 Type: schema.TypeString, 62 Optional: true, 63 }, 64 65 "default_action": { 66 Type: schema.TypeList, 67 Required: true, 68 Elem: &schema.Resource{ 69 Schema: map[string]*schema.Schema{ 70 "target_group_arn": { 71 Type: schema.TypeString, 72 Required: true, 73 }, 74 "type": { 75 Type: schema.TypeString, 76 Required: true, 77 ValidateFunc: validateAwsAlbListenerActionType, 78 }, 79 }, 80 }, 81 }, 82 }, 83 } 84 } 85 86 func resourceAwsAlbListenerCreate(d *schema.ResourceData, meta interface{}) error { 87 elbconn := meta.(*AWSClient).elbv2conn 88 89 params := &elbv2.CreateListenerInput{ 90 LoadBalancerArn: aws.String(d.Get("load_balancer_arn").(string)), 91 Port: aws.Int64(int64(d.Get("port").(int))), 92 Protocol: aws.String(d.Get("protocol").(string)), 93 } 94 95 if sslPolicy, ok := d.GetOk("ssl_policy"); ok { 96 params.SslPolicy = aws.String(sslPolicy.(string)) 97 } 98 99 if certificateArn, ok := d.GetOk("certificate_arn"); ok { 100 params.Certificates = make([]*elbv2.Certificate, 1) 101 params.Certificates[0] = &elbv2.Certificate{ 102 CertificateArn: aws.String(certificateArn.(string)), 103 } 104 } 105 106 if defaultActions := d.Get("default_action").([]interface{}); len(defaultActions) == 1 { 107 params.DefaultActions = make([]*elbv2.Action, len(defaultActions)) 108 109 for i, defaultAction := range defaultActions { 110 defaultActionMap := defaultAction.(map[string]interface{}) 111 112 params.DefaultActions[i] = &elbv2.Action{ 113 TargetGroupArn: aws.String(defaultActionMap["target_group_arn"].(string)), 114 Type: aws.String(defaultActionMap["type"].(string)), 115 } 116 } 117 } 118 119 resp, err := elbconn.CreateListener(params) 120 if err != nil { 121 return errwrap.Wrapf("Error creating ALB Listener: {{err}}", err) 122 } 123 124 if len(resp.Listeners) == 0 { 125 return errors.New("Error creating ALB Listener: no listeners returned in response") 126 } 127 128 d.SetId(*resp.Listeners[0].ListenerArn) 129 130 return resourceAwsAlbListenerRead(d, meta) 131 } 132 133 func resourceAwsAlbListenerRead(d *schema.ResourceData, meta interface{}) error { 134 elbconn := meta.(*AWSClient).elbv2conn 135 136 resp, err := elbconn.DescribeListeners(&elbv2.DescribeListenersInput{ 137 ListenerArns: []*string{aws.String(d.Id())}, 138 }) 139 if err != nil { 140 if isListenerNotFound(err) { 141 log.Printf("[WARN] DescribeListeners - removing %s from state", d.Id()) 142 d.SetId("") 143 return nil 144 } 145 return errwrap.Wrapf("Error retrieving Listener: {{err}}", err) 146 } 147 148 if len(resp.Listeners) != 1 { 149 return fmt.Errorf("Error retrieving Listener %q", d.Id()) 150 } 151 152 listener := resp.Listeners[0] 153 154 d.Set("arn", listener.ListenerArn) 155 d.Set("load_balancer_arn", listener.LoadBalancerArn) 156 d.Set("port", listener.Port) 157 d.Set("protocol", listener.Protocol) 158 d.Set("ssl_policy", listener.SslPolicy) 159 160 if listener.Certificates != nil && len(listener.Certificates) == 1 { 161 d.Set("certificate_arn", listener.Certificates[0].CertificateArn) 162 } 163 164 defaultActions := make([]map[string]interface{}, 0) 165 if listener.DefaultActions != nil && len(listener.DefaultActions) > 0 { 166 for _, defaultAction := range listener.DefaultActions { 167 action := map[string]interface{}{ 168 "target_group_arn": *defaultAction.TargetGroupArn, 169 "type": *defaultAction.Type, 170 } 171 defaultActions = append(defaultActions, action) 172 } 173 } 174 d.Set("default_action", defaultActions) 175 176 return nil 177 } 178 179 func resourceAwsAlbListenerUpdate(d *schema.ResourceData, meta interface{}) error { 180 elbconn := meta.(*AWSClient).elbv2conn 181 182 params := &elbv2.ModifyListenerInput{ 183 ListenerArn: aws.String(d.Id()), 184 Port: aws.Int64(int64(d.Get("port").(int))), 185 Protocol: aws.String(d.Get("protocol").(string)), 186 } 187 188 if sslPolicy, ok := d.GetOk("ssl_policy"); ok { 189 params.SslPolicy = aws.String(sslPolicy.(string)) 190 } 191 192 if certificateArn, ok := d.GetOk("certificate_arn"); ok { 193 params.Certificates = make([]*elbv2.Certificate, 1) 194 params.Certificates[0] = &elbv2.Certificate{ 195 CertificateArn: aws.String(certificateArn.(string)), 196 } 197 } 198 199 if defaultActions := d.Get("default_action").([]interface{}); len(defaultActions) == 1 { 200 params.DefaultActions = make([]*elbv2.Action, len(defaultActions)) 201 202 for i, defaultAction := range defaultActions { 203 defaultActionMap := defaultAction.(map[string]interface{}) 204 205 params.DefaultActions[i] = &elbv2.Action{ 206 TargetGroupArn: aws.String(defaultActionMap["target_group_arn"].(string)), 207 Type: aws.String(defaultActionMap["type"].(string)), 208 } 209 } 210 } 211 212 _, err := elbconn.ModifyListener(params) 213 if err != nil { 214 return errwrap.Wrapf("Error modifying ALB Listener: {{err}}", err) 215 } 216 217 return resourceAwsAlbListenerRead(d, meta) 218 } 219 220 func resourceAwsAlbListenerDelete(d *schema.ResourceData, meta interface{}) error { 221 elbconn := meta.(*AWSClient).elbv2conn 222 223 _, err := elbconn.DeleteListener(&elbv2.DeleteListenerInput{ 224 ListenerArn: aws.String(d.Id()), 225 }) 226 if err != nil { 227 return errwrap.Wrapf("Error deleting Listener: {{err}}", err) 228 } 229 230 return nil 231 } 232 233 func validateAwsAlbListenerPort(v interface{}, k string) (ws []string, errors []error) { 234 port := v.(int) 235 if port < 1 || port > 65536 { 236 errors = append(errors, fmt.Errorf("%q must be a valid port number (1-65536)", k)) 237 } 238 return 239 } 240 241 func validateAwsAlbListenerProtocol(v interface{}, k string) (ws []string, errors []error) { 242 value := strings.ToLower(v.(string)) 243 if value == "http" || value == "https" { 244 return 245 } 246 247 errors = append(errors, fmt.Errorf("%q must be either %q or %q", k, "HTTP", "HTTPS")) 248 return 249 } 250 251 func validateAwsAlbListenerActionType(v interface{}, k string) (ws []string, errors []error) { 252 value := strings.ToLower(v.(string)) 253 if value != "forward" { 254 errors = append(errors, fmt.Errorf("%q must have the value %q", k, "forward")) 255 } 256 return 257 } 258 259 func isListenerNotFound(err error) bool { 260 elberr, ok := err.(awserr.Error) 261 return ok && elberr.Code() == "ListenerNotFound" 262 }