github.com/gabrielperezs/terraform@v0.7.0-rc2.0.20160715084931-f7da2612946f/builtin/providers/aws/resource_aws_internet_gateway.go (about) 1 package aws 2 3 import ( 4 "fmt" 5 "log" 6 "time" 7 8 "github.com/aws/aws-sdk-go/aws" 9 "github.com/aws/aws-sdk-go/aws/awserr" 10 "github.com/aws/aws-sdk-go/service/ec2" 11 "github.com/hashicorp/terraform/helper/resource" 12 "github.com/hashicorp/terraform/helper/schema" 13 ) 14 15 func resourceAwsInternetGateway() *schema.Resource { 16 return &schema.Resource{ 17 Create: resourceAwsInternetGatewayCreate, 18 Read: resourceAwsInternetGatewayRead, 19 Update: resourceAwsInternetGatewayUpdate, 20 Delete: resourceAwsInternetGatewayDelete, 21 Importer: &schema.ResourceImporter{ 22 State: schema.ImportStatePassthrough, 23 }, 24 25 Schema: map[string]*schema.Schema{ 26 "vpc_id": &schema.Schema{ 27 Type: schema.TypeString, 28 Optional: true, 29 }, 30 "tags": tagsSchema(), 31 }, 32 } 33 } 34 35 func resourceAwsInternetGatewayCreate(d *schema.ResourceData, meta interface{}) error { 36 conn := meta.(*AWSClient).ec2conn 37 38 // Create the gateway 39 log.Printf("[DEBUG] Creating internet gateway") 40 var err error 41 resp, err := conn.CreateInternetGateway(nil) 42 if err != nil { 43 return fmt.Errorf("Error creating internet gateway: %s", err) 44 } 45 46 // Get the ID and store it 47 ig := *resp.InternetGateway 48 d.SetId(*ig.InternetGatewayId) 49 log.Printf("[INFO] InternetGateway ID: %s", d.Id()) 50 51 resource.Retry(5*time.Minute, func() *resource.RetryError { 52 igRaw, _, err := IGStateRefreshFunc(conn, d.Id())() 53 if igRaw != nil { 54 return nil 55 } 56 if err == nil { 57 return resource.RetryableError(err) 58 } else { 59 return resource.NonRetryableError(err) 60 } 61 }) 62 63 err = setTags(conn, d) 64 if err != nil { 65 return err 66 } 67 68 // Attach the new gateway to the correct vpc 69 return resourceAwsInternetGatewayAttach(d, meta) 70 } 71 72 func resourceAwsInternetGatewayRead(d *schema.ResourceData, meta interface{}) error { 73 conn := meta.(*AWSClient).ec2conn 74 75 igRaw, _, err := IGStateRefreshFunc(conn, d.Id())() 76 if err != nil { 77 return err 78 } 79 if igRaw == nil { 80 // Seems we have lost our internet gateway 81 d.SetId("") 82 return nil 83 } 84 85 ig := igRaw.(*ec2.InternetGateway) 86 if len(ig.Attachments) == 0 { 87 // Gateway exists but not attached to the VPC 88 d.Set("vpc_id", "") 89 } else { 90 d.Set("vpc_id", ig.Attachments[0].VpcId) 91 } 92 93 d.Set("tags", tagsToMap(ig.Tags)) 94 95 return nil 96 } 97 98 func resourceAwsInternetGatewayUpdate(d *schema.ResourceData, meta interface{}) error { 99 if d.HasChange("vpc_id") { 100 // If we're already attached, detach it first 101 if err := resourceAwsInternetGatewayDetach(d, meta); err != nil { 102 return err 103 } 104 105 // Attach the gateway to the new vpc 106 if err := resourceAwsInternetGatewayAttach(d, meta); err != nil { 107 return err 108 } 109 } 110 111 conn := meta.(*AWSClient).ec2conn 112 113 if err := setTags(conn, d); err != nil { 114 return err 115 } 116 117 d.SetPartial("tags") 118 119 return nil 120 } 121 122 func resourceAwsInternetGatewayDelete(d *schema.ResourceData, meta interface{}) error { 123 conn := meta.(*AWSClient).ec2conn 124 125 // Detach if it is attached 126 if err := resourceAwsInternetGatewayDetach(d, meta); err != nil { 127 return err 128 } 129 130 log.Printf("[INFO] Deleting Internet Gateway: %s", d.Id()) 131 132 return resource.Retry(5*time.Minute, func() *resource.RetryError { 133 _, err := conn.DeleteInternetGateway(&ec2.DeleteInternetGatewayInput{ 134 InternetGatewayId: aws.String(d.Id()), 135 }) 136 if err == nil { 137 return nil 138 } 139 140 ec2err, ok := err.(awserr.Error) 141 if !ok { 142 return resource.RetryableError(err) 143 } 144 145 switch ec2err.Code() { 146 case "InvalidInternetGatewayID.NotFound": 147 return nil 148 case "DependencyViolation": 149 return resource.RetryableError(err) // retry 150 } 151 152 return resource.NonRetryableError(err) 153 }) 154 } 155 156 func resourceAwsInternetGatewayAttach(d *schema.ResourceData, meta interface{}) error { 157 conn := meta.(*AWSClient).ec2conn 158 159 if d.Get("vpc_id").(string) == "" { 160 log.Printf( 161 "[DEBUG] Not attaching Internet Gateway '%s' as no VPC ID is set", 162 d.Id()) 163 return nil 164 } 165 166 log.Printf( 167 "[INFO] Attaching Internet Gateway '%s' to VPC '%s'", 168 d.Id(), 169 d.Get("vpc_id").(string)) 170 171 _, err := conn.AttachInternetGateway(&ec2.AttachInternetGatewayInput{ 172 InternetGatewayId: aws.String(d.Id()), 173 VpcId: aws.String(d.Get("vpc_id").(string)), 174 }) 175 if err != nil { 176 return err 177 } 178 179 // A note on the states below: the AWS docs (as of July, 2014) say 180 // that the states would be: attached, attaching, detached, detaching, 181 // but when running, I noticed that the state is usually "available" when 182 // it is attached. 183 184 // Wait for it to be fully attached before continuing 185 log.Printf("[DEBUG] Waiting for internet gateway (%s) to attach", d.Id()) 186 stateConf := &resource.StateChangeConf{ 187 Pending: []string{"detached", "attaching"}, 188 Target: []string{"available"}, 189 Refresh: IGAttachStateRefreshFunc(conn, d.Id(), "available"), 190 Timeout: 1 * time.Minute, 191 } 192 if _, err := stateConf.WaitForState(); err != nil { 193 return fmt.Errorf( 194 "Error waiting for internet gateway (%s) to attach: %s", 195 d.Id(), err) 196 } 197 198 return nil 199 } 200 201 func resourceAwsInternetGatewayDetach(d *schema.ResourceData, meta interface{}) error { 202 conn := meta.(*AWSClient).ec2conn 203 204 // Get the old VPC ID to detach from 205 vpcID, _ := d.GetChange("vpc_id") 206 207 if vpcID.(string) == "" { 208 log.Printf( 209 "[DEBUG] Not detaching Internet Gateway '%s' as no VPC ID is set", 210 d.Id()) 211 return nil 212 } 213 214 log.Printf( 215 "[INFO] Detaching Internet Gateway '%s' from VPC '%s'", 216 d.Id(), 217 vpcID.(string)) 218 219 // Wait for it to be fully detached before continuing 220 log.Printf("[DEBUG] Waiting for internet gateway (%s) to detach", d.Id()) 221 stateConf := &resource.StateChangeConf{ 222 Pending: []string{"detaching"}, 223 Target: []string{"detached"}, 224 Refresh: detachIGStateRefreshFunc(conn, d.Id(), vpcID.(string)), 225 Timeout: 15 * time.Minute, 226 Delay: 10 * time.Second, 227 NotFoundChecks: 30, 228 } 229 if _, err := stateConf.WaitForState(); err != nil { 230 return fmt.Errorf( 231 "Error waiting for internet gateway (%s) to detach: %s", 232 d.Id(), err) 233 } 234 235 return nil 236 } 237 238 // InstanceStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch 239 // an EC2 instance. 240 func detachIGStateRefreshFunc(conn *ec2.EC2, instanceID, vpcID string) resource.StateRefreshFunc { 241 return func() (interface{}, string, error) { 242 _, err := conn.DetachInternetGateway(&ec2.DetachInternetGatewayInput{ 243 InternetGatewayId: aws.String(instanceID), 244 VpcId: aws.String(vpcID), 245 }) 246 if err != nil { 247 ec2err, ok := err.(awserr.Error) 248 if ok { 249 if ec2err.Code() == "InvalidInternetGatewayID.NotFound" { 250 return nil, "Not Found", err 251 } else if ec2err.Code() == "Gateway.NotAttached" { 252 return "detached", "detached", nil 253 } else if ec2err.Code() == "DependencyViolation" { 254 return nil, "detaching", nil 255 } 256 } 257 } 258 // DetachInternetGateway only returns an error, so if it's nil, assume we're 259 // detached 260 return "detached", "detached", nil 261 } 262 } 263 264 // IGStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch 265 // an internet gateway. 266 func IGStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc { 267 return func() (interface{}, string, error) { 268 resp, err := conn.DescribeInternetGateways(&ec2.DescribeInternetGatewaysInput{ 269 InternetGatewayIds: []*string{aws.String(id)}, 270 }) 271 if err != nil { 272 ec2err, ok := err.(awserr.Error) 273 if ok && ec2err.Code() == "InvalidInternetGatewayID.NotFound" { 274 resp = nil 275 } else { 276 log.Printf("[ERROR] Error on IGStateRefresh: %s", err) 277 return nil, "", err 278 } 279 } 280 281 if resp == nil { 282 // Sometimes AWS just has consistency issues and doesn't see 283 // our instance yet. Return an empty state. 284 return nil, "", nil 285 } 286 287 ig := resp.InternetGateways[0] 288 return ig, "available", nil 289 } 290 } 291 292 // IGAttachStateRefreshFunc returns a resource.StateRefreshFunc that is used 293 // watch the state of an internet gateway's attachment. 294 func IGAttachStateRefreshFunc(conn *ec2.EC2, id string, expected string) resource.StateRefreshFunc { 295 var start time.Time 296 return func() (interface{}, string, error) { 297 if start.IsZero() { 298 start = time.Now() 299 } 300 301 resp, err := conn.DescribeInternetGateways(&ec2.DescribeInternetGatewaysInput{ 302 InternetGatewayIds: []*string{aws.String(id)}, 303 }) 304 if err != nil { 305 ec2err, ok := err.(awserr.Error) 306 if ok && ec2err.Code() == "InvalidInternetGatewayID.NotFound" { 307 resp = nil 308 } else { 309 log.Printf("[ERROR] Error on IGStateRefresh: %s", err) 310 return nil, "", err 311 } 312 } 313 314 if resp == nil { 315 // Sometimes AWS just has consistency issues and doesn't see 316 // our instance yet. Return an empty state. 317 return nil, "", nil 318 } 319 320 ig := resp.InternetGateways[0] 321 322 if time.Now().Sub(start) > 10*time.Second { 323 return ig, expected, nil 324 } 325 326 if len(ig.Attachments) == 0 { 327 // No attachments, we're detached 328 return ig, "detached", nil 329 } 330 331 return ig, *ig.Attachments[0].State, nil 332 } 333 }