github.com/anuaimi/terraform@v0.6.4-0.20150904235404-2bf9aec61da8/builtin/providers/aws/resource_aws_ecs_service.go (about) 1 package aws 2 3 import ( 4 "bytes" 5 "fmt" 6 "log" 7 "regexp" 8 "strings" 9 "time" 10 11 "github.com/aws/aws-sdk-go/aws" 12 "github.com/aws/aws-sdk-go/aws/awserr" 13 "github.com/aws/aws-sdk-go/service/ecs" 14 "github.com/hashicorp/terraform/helper/hashcode" 15 "github.com/hashicorp/terraform/helper/resource" 16 "github.com/hashicorp/terraform/helper/schema" 17 ) 18 19 var taskDefinitionRE = regexp.MustCompile("^([a-zA-Z0-9_-]+):([0-9]+)$") 20 21 func resourceAwsEcsService() *schema.Resource { 22 return &schema.Resource{ 23 Create: resourceAwsEcsServiceCreate, 24 Read: resourceAwsEcsServiceRead, 25 Update: resourceAwsEcsServiceUpdate, 26 Delete: resourceAwsEcsServiceDelete, 27 28 Schema: map[string]*schema.Schema{ 29 "name": &schema.Schema{ 30 Type: schema.TypeString, 31 Required: true, 32 ForceNew: true, 33 }, 34 35 "cluster": &schema.Schema{ 36 Type: schema.TypeString, 37 Optional: true, 38 Computed: true, 39 ForceNew: true, 40 }, 41 42 "task_definition": &schema.Schema{ 43 Type: schema.TypeString, 44 Required: true, 45 }, 46 47 "desired_count": &schema.Schema{ 48 Type: schema.TypeInt, 49 Optional: true, 50 }, 51 52 "iam_role": &schema.Schema{ 53 Type: schema.TypeString, 54 Optional: true, 55 }, 56 57 "load_balancer": &schema.Schema{ 58 Type: schema.TypeSet, 59 Optional: true, 60 Elem: &schema.Resource{ 61 Schema: map[string]*schema.Schema{ 62 "elb_name": &schema.Schema{ 63 Type: schema.TypeString, 64 Required: true, 65 }, 66 67 "container_name": &schema.Schema{ 68 Type: schema.TypeString, 69 Required: true, 70 }, 71 72 "container_port": &schema.Schema{ 73 Type: schema.TypeInt, 74 Required: true, 75 }, 76 }, 77 }, 78 Set: resourceAwsEcsLoadBalancerHash, 79 }, 80 }, 81 } 82 } 83 84 func resourceAwsEcsServiceCreate(d *schema.ResourceData, meta interface{}) error { 85 conn := meta.(*AWSClient).ecsconn 86 87 input := ecs.CreateServiceInput{ 88 ServiceName: aws.String(d.Get("name").(string)), 89 TaskDefinition: aws.String(d.Get("task_definition").(string)), 90 DesiredCount: aws.Int64(int64(d.Get("desired_count").(int))), 91 ClientToken: aws.String(resource.UniqueId()), 92 } 93 94 if v, ok := d.GetOk("cluster"); ok { 95 input.Cluster = aws.String(v.(string)) 96 } 97 98 loadBalancers := expandEcsLoadBalancers(d.Get("load_balancer").(*schema.Set).List()) 99 if len(loadBalancers) > 0 { 100 log.Printf("[DEBUG] Adding ECS load balancers: %s", loadBalancers) 101 input.LoadBalancers = loadBalancers 102 } 103 if v, ok := d.GetOk("iam_role"); ok { 104 input.Role = aws.String(v.(string)) 105 } 106 107 log.Printf("[DEBUG] Creating ECS service: %s", input) 108 109 // Retry due to AWS IAM policy eventual consistency 110 // See https://github.com/hashicorp/terraform/issues/2869 111 var out *ecs.CreateServiceOutput 112 var err error 113 err = resource.Retry(2*time.Minute, func() error { 114 out, err = conn.CreateService(&input) 115 116 if err != nil { 117 ec2err, ok := err.(awserr.Error) 118 if !ok { 119 return &resource.RetryError{Err: err} 120 } 121 if ec2err.Code() == "InvalidParameterException" { 122 log.Printf("[DEBUG] Trying to create ECS service again: %q", 123 ec2err.Message()) 124 return err 125 } 126 127 return &resource.RetryError{Err: err} 128 } 129 130 return nil 131 }) 132 if err != nil { 133 return err 134 } 135 136 service := *out.Service 137 138 log.Printf("[DEBUG] ECS service created: %s", *service.ServiceArn) 139 d.SetId(*service.ServiceArn) 140 d.Set("cluster", *service.ClusterArn) 141 142 return resourceAwsEcsServiceUpdate(d, meta) 143 } 144 145 func resourceAwsEcsServiceRead(d *schema.ResourceData, meta interface{}) error { 146 conn := meta.(*AWSClient).ecsconn 147 148 log.Printf("[DEBUG] Reading ECS service %s", d.Id()) 149 input := ecs.DescribeServicesInput{ 150 Services: []*string{aws.String(d.Id())}, 151 Cluster: aws.String(d.Get("cluster").(string)), 152 } 153 154 out, err := conn.DescribeServices(&input) 155 if err != nil { 156 return err 157 } 158 159 if len(out.Services) < 1 { 160 return nil 161 } 162 163 service := out.Services[0] 164 log.Printf("[DEBUG] Received ECS service %s", service) 165 166 d.SetId(*service.ServiceArn) 167 d.Set("name", *service.ServiceName) 168 169 // Save task definition in the same format 170 if strings.HasPrefix(d.Get("task_definition").(string), "arn:aws:ecs:") { 171 d.Set("task_definition", *service.TaskDefinition) 172 } else { 173 taskDefinition := buildFamilyAndRevisionFromARN(*service.TaskDefinition) 174 d.Set("task_definition", taskDefinition) 175 } 176 177 d.Set("desired_count", *service.DesiredCount) 178 d.Set("cluster", *service.ClusterArn) 179 180 // Save IAM role in the same format 181 if service.RoleArn != nil { 182 if strings.HasPrefix(d.Get("iam_role").(string), "arn:aws:iam:") { 183 d.Set("iam_role", *service.RoleArn) 184 } else { 185 roleARN := buildIamRoleNameFromARN(*service.RoleArn) 186 d.Set("iam_role", roleARN) 187 } 188 } 189 190 if service.LoadBalancers != nil { 191 d.Set("load_balancers", flattenEcsLoadBalancers(service.LoadBalancers)) 192 } 193 194 return nil 195 } 196 197 func resourceAwsEcsServiceUpdate(d *schema.ResourceData, meta interface{}) error { 198 conn := meta.(*AWSClient).ecsconn 199 200 log.Printf("[DEBUG] Updating ECS service %s", d.Id()) 201 input := ecs.UpdateServiceInput{ 202 Service: aws.String(d.Id()), 203 Cluster: aws.String(d.Get("cluster").(string)), 204 } 205 206 if d.HasChange("desired_count") { 207 _, n := d.GetChange("desired_count") 208 input.DesiredCount = aws.Int64(int64(n.(int))) 209 } 210 if d.HasChange("task_definition") { 211 _, n := d.GetChange("task_definition") 212 input.TaskDefinition = aws.String(n.(string)) 213 } 214 215 out, err := conn.UpdateService(&input) 216 if err != nil { 217 return err 218 } 219 service := out.Service 220 log.Printf("[DEBUG] Updated ECS service %s", service) 221 222 return resourceAwsEcsServiceRead(d, meta) 223 } 224 225 func resourceAwsEcsServiceDelete(d *schema.ResourceData, meta interface{}) error { 226 conn := meta.(*AWSClient).ecsconn 227 228 // Check if it's not already gone 229 resp, err := conn.DescribeServices(&ecs.DescribeServicesInput{ 230 Services: []*string{aws.String(d.Id())}, 231 Cluster: aws.String(d.Get("cluster").(string)), 232 }) 233 if err != nil { 234 return err 235 } 236 log.Printf("[DEBUG] ECS service %s is currently %s", d.Id(), *resp.Services[0].Status) 237 238 if *resp.Services[0].Status == "INACTIVE" { 239 return nil 240 } 241 242 // Drain the ECS service 243 if *resp.Services[0].Status != "DRAINING" { 244 log.Printf("[DEBUG] Draining ECS service %s", d.Id()) 245 _, err = conn.UpdateService(&ecs.UpdateServiceInput{ 246 Service: aws.String(d.Id()), 247 Cluster: aws.String(d.Get("cluster").(string)), 248 DesiredCount: aws.Int64(int64(0)), 249 }) 250 if err != nil { 251 return err 252 } 253 } 254 255 input := ecs.DeleteServiceInput{ 256 Service: aws.String(d.Id()), 257 Cluster: aws.String(d.Get("cluster").(string)), 258 } 259 260 log.Printf("[DEBUG] Deleting ECS service %s", input) 261 out, err := conn.DeleteService(&input) 262 if err != nil { 263 return err 264 } 265 266 // Wait until it's deleted 267 wait := resource.StateChangeConf{ 268 Pending: []string{"DRAINING"}, 269 Target: "INACTIVE", 270 Timeout: 5 * time.Minute, 271 MinTimeout: 1 * time.Second, 272 Refresh: func() (interface{}, string, error) { 273 log.Printf("[DEBUG] Checking if ECS service %s is INACTIVE", d.Id()) 274 resp, err := conn.DescribeServices(&ecs.DescribeServicesInput{ 275 Services: []*string{aws.String(d.Id())}, 276 Cluster: aws.String(d.Get("cluster").(string)), 277 }) 278 if err != nil { 279 return resp, "FAILED", err 280 } 281 282 return resp, *resp.Services[0].Status, nil 283 }, 284 } 285 286 _, err = wait.WaitForState() 287 if err != nil { 288 return err 289 } 290 291 log.Printf("[DEBUG] ECS service %s deleted.", *out.Service.ServiceArn) 292 return nil 293 } 294 295 func resourceAwsEcsLoadBalancerHash(v interface{}) int { 296 var buf bytes.Buffer 297 m := v.(map[string]interface{}) 298 buf.WriteString(fmt.Sprintf("%s-", m["elb_name"].(string))) 299 buf.WriteString(fmt.Sprintf("%s-", m["container_name"].(string))) 300 buf.WriteString(fmt.Sprintf("%d-", m["container_port"].(int))) 301 302 return hashcode.String(buf.String()) 303 } 304 305 func buildFamilyAndRevisionFromARN(arn string) string { 306 return strings.Split(arn, "/")[1] 307 } 308 309 func buildIamRoleNameFromARN(arn string) string { 310 // arn:aws:iam::0123456789:role/EcsService 311 return strings.Split(arn, "/")[1] 312 } 313 314 func parseTaskDefinition(taskDefinition string) (string, string, error) { 315 matches := taskDefinitionRE.FindAllStringSubmatch(taskDefinition, 2) 316 317 if len(matches) == 0 || len(matches[0]) != 3 { 318 return "", "", fmt.Errorf( 319 "Invalid task definition format, family:rev or ARN expected (%#v)", 320 taskDefinition) 321 } 322 323 return matches[0][1], matches[0][2], nil 324 }