github.com/ricardclau/terraform@v0.6.17-0.20160519222547-283e3ae6b5a9/builtin/providers/openstack/resource_openstack_compute_instance_v2.go (about) 1 package openstack 2 3 import ( 4 "bytes" 5 "crypto/sha1" 6 "encoding/hex" 7 "fmt" 8 "log" 9 "os" 10 "time" 11 12 "github.com/hashicorp/terraform/helper/hashcode" 13 "github.com/hashicorp/terraform/helper/resource" 14 "github.com/hashicorp/terraform/helper/schema" 15 "github.com/rackspace/gophercloud" 16 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/bootfromvolume" 17 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/floatingip" 18 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs" 19 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/schedulerhints" 20 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/secgroups" 21 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/tenantnetworks" 22 "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/volumeattach" 23 "github.com/rackspace/gophercloud/openstack/compute/v2/flavors" 24 "github.com/rackspace/gophercloud/openstack/compute/v2/images" 25 "github.com/rackspace/gophercloud/openstack/compute/v2/servers" 26 "github.com/rackspace/gophercloud/pagination" 27 ) 28 29 func resourceComputeInstanceV2() *schema.Resource { 30 return &schema.Resource{ 31 Create: resourceComputeInstanceV2Create, 32 Read: resourceComputeInstanceV2Read, 33 Update: resourceComputeInstanceV2Update, 34 Delete: resourceComputeInstanceV2Delete, 35 36 Schema: map[string]*schema.Schema{ 37 "region": &schema.Schema{ 38 Type: schema.TypeString, 39 Required: true, 40 ForceNew: true, 41 DefaultFunc: schema.EnvDefaultFunc("OS_REGION_NAME", ""), 42 }, 43 "name": &schema.Schema{ 44 Type: schema.TypeString, 45 Required: true, 46 ForceNew: false, 47 }, 48 "image_id": &schema.Schema{ 49 Type: schema.TypeString, 50 Optional: true, 51 ForceNew: true, 52 Computed: true, 53 }, 54 "image_name": &schema.Schema{ 55 Type: schema.TypeString, 56 Optional: true, 57 ForceNew: true, 58 Computed: true, 59 }, 60 "flavor_id": &schema.Schema{ 61 Type: schema.TypeString, 62 Optional: true, 63 ForceNew: false, 64 Computed: true, 65 DefaultFunc: schema.EnvDefaultFunc("OS_FLAVOR_ID", nil), 66 }, 67 "flavor_name": &schema.Schema{ 68 Type: schema.TypeString, 69 Optional: true, 70 ForceNew: false, 71 Computed: true, 72 DefaultFunc: schema.EnvDefaultFunc("OS_FLAVOR_NAME", nil), 73 }, 74 "floating_ip": &schema.Schema{ 75 Type: schema.TypeString, 76 Optional: true, 77 ForceNew: false, 78 }, 79 "user_data": &schema.Schema{ 80 Type: schema.TypeString, 81 Optional: true, 82 ForceNew: true, 83 // just stash the hash for state & diff comparisons 84 StateFunc: func(v interface{}) string { 85 switch v.(type) { 86 case string: 87 hash := sha1.Sum([]byte(v.(string))) 88 return hex.EncodeToString(hash[:]) 89 default: 90 return "" 91 } 92 }, 93 }, 94 "security_groups": &schema.Schema{ 95 Type: schema.TypeSet, 96 Optional: true, 97 ForceNew: false, 98 Computed: true, 99 Elem: &schema.Schema{Type: schema.TypeString}, 100 Set: schema.HashString, 101 }, 102 "availability_zone": &schema.Schema{ 103 Type: schema.TypeString, 104 Optional: true, 105 ForceNew: true, 106 }, 107 "network": &schema.Schema{ 108 Type: schema.TypeList, 109 Optional: true, 110 ForceNew: true, 111 Computed: true, 112 Elem: &schema.Resource{ 113 Schema: map[string]*schema.Schema{ 114 "uuid": &schema.Schema{ 115 Type: schema.TypeString, 116 Optional: true, 117 Computed: true, 118 }, 119 "name": &schema.Schema{ 120 Type: schema.TypeString, 121 Optional: true, 122 Computed: true, 123 }, 124 "port": &schema.Schema{ 125 Type: schema.TypeString, 126 Optional: true, 127 Computed: true, 128 }, 129 "fixed_ip_v4": &schema.Schema{ 130 Type: schema.TypeString, 131 Optional: true, 132 Computed: true, 133 }, 134 "fixed_ip_v6": &schema.Schema{ 135 Type: schema.TypeString, 136 Optional: true, 137 Computed: true, 138 }, 139 "floating_ip": &schema.Schema{ 140 Type: schema.TypeString, 141 Optional: true, 142 Computed: true, 143 }, 144 "mac": &schema.Schema{ 145 Type: schema.TypeString, 146 Computed: true, 147 }, 148 "access_network": &schema.Schema{ 149 Type: schema.TypeBool, 150 Optional: true, 151 Default: false, 152 }, 153 }, 154 }, 155 }, 156 "metadata": &schema.Schema{ 157 Type: schema.TypeMap, 158 Optional: true, 159 ForceNew: false, 160 }, 161 "config_drive": &schema.Schema{ 162 Type: schema.TypeBool, 163 Optional: true, 164 ForceNew: true, 165 }, 166 "admin_pass": &schema.Schema{ 167 Type: schema.TypeString, 168 Optional: true, 169 ForceNew: false, 170 }, 171 "access_ip_v4": &schema.Schema{ 172 Type: schema.TypeString, 173 Computed: true, 174 Optional: true, 175 ForceNew: false, 176 }, 177 "access_ip_v6": &schema.Schema{ 178 Type: schema.TypeString, 179 Computed: true, 180 Optional: true, 181 ForceNew: false, 182 }, 183 "key_pair": &schema.Schema{ 184 Type: schema.TypeString, 185 Optional: true, 186 ForceNew: true, 187 }, 188 "block_device": &schema.Schema{ 189 Type: schema.TypeList, 190 Optional: true, 191 ForceNew: true, 192 Elem: &schema.Resource{ 193 Schema: map[string]*schema.Schema{ 194 "source_type": &schema.Schema{ 195 Type: schema.TypeString, 196 Required: true, 197 }, 198 "uuid": &schema.Schema{ 199 Type: schema.TypeString, 200 Optional: true, 201 }, 202 "volume_size": &schema.Schema{ 203 Type: schema.TypeInt, 204 Optional: true, 205 }, 206 "destination_type": &schema.Schema{ 207 Type: schema.TypeString, 208 Optional: true, 209 }, 210 "boot_index": &schema.Schema{ 211 Type: schema.TypeInt, 212 Optional: true, 213 }, 214 "delete_on_termination": &schema.Schema{ 215 Type: schema.TypeBool, 216 Optional: true, 217 Default: false, 218 }, 219 "guest_format": &schema.Schema{ 220 Type: schema.TypeString, 221 Optional: true, 222 }, 223 }, 224 }, 225 }, 226 "volume": &schema.Schema{ 227 Type: schema.TypeSet, 228 Optional: true, 229 Computed: true, 230 Elem: &schema.Resource{ 231 Schema: map[string]*schema.Schema{ 232 "id": &schema.Schema{ 233 Type: schema.TypeString, 234 Computed: true, 235 }, 236 "volume_id": &schema.Schema{ 237 Type: schema.TypeString, 238 Optional: true, 239 Computed: true, 240 }, 241 "device": &schema.Schema{ 242 Type: schema.TypeString, 243 Optional: true, 244 Computed: true, 245 }, 246 }, 247 }, 248 Set: resourceComputeVolumeAttachmentHash, 249 }, 250 "scheduler_hints": &schema.Schema{ 251 Type: schema.TypeSet, 252 Optional: true, 253 Elem: &schema.Resource{ 254 Schema: map[string]*schema.Schema{ 255 "group": &schema.Schema{ 256 Type: schema.TypeString, 257 Optional: true, 258 ForceNew: true, 259 }, 260 "different_host": &schema.Schema{ 261 Type: schema.TypeList, 262 Optional: true, 263 ForceNew: true, 264 Elem: &schema.Schema{Type: schema.TypeString}, 265 }, 266 "same_host": &schema.Schema{ 267 Type: schema.TypeList, 268 Optional: true, 269 ForceNew: true, 270 Elem: &schema.Schema{Type: schema.TypeString}, 271 }, 272 "query": &schema.Schema{ 273 Type: schema.TypeList, 274 Optional: true, 275 ForceNew: true, 276 Elem: &schema.Schema{Type: schema.TypeString}, 277 }, 278 "target_cell": &schema.Schema{ 279 Type: schema.TypeString, 280 Optional: true, 281 ForceNew: true, 282 }, 283 "build_near_host_ip": &schema.Schema{ 284 Type: schema.TypeString, 285 Optional: true, 286 ForceNew: true, 287 }, 288 }, 289 }, 290 Set: resourceComputeSchedulerHintsHash, 291 }, 292 "personality": &schema.Schema{ 293 Type: schema.TypeSet, 294 Optional: true, 295 ForceNew: true, 296 Elem: &schema.Resource{ 297 Schema: map[string]*schema.Schema{ 298 "file": &schema.Schema{ 299 Type: schema.TypeString, 300 Required: true, 301 }, 302 "content": &schema.Schema{ 303 Type: schema.TypeString, 304 Required: true, 305 }, 306 }, 307 }, 308 Set: resourceComputeInstancePersonalityHash, 309 }, 310 }, 311 } 312 } 313 314 func resourceComputeInstanceV2Create(d *schema.ResourceData, meta interface{}) error { 315 config := meta.(*Config) 316 computeClient, err := config.computeV2Client(d.Get("region").(string)) 317 if err != nil { 318 return fmt.Errorf("Error creating OpenStack compute client: %s", err) 319 } 320 321 var createOpts servers.CreateOptsBuilder 322 323 // Determines the Image ID using the following rules: 324 // If a bootable block_device was specified, ignore the image altogether. 325 // If an image_id was specified, use it. 326 // If an image_name was specified, look up the image ID, report if error. 327 imageId, err := getImageIDFromConfig(computeClient, d) 328 if err != nil { 329 return err 330 } 331 332 flavorId, err := getFlavorID(computeClient, d) 333 if err != nil { 334 return err 335 } 336 337 // determine if volume configuration is correct 338 // this includes ensuring volume_ids are set 339 if err := checkVolumeConfig(d); err != nil { 340 return err 341 } 342 343 // determine if block_device configuration is correct 344 // this includes valid combinations and required attributes 345 if err := checkBlockDeviceConfig(d); err != nil { 346 return err 347 } 348 349 // check if floating IP configuration is correct 350 if err := checkInstanceFloatingIPs(d); err != nil { 351 return err 352 } 353 354 // Build a list of networks with the information given upon creation. 355 // Error out if an invalid network configuration was used. 356 networkDetails, err := getInstanceNetworks(computeClient, d) 357 if err != nil { 358 return err 359 } 360 361 networks := make([]servers.Network, len(networkDetails)) 362 for i, net := range networkDetails { 363 networks[i] = servers.Network{ 364 UUID: net["uuid"].(string), 365 Port: net["port"].(string), 366 FixedIP: net["fixed_ip_v4"].(string), 367 } 368 } 369 370 createOpts = &servers.CreateOpts{ 371 Name: d.Get("name").(string), 372 ImageRef: imageId, 373 FlavorRef: flavorId, 374 SecurityGroups: resourceInstanceSecGroupsV2(d), 375 AvailabilityZone: d.Get("availability_zone").(string), 376 Networks: networks, 377 Metadata: resourceInstanceMetadataV2(d), 378 ConfigDrive: d.Get("config_drive").(bool), 379 AdminPass: d.Get("admin_pass").(string), 380 UserData: []byte(d.Get("user_data").(string)), 381 Personality: resourceInstancePersonalityV2(d), 382 } 383 384 if keyName, ok := d.Get("key_pair").(string); ok && keyName != "" { 385 createOpts = &keypairs.CreateOptsExt{ 386 CreateOptsBuilder: createOpts, 387 KeyName: keyName, 388 } 389 } 390 391 if vL, ok := d.GetOk("block_device"); ok { 392 blockDevices := resourceInstanceBlockDevicesV2(d, vL.([]interface{})) 393 createOpts = &bootfromvolume.CreateOptsExt{ 394 CreateOptsBuilder: createOpts, 395 BlockDevice: blockDevices, 396 } 397 } 398 399 schedulerHintsRaw := d.Get("scheduler_hints").(*schema.Set).List() 400 if len(schedulerHintsRaw) > 0 { 401 log.Printf("[DEBUG] schedulerhints: %+v", schedulerHintsRaw) 402 schedulerHints := resourceInstanceSchedulerHintsV2(d, schedulerHintsRaw[0].(map[string]interface{})) 403 createOpts = &schedulerhints.CreateOptsExt{ 404 CreateOptsBuilder: createOpts, 405 SchedulerHints: schedulerHints, 406 } 407 } 408 409 log.Printf("[DEBUG] Create Options: %#v", createOpts) 410 411 // If a block_device is used, use the bootfromvolume.Create function as it allows an empty ImageRef. 412 // Otherwise, use the normal servers.Create function. 413 var server *servers.Server 414 if _, ok := d.GetOk("block_device"); ok { 415 server, err = bootfromvolume.Create(computeClient, createOpts).Extract() 416 } else { 417 server, err = servers.Create(computeClient, createOpts).Extract() 418 } 419 420 if err != nil { 421 return fmt.Errorf("Error creating OpenStack server: %s", err) 422 } 423 log.Printf("[INFO] Instance ID: %s", server.ID) 424 425 // Store the ID now 426 d.SetId(server.ID) 427 428 // Wait for the instance to become running so we can get some attributes 429 // that aren't available until later. 430 log.Printf( 431 "[DEBUG] Waiting for instance (%s) to become running", 432 server.ID) 433 434 stateConf := &resource.StateChangeConf{ 435 Pending: []string{"BUILD"}, 436 Target: []string{"ACTIVE"}, 437 Refresh: ServerV2StateRefreshFunc(computeClient, server.ID), 438 Timeout: 30 * time.Minute, 439 Delay: 10 * time.Second, 440 MinTimeout: 3 * time.Second, 441 } 442 443 _, err = stateConf.WaitForState() 444 if err != nil { 445 return fmt.Errorf( 446 "Error waiting for instance (%s) to become ready: %s", 447 server.ID, err) 448 } 449 450 // Now that the instance has been created, we need to do an early read on the 451 // networks in order to associate floating IPs 452 _, err = getInstanceNetworksAndAddresses(computeClient, d) 453 454 // If floating IPs were specified, associate them after the instance has launched. 455 err = associateFloatingIPsToInstance(computeClient, d) 456 if err != nil { 457 return err 458 } 459 460 // if volumes were specified, attach them after the instance has launched. 461 if v, ok := d.GetOk("volume"); ok { 462 vols := v.(*schema.Set).List() 463 if blockClient, err := config.blockStorageV1Client(d.Get("region").(string)); err != nil { 464 return fmt.Errorf("Error creating OpenStack block storage client: %s", err) 465 } else { 466 if err := attachVolumesToInstance(computeClient, blockClient, d.Id(), vols); err != nil { 467 return err 468 } 469 } 470 } 471 472 return resourceComputeInstanceV2Read(d, meta) 473 } 474 475 func resourceComputeInstanceV2Read(d *schema.ResourceData, meta interface{}) error { 476 config := meta.(*Config) 477 computeClient, err := config.computeV2Client(d.Get("region").(string)) 478 if err != nil { 479 return fmt.Errorf("Error creating OpenStack compute client: %s", err) 480 } 481 482 server, err := servers.Get(computeClient, d.Id()).Extract() 483 if err != nil { 484 return CheckDeleted(d, err, "server") 485 } 486 487 log.Printf("[DEBUG] Retreived Server %s: %+v", d.Id(), server) 488 489 d.Set("name", server.Name) 490 491 // Get the instance network and address information 492 networks, err := getInstanceNetworksAndAddresses(computeClient, d) 493 if err != nil { 494 return err 495 } 496 497 // Determine the best IPv4 and IPv6 addresses to access the instance with 498 hostv4, hostv6 := getInstanceAccessAddresses(d, networks) 499 500 if server.AccessIPv4 != "" && hostv4 == "" { 501 hostv4 = server.AccessIPv4 502 } 503 504 if server.AccessIPv6 != "" && hostv6 == "" { 505 hostv6 = server.AccessIPv6 506 } 507 508 d.Set("network", networks) 509 d.Set("access_ip_v4", hostv4) 510 d.Set("access_ip_v6", hostv6) 511 512 // Determine the best IP address to use for SSH connectivity. 513 // Prefer IPv4 over IPv6. 514 preferredSSHAddress := "" 515 if hostv4 != "" { 516 preferredSSHAddress = hostv4 517 } else if hostv6 != "" { 518 preferredSSHAddress = hostv6 519 } 520 521 if preferredSSHAddress != "" { 522 // Initialize the connection info 523 d.SetConnInfo(map[string]string{ 524 "type": "ssh", 525 "host": preferredSSHAddress, 526 }) 527 } 528 529 d.Set("metadata", server.Metadata) 530 531 secGrpNames := []string{} 532 for _, sg := range server.SecurityGroups { 533 secGrpNames = append(secGrpNames, sg["name"].(string)) 534 } 535 d.Set("security_groups", secGrpNames) 536 537 flavorId, ok := server.Flavor["id"].(string) 538 if !ok { 539 return fmt.Errorf("Error setting OpenStack server's flavor: %v", server.Flavor) 540 } 541 d.Set("flavor_id", flavorId) 542 543 flavor, err := flavors.Get(computeClient, flavorId).Extract() 544 if err != nil { 545 return err 546 } 547 d.Set("flavor_name", flavor.Name) 548 549 // Set the instance's image information appropriately 550 if err := setImageInformation(computeClient, server, d); err != nil { 551 return err 552 } 553 554 // volume attachments 555 if err := getVolumeAttachments(computeClient, d); err != nil { 556 return err 557 } 558 559 return nil 560 } 561 562 func resourceComputeInstanceV2Update(d *schema.ResourceData, meta interface{}) error { 563 config := meta.(*Config) 564 computeClient, err := config.computeV2Client(d.Get("region").(string)) 565 if err != nil { 566 return fmt.Errorf("Error creating OpenStack compute client: %s", err) 567 } 568 569 var updateOpts servers.UpdateOpts 570 if d.HasChange("name") { 571 updateOpts.Name = d.Get("name").(string) 572 } 573 574 if updateOpts != (servers.UpdateOpts{}) { 575 _, err := servers.Update(computeClient, d.Id(), updateOpts).Extract() 576 if err != nil { 577 return fmt.Errorf("Error updating OpenStack server: %s", err) 578 } 579 } 580 581 if d.HasChange("metadata") { 582 var metadataOpts servers.MetadataOpts 583 metadataOpts = make(servers.MetadataOpts) 584 newMetadata := d.Get("metadata").(map[string]interface{}) 585 for k, v := range newMetadata { 586 metadataOpts[k] = v.(string) 587 } 588 589 _, err := servers.UpdateMetadata(computeClient, d.Id(), metadataOpts).Extract() 590 if err != nil { 591 return fmt.Errorf("Error updating OpenStack server (%s) metadata: %s", d.Id(), err) 592 } 593 } 594 595 if d.HasChange("security_groups") { 596 oldSGRaw, newSGRaw := d.GetChange("security_groups") 597 oldSGSet := oldSGRaw.(*schema.Set) 598 newSGSet := newSGRaw.(*schema.Set) 599 secgroupsToAdd := newSGSet.Difference(oldSGSet) 600 secgroupsToRemove := oldSGSet.Difference(newSGSet) 601 602 log.Printf("[DEBUG] Security groups to add: %v", secgroupsToAdd) 603 604 log.Printf("[DEBUG] Security groups to remove: %v", secgroupsToRemove) 605 606 for _, g := range secgroupsToRemove.List() { 607 err := secgroups.RemoveServerFromGroup(computeClient, d.Id(), g.(string)).ExtractErr() 608 if err != nil { 609 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 610 if !ok { 611 return fmt.Errorf("Error removing security group from OpenStack server (%s): %s", d.Id(), err) 612 } 613 if errCode.Actual == 404 { 614 continue 615 } else { 616 return fmt.Errorf("Error removing security group from OpenStack server (%s): %s", d.Id(), err) 617 } 618 } else { 619 log.Printf("[DEBUG] Removed security group (%s) from instance (%s)", g.(string), d.Id()) 620 } 621 } 622 for _, g := range secgroupsToAdd.List() { 623 err := secgroups.AddServerToGroup(computeClient, d.Id(), g.(string)).ExtractErr() 624 if err != nil { 625 return fmt.Errorf("Error adding security group to OpenStack server (%s): %s", d.Id(), err) 626 } 627 log.Printf("[DEBUG] Added security group (%s) to instance (%s)", g.(string), d.Id()) 628 } 629 630 } 631 632 if d.HasChange("admin_pass") { 633 if newPwd, ok := d.Get("admin_pass").(string); ok { 634 err := servers.ChangeAdminPassword(computeClient, d.Id(), newPwd).ExtractErr() 635 if err != nil { 636 return fmt.Errorf("Error changing admin password of OpenStack server (%s): %s", d.Id(), err) 637 } 638 } 639 } 640 641 if d.HasChange("floating_ip") { 642 oldFIP, newFIP := d.GetChange("floating_ip") 643 log.Printf("[DEBUG] Old Floating IP: %v", oldFIP) 644 log.Printf("[DEBUG] New Floating IP: %v", newFIP) 645 if oldFIP.(string) != "" { 646 log.Printf("[DEBUG] Attempting to disassociate %s from %s", oldFIP, d.Id()) 647 if err := disassociateFloatingIPFromInstance(computeClient, oldFIP.(string), d.Id(), ""); err != nil { 648 return fmt.Errorf("Error disassociating Floating IP during update: %s", err) 649 } 650 } 651 652 if newFIP.(string) != "" { 653 log.Printf("[DEBUG] Attempting to associate %s to %s", newFIP, d.Id()) 654 if err := associateFloatingIPToInstance(computeClient, newFIP.(string), d.Id(), ""); err != nil { 655 return fmt.Errorf("Error associating Floating IP during update: %s", err) 656 } 657 } 658 } 659 660 if d.HasChange("network") { 661 oldNetworks, newNetworks := d.GetChange("network") 662 oldNetworkList := oldNetworks.([]interface{}) 663 newNetworkList := newNetworks.([]interface{}) 664 for i, oldNet := range oldNetworkList { 665 var oldFIP, newFIP string 666 var oldFixedIP, newFixedIP string 667 668 if oldNetRaw, ok := oldNet.(map[string]interface{}); ok { 669 oldFIP = oldNetRaw["floating_ip"].(string) 670 oldFixedIP = oldNetRaw["fixed_ip_v4"].(string) 671 } 672 673 if len(newNetworkList) > i { 674 if newNetRaw, ok := newNetworkList[i].(map[string]interface{}); ok { 675 newFIP = newNetRaw["floating_ip"].(string) 676 newFixedIP = newNetRaw["fixed_ip_v4"].(string) 677 } 678 } 679 680 // Only changes to the floating IP are supported 681 if oldFIP != "" && oldFIP != newFIP { 682 log.Printf("[DEBUG] Attempting to disassociate %s from %s", oldFIP, d.Id()) 683 if err := disassociateFloatingIPFromInstance(computeClient, oldFIP, d.Id(), oldFixedIP); err != nil { 684 return fmt.Errorf("Error disassociating Floating IP during update: %s", err) 685 } 686 } 687 688 if newFIP != "" && oldFIP != newFIP { 689 log.Printf("[DEBUG] Attempting to associate %s to %s", newFIP, d.Id()) 690 if err := associateFloatingIPToInstance(computeClient, newFIP, d.Id(), newFixedIP); err != nil { 691 return fmt.Errorf("Error associating Floating IP during update: %s", err) 692 } 693 } 694 } 695 } 696 697 if d.HasChange("volume") { 698 // ensure the volume configuration is correct 699 if err := checkVolumeConfig(d); err != nil { 700 return err 701 } 702 703 // old attachments and new attachments 704 oldAttachments, newAttachments := d.GetChange("volume") 705 // for each old attachment, detach the volume 706 oldAttachmentSet := oldAttachments.(*schema.Set).List() 707 708 if blockClient, err := config.blockStorageV1Client(d.Get("region").(string)); err != nil { 709 return err 710 } else { 711 if err := detachVolumesFromInstance(computeClient, blockClient, d.Id(), oldAttachmentSet); err != nil { 712 return err 713 } 714 } 715 716 // for each new attachment, attach the volume 717 newAttachmentSet := newAttachments.(*schema.Set).List() 718 if blockClient, err := config.blockStorageV1Client(d.Get("region").(string)); err != nil { 719 return err 720 } else { 721 if err := attachVolumesToInstance(computeClient, blockClient, d.Id(), newAttachmentSet); err != nil { 722 return err 723 } 724 } 725 726 d.SetPartial("volume") 727 } 728 729 if d.HasChange("flavor_id") || d.HasChange("flavor_name") { 730 var newFlavorId string 731 var err error 732 if d.HasChange("flavor_id") { 733 newFlavorId = d.Get("flavor_id").(string) 734 } else { 735 newFlavorName := d.Get("flavor_name").(string) 736 newFlavorId, err = flavors.IDFromName(computeClient, newFlavorName) 737 if err != nil { 738 return err 739 } 740 } 741 742 resizeOpts := &servers.ResizeOpts{ 743 FlavorRef: newFlavorId, 744 } 745 log.Printf("[DEBUG] Resize configuration: %#v", resizeOpts) 746 err = servers.Resize(computeClient, d.Id(), resizeOpts).ExtractErr() 747 if err != nil { 748 return fmt.Errorf("Error resizing OpenStack server: %s", err) 749 } 750 751 // Wait for the instance to finish resizing. 752 log.Printf("[DEBUG] Waiting for instance (%s) to finish resizing", d.Id()) 753 754 stateConf := &resource.StateChangeConf{ 755 Pending: []string{"RESIZE"}, 756 Target: []string{"VERIFY_RESIZE"}, 757 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 758 Timeout: 30 * time.Minute, 759 Delay: 10 * time.Second, 760 MinTimeout: 3 * time.Second, 761 } 762 763 _, err = stateConf.WaitForState() 764 if err != nil { 765 return fmt.Errorf("Error waiting for instance (%s) to resize: %s", d.Id(), err) 766 } 767 768 // Confirm resize. 769 log.Printf("[DEBUG] Confirming resize") 770 err = servers.ConfirmResize(computeClient, d.Id()).ExtractErr() 771 if err != nil { 772 return fmt.Errorf("Error confirming resize of OpenStack server: %s", err) 773 } 774 775 stateConf = &resource.StateChangeConf{ 776 Pending: []string{"VERIFY_RESIZE"}, 777 Target: []string{"ACTIVE"}, 778 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 779 Timeout: 30 * time.Minute, 780 Delay: 10 * time.Second, 781 MinTimeout: 3 * time.Second, 782 } 783 784 _, err = stateConf.WaitForState() 785 if err != nil { 786 return fmt.Errorf("Error waiting for instance (%s) to confirm resize: %s", d.Id(), err) 787 } 788 } 789 790 return resourceComputeInstanceV2Read(d, meta) 791 } 792 793 func resourceComputeInstanceV2Delete(d *schema.ResourceData, meta interface{}) error { 794 config := meta.(*Config) 795 computeClient, err := config.computeV2Client(d.Get("region").(string)) 796 if err != nil { 797 return fmt.Errorf("Error creating OpenStack compute client: %s", err) 798 } 799 800 err = servers.Delete(computeClient, d.Id()).ExtractErr() 801 if err != nil { 802 return fmt.Errorf("Error deleting OpenStack server: %s", err) 803 } 804 805 // Wait for the instance to delete before moving on. 806 log.Printf("[DEBUG] Waiting for instance (%s) to delete", d.Id()) 807 808 stateConf := &resource.StateChangeConf{ 809 Pending: []string{"ACTIVE"}, 810 Target: []string{"DELETED"}, 811 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 812 Timeout: 30 * time.Minute, 813 Delay: 10 * time.Second, 814 MinTimeout: 3 * time.Second, 815 } 816 817 _, err = stateConf.WaitForState() 818 if err != nil { 819 return fmt.Errorf( 820 "Error waiting for instance (%s) to delete: %s", 821 d.Id(), err) 822 } 823 824 d.SetId("") 825 return nil 826 } 827 828 // ServerV2StateRefreshFunc returns a resource.StateRefreshFunc that is used to watch 829 // an OpenStack instance. 830 func ServerV2StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc { 831 return func() (interface{}, string, error) { 832 s, err := servers.Get(client, instanceID).Extract() 833 if err != nil { 834 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 835 if !ok { 836 return nil, "", err 837 } 838 if errCode.Actual == 404 { 839 return s, "DELETED", nil 840 } 841 return nil, "", err 842 } 843 844 return s, s.Status, nil 845 } 846 } 847 848 func resourceInstanceSecGroupsV2(d *schema.ResourceData) []string { 849 rawSecGroups := d.Get("security_groups").(*schema.Set).List() 850 secgroups := make([]string, len(rawSecGroups)) 851 for i, raw := range rawSecGroups { 852 secgroups[i] = raw.(string) 853 } 854 return secgroups 855 } 856 857 // getInstanceNetworks collects instance network information from different sources 858 // and aggregates it all together. 859 func getInstanceNetworksAndAddresses(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) ([]map[string]interface{}, error) { 860 server, err := servers.Get(computeClient, d.Id()).Extract() 861 862 if err != nil { 863 return nil, CheckDeleted(d, err, "server") 864 } 865 866 networkDetails, err := getInstanceNetworks(computeClient, d) 867 addresses := getInstanceAddresses(server.Addresses) 868 if err != nil { 869 return nil, err 870 } 871 872 // if there are no networkDetails, make networks at least a length of 1 873 networkLength := 1 874 if len(networkDetails) > 0 { 875 networkLength = len(networkDetails) 876 } 877 networks := make([]map[string]interface{}, networkLength) 878 879 // Loop through all networks and addresses, 880 // merge relevant address details. 881 if len(networkDetails) == 0 { 882 for netName, n := range addresses { 883 networks[0] = map[string]interface{}{ 884 "name": netName, 885 "fixed_ip_v4": n["fixed_ip_v4"], 886 "fixed_ip_v6": n["fixed_ip_v6"], 887 "floating_ip": n["floating_ip"], 888 "mac": n["mac"], 889 } 890 } 891 } else { 892 for i, net := range networkDetails { 893 n := addresses[net["name"].(string)] 894 895 networks[i] = map[string]interface{}{ 896 "uuid": networkDetails[i]["uuid"], 897 "name": networkDetails[i]["name"], 898 "port": networkDetails[i]["port"], 899 "fixed_ip_v4": n["fixed_ip_v4"], 900 "fixed_ip_v6": n["fixed_ip_v6"], 901 "floating_ip": n["floating_ip"], 902 "mac": n["mac"], 903 "access_network": networkDetails[i]["access_network"], 904 } 905 } 906 } 907 908 log.Printf("[DEBUG] networks: %+v", networks) 909 910 return networks, nil 911 } 912 913 func getInstanceNetworks(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) ([]map[string]interface{}, error) { 914 rawNetworks := d.Get("network").([]interface{}) 915 newNetworks := make([]map[string]interface{}, 0, len(rawNetworks)) 916 var tenantnet tenantnetworks.Network 917 918 tenantNetworkExt := true 919 for _, raw := range rawNetworks { 920 // Not sure what causes this, but it is a possibility (see GH-2323). 921 // Since we call this function to reconcile what we'll save in the 922 // state anyways, we just ignore it. 923 if raw == nil { 924 continue 925 } 926 927 rawMap := raw.(map[string]interface{}) 928 929 allPages, err := tenantnetworks.List(computeClient).AllPages() 930 if err != nil { 931 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 932 if !ok { 933 return nil, err 934 } 935 936 if errCode.Actual == 404 || errCode.Actual == 403 { 937 tenantNetworkExt = false 938 } else { 939 return nil, err 940 } 941 } 942 943 networkID := "" 944 networkName := "" 945 if tenantNetworkExt { 946 networkList, err := tenantnetworks.ExtractNetworks(allPages) 947 if err != nil { 948 return nil, err 949 } 950 951 for _, network := range networkList { 952 if network.Name == rawMap["name"] { 953 tenantnet = network 954 } 955 if network.ID == rawMap["uuid"] { 956 tenantnet = network 957 } 958 } 959 960 networkID = tenantnet.ID 961 networkName = tenantnet.Name 962 } else { 963 networkID = rawMap["uuid"].(string) 964 networkName = rawMap["name"].(string) 965 } 966 967 newNetworks = append(newNetworks, map[string]interface{}{ 968 "uuid": networkID, 969 "name": networkName, 970 "port": rawMap["port"].(string), 971 "fixed_ip_v4": rawMap["fixed_ip_v4"].(string), 972 "access_network": rawMap["access_network"].(bool), 973 }) 974 } 975 976 log.Printf("[DEBUG] networks: %+v", newNetworks) 977 return newNetworks, nil 978 } 979 980 func getInstanceAddresses(addresses map[string]interface{}) map[string]map[string]interface{} { 981 addrs := make(map[string]map[string]interface{}) 982 for n, networkAddresses := range addresses { 983 addrs[n] = make(map[string]interface{}) 984 for _, element := range networkAddresses.([]interface{}) { 985 address := element.(map[string]interface{}) 986 if address["OS-EXT-IPS:type"] == "floating" { 987 addrs[n]["floating_ip"] = address["addr"] 988 } else { 989 if address["version"].(float64) == 4 { 990 addrs[n]["fixed_ip_v4"] = address["addr"].(string) 991 } else { 992 addrs[n]["fixed_ip_v6"] = fmt.Sprintf("[%s]", address["addr"].(string)) 993 } 994 } 995 if mac, ok := address["OS-EXT-IPS-MAC:mac_addr"]; ok { 996 addrs[n]["mac"] = mac.(string) 997 } 998 } 999 } 1000 1001 log.Printf("[DEBUG] Addresses: %+v", addresses) 1002 1003 return addrs 1004 } 1005 1006 func getInstanceAccessAddresses(d *schema.ResourceData, networks []map[string]interface{}) (string, string) { 1007 var hostv4, hostv6 string 1008 1009 // Start with a global floating IP 1010 floatingIP := d.Get("floating_ip").(string) 1011 if floatingIP != "" { 1012 hostv4 = floatingIP 1013 } 1014 1015 // Loop through all networks 1016 // If the network has a valid floating, fixed v4, or fixed v6 address 1017 // and hostv4 or hostv6 is not set, set hostv4/hostv6. 1018 // If the network is an "access_network" overwrite hostv4/hostv6. 1019 for _, n := range networks { 1020 var accessNetwork bool 1021 1022 if an, ok := n["access_network"].(bool); ok && an { 1023 accessNetwork = true 1024 } 1025 1026 if fixedIPv4, ok := n["fixed_ip_v4"].(string); ok && fixedIPv4 != "" { 1027 if hostv4 == "" || accessNetwork { 1028 hostv4 = fixedIPv4 1029 } 1030 } 1031 1032 if floatingIP, ok := n["floating_ip"].(string); ok && floatingIP != "" { 1033 if hostv4 == "" || accessNetwork { 1034 hostv4 = floatingIP 1035 } 1036 } 1037 1038 if fixedIPv6, ok := n["fixed_ip_v6"].(string); ok && fixedIPv6 != "" { 1039 if hostv6 == "" || accessNetwork { 1040 hostv6 = fixedIPv6 1041 } 1042 } 1043 } 1044 1045 log.Printf("[DEBUG] OpenStack Instance Network Access Addresses: %s, %s", hostv4, hostv6) 1046 1047 return hostv4, hostv6 1048 } 1049 1050 func checkInstanceFloatingIPs(d *schema.ResourceData) error { 1051 rawNetworks := d.Get("network").([]interface{}) 1052 floatingIP := d.Get("floating_ip").(string) 1053 1054 for _, raw := range rawNetworks { 1055 if raw == nil { 1056 continue 1057 } 1058 1059 rawMap := raw.(map[string]interface{}) 1060 1061 // Error if a floating IP was specified both globally and in the network block. 1062 if floatingIP != "" && rawMap["floating_ip"] != "" { 1063 return fmt.Errorf("Cannot specify a floating IP both globally and in a network block.") 1064 } 1065 } 1066 return nil 1067 } 1068 1069 func associateFloatingIPsToInstance(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) error { 1070 floatingIP := d.Get("floating_ip").(string) 1071 rawNetworks := d.Get("network").([]interface{}) 1072 instanceID := d.Id() 1073 1074 if floatingIP != "" { 1075 if err := associateFloatingIPToInstance(computeClient, floatingIP, instanceID, ""); err != nil { 1076 return err 1077 } 1078 } else { 1079 for _, raw := range rawNetworks { 1080 if raw == nil { 1081 continue 1082 } 1083 1084 rawMap := raw.(map[string]interface{}) 1085 if rawMap["floating_ip"].(string) != "" { 1086 floatingIP := rawMap["floating_ip"].(string) 1087 fixedIP := rawMap["fixed_ip_v4"].(string) 1088 if err := associateFloatingIPToInstance(computeClient, floatingIP, instanceID, fixedIP); err != nil { 1089 return err 1090 } 1091 } 1092 } 1093 } 1094 return nil 1095 } 1096 1097 func associateFloatingIPToInstance(computeClient *gophercloud.ServiceClient, floatingIP string, instanceID string, fixedIP string) error { 1098 associateOpts := floatingip.AssociateOpts{ 1099 ServerID: instanceID, 1100 FloatingIP: floatingIP, 1101 FixedIP: fixedIP, 1102 } 1103 1104 if err := floatingip.AssociateInstance(computeClient, associateOpts).ExtractErr(); err != nil { 1105 return fmt.Errorf("Error associating floating IP: %s", err) 1106 } 1107 1108 return nil 1109 } 1110 1111 func disassociateFloatingIPFromInstance(computeClient *gophercloud.ServiceClient, floatingIP string, instanceID string, fixedIP string) error { 1112 associateOpts := floatingip.AssociateOpts{ 1113 ServerID: instanceID, 1114 FloatingIP: floatingIP, 1115 FixedIP: fixedIP, 1116 } 1117 1118 if err := floatingip.DisassociateInstance(computeClient, associateOpts).ExtractErr(); err != nil { 1119 return fmt.Errorf("Error disassociating floating IP: %s", err) 1120 } 1121 1122 return nil 1123 } 1124 1125 func resourceInstanceMetadataV2(d *schema.ResourceData) map[string]string { 1126 m := make(map[string]string) 1127 for key, val := range d.Get("metadata").(map[string]interface{}) { 1128 m[key] = val.(string) 1129 } 1130 return m 1131 } 1132 1133 func resourceInstanceBlockDevicesV2(d *schema.ResourceData, bds []interface{}) []bootfromvolume.BlockDevice { 1134 blockDeviceOpts := make([]bootfromvolume.BlockDevice, len(bds)) 1135 for i, bd := range bds { 1136 bdM := bd.(map[string]interface{}) 1137 sourceType := bootfromvolume.SourceType(bdM["source_type"].(string)) 1138 blockDeviceOpts[i] = bootfromvolume.BlockDevice{ 1139 UUID: bdM["uuid"].(string), 1140 SourceType: sourceType, 1141 VolumeSize: bdM["volume_size"].(int), 1142 DestinationType: bdM["destination_type"].(string), 1143 BootIndex: bdM["boot_index"].(int), 1144 DeleteOnTermination: bdM["delete_on_termination"].(bool), 1145 GuestFormat: bdM["guest_format"].(string), 1146 } 1147 } 1148 1149 log.Printf("[DEBUG] Block Device Options: %+v", blockDeviceOpts) 1150 return blockDeviceOpts 1151 } 1152 1153 func resourceInstanceSchedulerHintsV2(d *schema.ResourceData, schedulerHintsRaw map[string]interface{}) schedulerhints.SchedulerHints { 1154 differentHost := []string{} 1155 if len(schedulerHintsRaw["different_host"].([]interface{})) > 0 { 1156 for _, dh := range schedulerHintsRaw["different_host"].([]interface{}) { 1157 differentHost = append(differentHost, dh.(string)) 1158 } 1159 } 1160 1161 sameHost := []string{} 1162 if len(schedulerHintsRaw["same_host"].([]interface{})) > 0 { 1163 for _, sh := range schedulerHintsRaw["same_host"].([]interface{}) { 1164 sameHost = append(sameHost, sh.(string)) 1165 } 1166 } 1167 1168 query := make([]interface{}, len(schedulerHintsRaw["query"].([]interface{}))) 1169 if len(schedulerHintsRaw["query"].([]interface{})) > 0 { 1170 for _, q := range schedulerHintsRaw["query"].([]interface{}) { 1171 query = append(query, q.(string)) 1172 } 1173 } 1174 1175 schedulerHints := schedulerhints.SchedulerHints{ 1176 Group: schedulerHintsRaw["group"].(string), 1177 DifferentHost: differentHost, 1178 SameHost: sameHost, 1179 Query: query, 1180 TargetCell: schedulerHintsRaw["target_cell"].(string), 1181 BuildNearHostIP: schedulerHintsRaw["build_near_host_ip"].(string), 1182 } 1183 1184 return schedulerHints 1185 } 1186 1187 func getImageIDFromConfig(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) (string, error) { 1188 // If block_device was used, an Image does not need to be specified, unless an image/local 1189 // combination was used. This emulates normal boot behavior. Otherwise, ignore the image altogether. 1190 if vL, ok := d.GetOk("block_device"); ok { 1191 needImage := false 1192 for _, v := range vL.([]interface{}) { 1193 vM := v.(map[string]interface{}) 1194 if vM["source_type"] == "image" && vM["destination_type"] == "local" { 1195 needImage = true 1196 } 1197 } 1198 if !needImage { 1199 return "", nil 1200 } 1201 } 1202 1203 if imageId := d.Get("image_id").(string); imageId != "" { 1204 return imageId, nil 1205 } else { 1206 // try the OS_IMAGE_ID environment variable 1207 if v := os.Getenv("OS_IMAGE_ID"); v != "" { 1208 return v, nil 1209 } 1210 } 1211 1212 imageName := d.Get("image_name").(string) 1213 if imageName == "" { 1214 // try the OS_IMAGE_NAME environment variable 1215 if v := os.Getenv("OS_IMAGE_NAME"); v != "" { 1216 imageName = v 1217 } 1218 } 1219 1220 if imageName != "" { 1221 imageId, err := images.IDFromName(computeClient, imageName) 1222 if err != nil { 1223 return "", err 1224 } 1225 return imageId, nil 1226 } 1227 1228 return "", fmt.Errorf("Neither a boot device, image ID, or image name were able to be determined.") 1229 } 1230 1231 func setImageInformation(computeClient *gophercloud.ServiceClient, server *servers.Server, d *schema.ResourceData) error { 1232 // If block_device was used, an Image does not need to be specified, unless an image/local 1233 // combination was used. This emulates normal boot behavior. Otherwise, ignore the image altogether. 1234 if vL, ok := d.GetOk("block_device"); ok { 1235 needImage := false 1236 for _, v := range vL.([]interface{}) { 1237 vM := v.(map[string]interface{}) 1238 if vM["source_type"] == "image" && vM["destination_type"] == "local" { 1239 needImage = true 1240 } 1241 } 1242 if !needImage { 1243 d.Set("image_id", "Attempt to boot from volume - no image supplied") 1244 return nil 1245 } 1246 } 1247 1248 imageId := server.Image["id"].(string) 1249 if imageId != "" { 1250 d.Set("image_id", imageId) 1251 if image, err := images.Get(computeClient, imageId).Extract(); err != nil { 1252 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 1253 if !ok { 1254 return err 1255 } 1256 if errCode.Actual == 404 { 1257 // If the image name can't be found, set the value to "Image not found". 1258 // The most likely scenario is that the image no longer exists in the Image Service 1259 // but the instance still has a record from when it existed. 1260 d.Set("image_name", "Image not found") 1261 return nil 1262 } else { 1263 return err 1264 } 1265 } else { 1266 d.Set("image_name", image.Name) 1267 } 1268 } 1269 1270 return nil 1271 } 1272 1273 func getFlavorID(client *gophercloud.ServiceClient, d *schema.ResourceData) (string, error) { 1274 flavorId := d.Get("flavor_id").(string) 1275 1276 if flavorId != "" { 1277 return flavorId, nil 1278 } 1279 1280 flavorName := d.Get("flavor_name").(string) 1281 return flavors.IDFromName(client, flavorName) 1282 } 1283 1284 func resourceComputeVolumeAttachmentHash(v interface{}) int { 1285 var buf bytes.Buffer 1286 m := v.(map[string]interface{}) 1287 buf.WriteString(fmt.Sprintf("%s-", m["volume_id"].(string))) 1288 1289 return hashcode.String(buf.String()) 1290 } 1291 1292 func resourceComputeSchedulerHintsHash(v interface{}) int { 1293 var buf bytes.Buffer 1294 m := v.(map[string]interface{}) 1295 1296 if m["group"] != nil { 1297 buf.WriteString(fmt.Sprintf("%s-", m["group"].(string))) 1298 } 1299 1300 if m["target_cell"] != nil { 1301 buf.WriteString(fmt.Sprintf("%s-", m["target_cell"].(string))) 1302 } 1303 1304 if m["build_host_near_ip"] != nil { 1305 buf.WriteString(fmt.Sprintf("%s-", m["build_host_near_ip"].(string))) 1306 } 1307 1308 buf.WriteString(fmt.Sprintf("%s-", m["different_host"].([]interface{}))) 1309 buf.WriteString(fmt.Sprintf("%s-", m["same_host"].([]interface{}))) 1310 buf.WriteString(fmt.Sprintf("%s-", m["query"].([]interface{}))) 1311 1312 return hashcode.String(buf.String()) 1313 } 1314 1315 func attachVolumesToInstance(computeClient *gophercloud.ServiceClient, blockClient *gophercloud.ServiceClient, serverId string, vols []interface{}) error { 1316 for _, v := range vols { 1317 va := v.(map[string]interface{}) 1318 volumeId := va["volume_id"].(string) 1319 device := va["device"].(string) 1320 1321 s := "" 1322 if serverId != "" { 1323 s = serverId 1324 } else if va["server_id"] != "" { 1325 s = va["server_id"].(string) 1326 } else { 1327 return fmt.Errorf("Unable to determine server ID to attach volume.") 1328 } 1329 1330 vaOpts := &volumeattach.CreateOpts{ 1331 Device: device, 1332 VolumeID: volumeId, 1333 } 1334 1335 if _, err := volumeattach.Create(computeClient, s, vaOpts).Extract(); err != nil { 1336 return err 1337 } 1338 1339 stateConf := &resource.StateChangeConf{ 1340 Pending: []string{"attaching", "available"}, 1341 Target: []string{"in-use"}, 1342 Refresh: VolumeV1StateRefreshFunc(blockClient, va["volume_id"].(string)), 1343 Timeout: 30 * time.Minute, 1344 Delay: 5 * time.Second, 1345 MinTimeout: 2 * time.Second, 1346 } 1347 1348 if _, err := stateConf.WaitForState(); err != nil { 1349 return err 1350 } 1351 1352 log.Printf("[INFO] Attached volume %s to instance %s", volumeId, serverId) 1353 } 1354 return nil 1355 } 1356 1357 func detachVolumesFromInstance(computeClient *gophercloud.ServiceClient, blockClient *gophercloud.ServiceClient, serverId string, vols []interface{}) error { 1358 for _, v := range vols { 1359 va := v.(map[string]interface{}) 1360 aId := va["id"].(string) 1361 1362 if err := volumeattach.Delete(computeClient, serverId, aId).ExtractErr(); err != nil { 1363 return err 1364 } 1365 1366 stateConf := &resource.StateChangeConf{ 1367 Pending: []string{"detaching", "in-use"}, 1368 Target: []string{"available"}, 1369 Refresh: VolumeV1StateRefreshFunc(blockClient, va["volume_id"].(string)), 1370 Timeout: 30 * time.Minute, 1371 Delay: 5 * time.Second, 1372 MinTimeout: 2 * time.Second, 1373 } 1374 1375 if _, err := stateConf.WaitForState(); err != nil { 1376 return err 1377 } 1378 log.Printf("[INFO] Detached volume %s from instance %s", va["volume_id"], serverId) 1379 } 1380 1381 return nil 1382 } 1383 1384 func getVolumeAttachments(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) error { 1385 var attachments []volumeattach.VolumeAttachment 1386 1387 err := volumeattach.List(computeClient, d.Id()).EachPage(func(page pagination.Page) (bool, error) { 1388 actual, err := volumeattach.ExtractVolumeAttachments(page) 1389 if err != nil { 1390 return false, err 1391 } 1392 1393 attachments = actual 1394 return true, nil 1395 }) 1396 1397 if err != nil { 1398 return err 1399 } 1400 1401 vols := make([]map[string]interface{}, len(attachments)) 1402 for i, attachment := range attachments { 1403 vols[i] = make(map[string]interface{}) 1404 vols[i]["id"] = attachment.ID 1405 vols[i]["volume_id"] = attachment.VolumeID 1406 vols[i]["device"] = attachment.Device 1407 } 1408 log.Printf("[INFO] Volume attachments: %v", vols) 1409 d.Set("volume", vols) 1410 1411 return nil 1412 } 1413 1414 func checkVolumeConfig(d *schema.ResourceData) error { 1415 // Although a volume_id is required to attach a volume, in order to be able to report 1416 // the attached volumes of an instance, it must be "computed" and thus "optional". 1417 // This accounts for situations such as "boot from volume" as well as volumes being 1418 // attached to the instance outside of Terraform. 1419 if v := d.Get("volume"); v != nil { 1420 vols := v.(*schema.Set).List() 1421 if len(vols) > 0 { 1422 for _, v := range vols { 1423 va := v.(map[string]interface{}) 1424 if va["volume_id"].(string) == "" { 1425 return fmt.Errorf("A volume_id must be specified when attaching volumes.") 1426 } 1427 } 1428 } 1429 } 1430 1431 return nil 1432 } 1433 1434 func checkBlockDeviceConfig(d *schema.ResourceData) error { 1435 if vL, ok := d.GetOk("block_device"); ok { 1436 for _, v := range vL.([]interface{}) { 1437 vM := v.(map[string]interface{}) 1438 1439 if vM["source_type"] != "blank" && vM["uuid"] == "" { 1440 return fmt.Errorf("You must specify a uuid for %s block device types", vM["source_type"]) 1441 } 1442 1443 if vM["source_type"] == "image" && vM["destination_type"] == "volume" { 1444 if vM["volume_size"] == 0 { 1445 return fmt.Errorf("You must specify a volume_size when creating a volume from an image") 1446 } 1447 } 1448 1449 if vM["source_type"] == "blank" && vM["destination_type"] == "local" { 1450 if vM["volume_size"] == 0 { 1451 return fmt.Errorf("You must specify a volume_size when creating a blank block device") 1452 } 1453 } 1454 } 1455 } 1456 1457 return nil 1458 } 1459 1460 func resourceComputeInstancePersonalityHash(v interface{}) int { 1461 var buf bytes.Buffer 1462 m := v.(map[string]interface{}) 1463 buf.WriteString(fmt.Sprintf("%s-", m["file"].(string))) 1464 1465 return hashcode.String(buf.String()) 1466 } 1467 1468 func resourceInstancePersonalityV2(d *schema.ResourceData) servers.Personality { 1469 var personalities servers.Personality 1470 1471 if v := d.Get("personality"); v != nil { 1472 personalityList := v.(*schema.Set).List() 1473 if len(personalityList) > 0 { 1474 for _, p := range personalityList { 1475 rawPersonality := p.(map[string]interface{}) 1476 file := servers.File{ 1477 Path: rawPersonality["file"].(string), 1478 Contents: []byte(rawPersonality["content"].(string)), 1479 } 1480 1481 log.Printf("[DEBUG] OpenStack Compute Instance Personality: %+v", file) 1482 1483 personalities = append(personalities, &file) 1484 } 1485 } 1486 } 1487 1488 return personalities 1489 }