github.com/andresvia/terraform@v0.6.15-0.20160412045437-d51c75946785/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 createOpts, 395 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 != "" && newFIP != "" && 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 log.Printf("[DEBUG] Attempting to associate %s to %s", newFIP, d.Id()) 688 if err := associateFloatingIPToInstance(computeClient, newFIP, d.Id(), newFixedIP); err != nil { 689 return fmt.Errorf("Error associating Floating IP during update: %s", err) 690 } 691 } 692 } 693 } 694 695 if d.HasChange("volume") { 696 // ensure the volume configuration is correct 697 if err := checkVolumeConfig(d); err != nil { 698 return err 699 } 700 701 // old attachments and new attachments 702 oldAttachments, newAttachments := d.GetChange("volume") 703 704 // for each old attachment, detach the volume 705 oldAttachmentSet := oldAttachments.(*schema.Set).List() 706 if blockClient, err := config.blockStorageV1Client(d.Get("region").(string)); err != nil { 707 return err 708 } else { 709 if err := detachVolumesFromInstance(computeClient, blockClient, d.Id(), oldAttachmentSet); err != nil { 710 return err 711 } 712 } 713 714 // for each new attachment, attach the volume 715 newAttachmentSet := newAttachments.(*schema.Set).List() 716 if blockClient, err := config.blockStorageV1Client(d.Get("region").(string)); err != nil { 717 return err 718 } else { 719 if err := attachVolumesToInstance(computeClient, blockClient, d.Id(), newAttachmentSet); err != nil { 720 return err 721 } 722 } 723 724 d.SetPartial("volume") 725 } 726 727 if d.HasChange("flavor_id") || d.HasChange("flavor_name") { 728 var newFlavorId string 729 var err error 730 if d.HasChange("flavor_id") { 731 newFlavorId = d.Get("flavor_id").(string) 732 } else { 733 newFlavorName := d.Get("flavor_name").(string) 734 newFlavorId, err = flavors.IDFromName(computeClient, newFlavorName) 735 if err != nil { 736 return err 737 } 738 } 739 740 resizeOpts := &servers.ResizeOpts{ 741 FlavorRef: newFlavorId, 742 } 743 log.Printf("[DEBUG] Resize configuration: %#v", resizeOpts) 744 err = servers.Resize(computeClient, d.Id(), resizeOpts).ExtractErr() 745 if err != nil { 746 return fmt.Errorf("Error resizing OpenStack server: %s", err) 747 } 748 749 // Wait for the instance to finish resizing. 750 log.Printf("[DEBUG] Waiting for instance (%s) to finish resizing", d.Id()) 751 752 stateConf := &resource.StateChangeConf{ 753 Pending: []string{"RESIZE"}, 754 Target: []string{"VERIFY_RESIZE"}, 755 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 756 Timeout: 3 * time.Minute, 757 Delay: 10 * time.Second, 758 MinTimeout: 3 * time.Second, 759 } 760 761 _, err = stateConf.WaitForState() 762 if err != nil { 763 return fmt.Errorf("Error waiting for instance (%s) to resize: %s", d.Id(), err) 764 } 765 766 // Confirm resize. 767 log.Printf("[DEBUG] Confirming resize") 768 err = servers.ConfirmResize(computeClient, d.Id()).ExtractErr() 769 if err != nil { 770 return fmt.Errorf("Error confirming resize of OpenStack server: %s", err) 771 } 772 773 stateConf = &resource.StateChangeConf{ 774 Pending: []string{"VERIFY_RESIZE"}, 775 Target: []string{"ACTIVE"}, 776 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 777 Timeout: 3 * time.Minute, 778 Delay: 10 * time.Second, 779 MinTimeout: 3 * time.Second, 780 } 781 782 _, err = stateConf.WaitForState() 783 if err != nil { 784 return fmt.Errorf("Error waiting for instance (%s) to confirm resize: %s", d.Id(), err) 785 } 786 } 787 788 return resourceComputeInstanceV2Read(d, meta) 789 } 790 791 func resourceComputeInstanceV2Delete(d *schema.ResourceData, meta interface{}) error { 792 config := meta.(*Config) 793 computeClient, err := config.computeV2Client(d.Get("region").(string)) 794 if err != nil { 795 return fmt.Errorf("Error creating OpenStack compute client: %s", err) 796 } 797 798 err = servers.Delete(computeClient, d.Id()).ExtractErr() 799 if err != nil { 800 return fmt.Errorf("Error deleting OpenStack server: %s", err) 801 } 802 803 // Wait for the instance to delete before moving on. 804 log.Printf("[DEBUG] Waiting for instance (%s) to delete", d.Id()) 805 806 stateConf := &resource.StateChangeConf{ 807 Pending: []string{"ACTIVE"}, 808 Target: []string{"DELETED"}, 809 Refresh: ServerV2StateRefreshFunc(computeClient, d.Id()), 810 Timeout: 30 * time.Minute, 811 Delay: 10 * time.Second, 812 MinTimeout: 3 * time.Second, 813 } 814 815 _, err = stateConf.WaitForState() 816 if err != nil { 817 return fmt.Errorf( 818 "Error waiting for instance (%s) to delete: %s", 819 d.Id(), err) 820 } 821 822 d.SetId("") 823 return nil 824 } 825 826 // ServerV2StateRefreshFunc returns a resource.StateRefreshFunc that is used to watch 827 // an OpenStack instance. 828 func ServerV2StateRefreshFunc(client *gophercloud.ServiceClient, instanceID string) resource.StateRefreshFunc { 829 return func() (interface{}, string, error) { 830 s, err := servers.Get(client, instanceID).Extract() 831 if err != nil { 832 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 833 if !ok { 834 return nil, "", err 835 } 836 if errCode.Actual == 404 { 837 return s, "DELETED", nil 838 } 839 return nil, "", err 840 } 841 842 return s, s.Status, nil 843 } 844 } 845 846 func resourceInstanceSecGroupsV2(d *schema.ResourceData) []string { 847 rawSecGroups := d.Get("security_groups").(*schema.Set).List() 848 secgroups := make([]string, len(rawSecGroups)) 849 for i, raw := range rawSecGroups { 850 secgroups[i] = raw.(string) 851 } 852 return secgroups 853 } 854 855 // getInstanceNetworks collects instance network information from different sources 856 // and aggregates it all together. 857 func getInstanceNetworksAndAddresses(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) ([]map[string]interface{}, error) { 858 server, err := servers.Get(computeClient, d.Id()).Extract() 859 if err != nil { 860 return nil, CheckDeleted(d, err, "server") 861 } 862 863 networkDetails, err := getInstanceNetworks(computeClient, d) 864 addresses := getInstanceAddresses(server.Addresses) 865 if err != nil { 866 return nil, err 867 } 868 869 // if there are no networkDetails, make networks at least a length of 1 870 networkLength := 1 871 if len(networkDetails) > 0 { 872 networkLength = len(networkDetails) 873 } 874 networks := make([]map[string]interface{}, networkLength) 875 876 // Loop through all networks and addresses, 877 // merge relevant address details. 878 if len(networkDetails) == 0 { 879 for netName, n := range addresses { 880 networks[0] = map[string]interface{}{ 881 "name": netName, 882 "fixed_ip_v4": n["fixed_ip_v4"], 883 "fixed_ip_v6": n["fixed_ip_v6"], 884 "floating_ip": n["floating_ip"], 885 "mac": n["mac"], 886 } 887 } 888 } else { 889 for i, net := range networkDetails { 890 n := addresses[net["name"].(string)] 891 892 networks[i] = map[string]interface{}{ 893 "uuid": networkDetails[i]["uuid"], 894 "name": networkDetails[i]["name"], 895 "port": networkDetails[i]["port"], 896 "fixed_ip_v4": n["fixed_ip_v4"], 897 "fixed_ip_v6": n["fixed_ip_v6"], 898 "floating_ip": n["floating_ip"], 899 "mac": n["mac"], 900 "access_network": networkDetails[i]["access_network"], 901 } 902 } 903 } 904 905 log.Printf("[DEBUG] networks: %+v", networks) 906 907 return networks, nil 908 } 909 910 func getInstanceNetworks(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) ([]map[string]interface{}, error) { 911 rawNetworks := d.Get("network").([]interface{}) 912 newNetworks := make([]map[string]interface{}, 0, len(rawNetworks)) 913 var tenantnet tenantnetworks.Network 914 915 tenantNetworkExt := true 916 for _, raw := range rawNetworks { 917 // Not sure what causes this, but it is a possibility (see GH-2323). 918 // Since we call this function to reconcile what we'll save in the 919 // state anyways, we just ignore it. 920 if raw == nil { 921 continue 922 } 923 924 rawMap := raw.(map[string]interface{}) 925 926 allPages, err := tenantnetworks.List(computeClient).AllPages() 927 if err != nil { 928 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 929 if !ok { 930 return nil, err 931 } 932 933 if errCode.Actual == 404 || errCode.Actual == 403 { 934 tenantNetworkExt = false 935 } else { 936 return nil, err 937 } 938 } 939 940 networkID := "" 941 networkName := "" 942 if tenantNetworkExt { 943 networkList, err := tenantnetworks.ExtractNetworks(allPages) 944 if err != nil { 945 return nil, err 946 } 947 948 for _, network := range networkList { 949 if network.Name == rawMap["name"] { 950 tenantnet = network 951 } 952 if network.ID == rawMap["uuid"] { 953 tenantnet = network 954 } 955 } 956 957 networkID = tenantnet.ID 958 networkName = tenantnet.Name 959 } else { 960 networkID = rawMap["uuid"].(string) 961 networkName = rawMap["name"].(string) 962 } 963 964 newNetworks = append(newNetworks, map[string]interface{}{ 965 "uuid": networkID, 966 "name": networkName, 967 "port": rawMap["port"].(string), 968 "fixed_ip_v4": rawMap["fixed_ip_v4"].(string), 969 "access_network": rawMap["access_network"].(bool), 970 }) 971 } 972 973 log.Printf("[DEBUG] networks: %+v", newNetworks) 974 return newNetworks, nil 975 } 976 977 func getInstanceAddresses(addresses map[string]interface{}) map[string]map[string]interface{} { 978 addrs := make(map[string]map[string]interface{}) 979 for n, networkAddresses := range addresses { 980 addrs[n] = make(map[string]interface{}) 981 for _, element := range networkAddresses.([]interface{}) { 982 address := element.(map[string]interface{}) 983 if address["OS-EXT-IPS:type"] == "floating" { 984 addrs[n]["floating_ip"] = address["addr"] 985 } else { 986 if address["version"].(float64) == 4 { 987 addrs[n]["fixed_ip_v4"] = address["addr"].(string) 988 } else { 989 addrs[n]["fixed_ip_v6"] = fmt.Sprintf("[%s]", address["addr"].(string)) 990 } 991 } 992 if mac, ok := address["OS-EXT-IPS-MAC:mac_addr"]; ok { 993 addrs[n]["mac"] = mac.(string) 994 } 995 } 996 } 997 998 log.Printf("[DEBUG] Addresses: %+v", addresses) 999 1000 return addrs 1001 } 1002 1003 func getInstanceAccessAddresses(d *schema.ResourceData, networks []map[string]interface{}) (string, string) { 1004 var hostv4, hostv6 string 1005 1006 // Start with a global floating IP 1007 floatingIP := d.Get("floating_ip").(string) 1008 if floatingIP != "" { 1009 hostv4 = floatingIP 1010 } 1011 1012 // Loop through all networks and check for the following: 1013 // * If the network is set as an access network. 1014 // * If the network has a floating IP. 1015 // * If the network has a v4/v6 fixed IP. 1016 for _, n := range networks { 1017 if n["floating_ip"] != nil { 1018 hostv4 = n["floating_ip"].(string) 1019 } else { 1020 if hostv4 == "" && n["fixed_ip_v4"] != nil { 1021 hostv4 = n["fixed_ip_v4"].(string) 1022 } 1023 } 1024 1025 if hostv6 == "" && n["fixed_ip_v6"] != nil { 1026 hostv6 = n["fixed_ip_v6"].(string) 1027 } 1028 1029 if an, ok := n["access_network"].(bool); ok && an { 1030 break 1031 } 1032 } 1033 1034 log.Printf("[DEBUG] OpenStack Instance Network Access Addresses: %s, %s", hostv4, hostv6) 1035 1036 return hostv4, hostv6 1037 } 1038 1039 func checkInstanceFloatingIPs(d *schema.ResourceData) error { 1040 rawNetworks := d.Get("network").([]interface{}) 1041 floatingIP := d.Get("floating_ip").(string) 1042 1043 for _, raw := range rawNetworks { 1044 if raw == nil { 1045 continue 1046 } 1047 1048 rawMap := raw.(map[string]interface{}) 1049 1050 // Error if a floating IP was specified both globally and in the network block. 1051 if floatingIP != "" && rawMap["floating_ip"] != "" { 1052 return fmt.Errorf("Cannot specify a floating IP both globally and in a network block.") 1053 } 1054 } 1055 return nil 1056 } 1057 1058 func associateFloatingIPsToInstance(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) error { 1059 floatingIP := d.Get("floating_ip").(string) 1060 rawNetworks := d.Get("network").([]interface{}) 1061 instanceID := d.Id() 1062 1063 if floatingIP != "" { 1064 if err := associateFloatingIPToInstance(computeClient, floatingIP, instanceID, ""); err != nil { 1065 return err 1066 } 1067 } else { 1068 for _, raw := range rawNetworks { 1069 if raw == nil { 1070 continue 1071 } 1072 1073 rawMap := raw.(map[string]interface{}) 1074 if rawMap["floating_ip"].(string) != "" { 1075 floatingIP := rawMap["floating_ip"].(string) 1076 fixedIP := rawMap["fixed_ip_v4"].(string) 1077 if err := associateFloatingIPToInstance(computeClient, floatingIP, instanceID, fixedIP); err != nil { 1078 return err 1079 } 1080 } 1081 } 1082 } 1083 return nil 1084 } 1085 1086 func associateFloatingIPToInstance(computeClient *gophercloud.ServiceClient, floatingIP string, instanceID string, fixedIP string) error { 1087 associateOpts := floatingip.AssociateOpts{ 1088 ServerID: instanceID, 1089 FloatingIP: floatingIP, 1090 FixedIP: fixedIP, 1091 } 1092 1093 if err := floatingip.AssociateInstance(computeClient, associateOpts).ExtractErr(); err != nil { 1094 return fmt.Errorf("Error associating floating IP: %s", err) 1095 } 1096 1097 return nil 1098 } 1099 1100 func disassociateFloatingIPFromInstance(computeClient *gophercloud.ServiceClient, floatingIP string, instanceID string, fixedIP string) error { 1101 associateOpts := floatingip.AssociateOpts{ 1102 ServerID: instanceID, 1103 FloatingIP: floatingIP, 1104 FixedIP: fixedIP, 1105 } 1106 1107 if err := floatingip.DisassociateInstance(computeClient, associateOpts).ExtractErr(); err != nil { 1108 return fmt.Errorf("Error disassociating floating IP: %s", err) 1109 } 1110 1111 return nil 1112 } 1113 1114 func resourceInstanceMetadataV2(d *schema.ResourceData) map[string]string { 1115 m := make(map[string]string) 1116 for key, val := range d.Get("metadata").(map[string]interface{}) { 1117 m[key] = val.(string) 1118 } 1119 return m 1120 } 1121 1122 func resourceInstanceBlockDevicesV2(d *schema.ResourceData, bds []interface{}) []bootfromvolume.BlockDevice { 1123 blockDeviceOpts := make([]bootfromvolume.BlockDevice, len(bds)) 1124 for i, bd := range bds { 1125 bdM := bd.(map[string]interface{}) 1126 sourceType := bootfromvolume.SourceType(bdM["source_type"].(string)) 1127 blockDeviceOpts[i] = bootfromvolume.BlockDevice{ 1128 UUID: bdM["uuid"].(string), 1129 SourceType: sourceType, 1130 VolumeSize: bdM["volume_size"].(int), 1131 DestinationType: bdM["destination_type"].(string), 1132 BootIndex: bdM["boot_index"].(int), 1133 DeleteOnTermination: bdM["delete_on_termination"].(bool), 1134 GuestFormat: bdM["guest_format"].(string), 1135 } 1136 } 1137 1138 log.Printf("[DEBUG] Block Device Options: %+v", blockDeviceOpts) 1139 return blockDeviceOpts 1140 } 1141 1142 func resourceInstanceSchedulerHintsV2(d *schema.ResourceData, schedulerHintsRaw map[string]interface{}) schedulerhints.SchedulerHints { 1143 differentHost := []string{} 1144 if len(schedulerHintsRaw["different_host"].([]interface{})) > 0 { 1145 for _, dh := range schedulerHintsRaw["different_host"].([]interface{}) { 1146 differentHost = append(differentHost, dh.(string)) 1147 } 1148 } 1149 1150 sameHost := []string{} 1151 if len(schedulerHintsRaw["same_host"].([]interface{})) > 0 { 1152 for _, sh := range schedulerHintsRaw["same_host"].([]interface{}) { 1153 sameHost = append(sameHost, sh.(string)) 1154 } 1155 } 1156 1157 query := make([]interface{}, len(schedulerHintsRaw["query"].([]interface{}))) 1158 if len(schedulerHintsRaw["query"].([]interface{})) > 0 { 1159 for _, q := range schedulerHintsRaw["query"].([]interface{}) { 1160 query = append(query, q.(string)) 1161 } 1162 } 1163 1164 schedulerHints := schedulerhints.SchedulerHints{ 1165 Group: schedulerHintsRaw["group"].(string), 1166 DifferentHost: differentHost, 1167 SameHost: sameHost, 1168 Query: query, 1169 TargetCell: schedulerHintsRaw["target_cell"].(string), 1170 BuildNearHostIP: schedulerHintsRaw["build_near_host_ip"].(string), 1171 } 1172 1173 return schedulerHints 1174 } 1175 1176 func getImageIDFromConfig(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) (string, error) { 1177 // If block_device was used, an Image does not need to be specified, unless an image/local 1178 // combination was used. This emulates normal boot behavior. Otherwise, ignore the image altogether. 1179 if vL, ok := d.GetOk("block_device"); ok { 1180 needImage := false 1181 for _, v := range vL.([]interface{}) { 1182 vM := v.(map[string]interface{}) 1183 if vM["source_type"] == "image" && vM["destination_type"] == "local" { 1184 needImage = true 1185 } 1186 } 1187 if !needImage { 1188 return "", nil 1189 } 1190 } 1191 1192 if imageId := d.Get("image_id").(string); imageId != "" { 1193 return imageId, nil 1194 } else { 1195 // try the OS_IMAGE_ID environment variable 1196 if v := os.Getenv("OS_IMAGE_ID"); v != "" { 1197 return v, nil 1198 } 1199 } 1200 1201 imageName := d.Get("image_name").(string) 1202 if imageName == "" { 1203 // try the OS_IMAGE_NAME environment variable 1204 if v := os.Getenv("OS_IMAGE_NAME"); v != "" { 1205 imageName = v 1206 } 1207 } 1208 1209 if imageName != "" { 1210 imageId, err := images.IDFromName(computeClient, imageName) 1211 if err != nil { 1212 return "", err 1213 } 1214 return imageId, nil 1215 } 1216 1217 return "", fmt.Errorf("Neither a boot device, image ID, or image name were able to be determined.") 1218 } 1219 1220 func setImageInformation(computeClient *gophercloud.ServiceClient, server *servers.Server, d *schema.ResourceData) error { 1221 // If block_device was used, an Image does not need to be specified, unless an image/local 1222 // combination was used. This emulates normal boot behavior. Otherwise, ignore the image altogether. 1223 if vL, ok := d.GetOk("block_device"); ok { 1224 needImage := false 1225 for _, v := range vL.([]interface{}) { 1226 vM := v.(map[string]interface{}) 1227 if vM["source_type"] == "image" && vM["destination_type"] == "local" { 1228 needImage = true 1229 } 1230 } 1231 if !needImage { 1232 d.Set("image_id", "Attempt to boot from volume - no image supplied") 1233 return nil 1234 } 1235 } 1236 1237 imageId := server.Image["id"].(string) 1238 if imageId != "" { 1239 d.Set("image_id", imageId) 1240 if image, err := images.Get(computeClient, imageId).Extract(); err != nil { 1241 errCode, ok := err.(*gophercloud.UnexpectedResponseCodeError) 1242 if !ok { 1243 return err 1244 } 1245 if errCode.Actual == 404 { 1246 // If the image name can't be found, set the value to "Image not found". 1247 // The most likely scenario is that the image no longer exists in the Image Service 1248 // but the instance still has a record from when it existed. 1249 d.Set("image_name", "Image not found") 1250 return nil 1251 } else { 1252 return err 1253 } 1254 } else { 1255 d.Set("image_name", image.Name) 1256 } 1257 } 1258 1259 return nil 1260 } 1261 1262 func getFlavorID(client *gophercloud.ServiceClient, d *schema.ResourceData) (string, error) { 1263 flavorId := d.Get("flavor_id").(string) 1264 1265 if flavorId != "" { 1266 return flavorId, nil 1267 } 1268 1269 flavorName := d.Get("flavor_name").(string) 1270 return flavors.IDFromName(client, flavorName) 1271 } 1272 1273 func resourceComputeVolumeAttachmentHash(v interface{}) int { 1274 var buf bytes.Buffer 1275 m := v.(map[string]interface{}) 1276 buf.WriteString(fmt.Sprintf("%s-", m["volume_id"].(string))) 1277 1278 return hashcode.String(buf.String()) 1279 } 1280 1281 func resourceComputeSchedulerHintsHash(v interface{}) int { 1282 var buf bytes.Buffer 1283 m := v.(map[string]interface{}) 1284 1285 if m["group"] != nil { 1286 buf.WriteString(fmt.Sprintf("%s-", m["group"].(string))) 1287 } 1288 1289 if m["target_cell"] != nil { 1290 buf.WriteString(fmt.Sprintf("%s-", m["target_cell"].(string))) 1291 } 1292 1293 if m["build_host_near_ip"] != nil { 1294 buf.WriteString(fmt.Sprintf("%s-", m["build_host_near_ip"].(string))) 1295 } 1296 1297 buf.WriteString(fmt.Sprintf("%s-", m["different_host"].([]interface{}))) 1298 buf.WriteString(fmt.Sprintf("%s-", m["same_host"].([]interface{}))) 1299 buf.WriteString(fmt.Sprintf("%s-", m["query"].([]interface{}))) 1300 1301 return hashcode.String(buf.String()) 1302 } 1303 1304 func attachVolumesToInstance(computeClient *gophercloud.ServiceClient, blockClient *gophercloud.ServiceClient, serverId string, vols []interface{}) error { 1305 for _, v := range vols { 1306 va := v.(map[string]interface{}) 1307 volumeId := va["volume_id"].(string) 1308 device := va["device"].(string) 1309 1310 s := "" 1311 if serverId != "" { 1312 s = serverId 1313 } else if va["server_id"] != "" { 1314 s = va["server_id"].(string) 1315 } else { 1316 return fmt.Errorf("Unable to determine server ID to attach volume.") 1317 } 1318 1319 vaOpts := &volumeattach.CreateOpts{ 1320 Device: device, 1321 VolumeID: volumeId, 1322 } 1323 1324 if _, err := volumeattach.Create(computeClient, s, vaOpts).Extract(); err != nil { 1325 return err 1326 } 1327 1328 stateConf := &resource.StateChangeConf{ 1329 Pending: []string{"attaching", "available"}, 1330 Target: []string{"in-use"}, 1331 Refresh: VolumeV1StateRefreshFunc(blockClient, va["volume_id"].(string)), 1332 Timeout: 30 * time.Minute, 1333 Delay: 5 * time.Second, 1334 MinTimeout: 2 * time.Second, 1335 } 1336 1337 if _, err := stateConf.WaitForState(); err != nil { 1338 return err 1339 } 1340 1341 log.Printf("[INFO] Attached volume %s to instance %s", volumeId, serverId) 1342 } 1343 return nil 1344 } 1345 1346 func detachVolumesFromInstance(computeClient *gophercloud.ServiceClient, blockClient *gophercloud.ServiceClient, serverId string, vols []interface{}) error { 1347 for _, v := range vols { 1348 va := v.(map[string]interface{}) 1349 aId := va["id"].(string) 1350 1351 if err := volumeattach.Delete(computeClient, serverId, aId).ExtractErr(); err != nil { 1352 return err 1353 } 1354 1355 stateConf := &resource.StateChangeConf{ 1356 Pending: []string{"detaching", "in-use"}, 1357 Target: []string{"available"}, 1358 Refresh: VolumeV1StateRefreshFunc(blockClient, va["volume_id"].(string)), 1359 Timeout: 30 * time.Minute, 1360 Delay: 5 * time.Second, 1361 MinTimeout: 2 * time.Second, 1362 } 1363 1364 if _, err := stateConf.WaitForState(); err != nil { 1365 return err 1366 } 1367 log.Printf("[INFO] Detached volume %s from instance %s", va["volume_id"], serverId) 1368 } 1369 1370 return nil 1371 } 1372 1373 func getVolumeAttachments(computeClient *gophercloud.ServiceClient, d *schema.ResourceData) error { 1374 var attachments []volumeattach.VolumeAttachment 1375 1376 err := volumeattach.List(computeClient, d.Id()).EachPage(func(page pagination.Page) (bool, error) { 1377 actual, err := volumeattach.ExtractVolumeAttachments(page) 1378 if err != nil { 1379 return false, err 1380 } 1381 1382 attachments = actual 1383 return true, nil 1384 }) 1385 1386 if err != nil { 1387 return err 1388 } 1389 1390 vols := make([]map[string]interface{}, len(attachments)) 1391 for i, attachment := range attachments { 1392 vols[i] = make(map[string]interface{}) 1393 vols[i]["id"] = attachment.ID 1394 vols[i]["volume_id"] = attachment.VolumeID 1395 vols[i]["device"] = attachment.Device 1396 } 1397 log.Printf("[INFO] Volume attachments: %v", vols) 1398 d.Set("volume", vols) 1399 1400 return nil 1401 } 1402 1403 func checkVolumeConfig(d *schema.ResourceData) error { 1404 // Although a volume_id is required to attach a volume, in order to be able to report 1405 // the attached volumes of an instance, it must be "computed" and thus "optional". 1406 // This accounts for situations such as "boot from volume" as well as volumes being 1407 // attached to the instance outside of Terraform. 1408 if v := d.Get("volume"); v != nil { 1409 vols := v.(*schema.Set).List() 1410 if len(vols) > 0 { 1411 for _, v := range vols { 1412 va := v.(map[string]interface{}) 1413 if va["volume_id"].(string) == "" { 1414 return fmt.Errorf("A volume_id must be specified when attaching volumes.") 1415 } 1416 } 1417 } 1418 } 1419 1420 return nil 1421 } 1422 1423 func checkBlockDeviceConfig(d *schema.ResourceData) error { 1424 if vL, ok := d.GetOk("block_device"); ok { 1425 for _, v := range vL.([]interface{}) { 1426 vM := v.(map[string]interface{}) 1427 1428 if vM["source_type"] != "blank" && vM["uuid"] == "" { 1429 return fmt.Errorf("You must specify a uuid for %s block device types", vM["source_type"]) 1430 } 1431 1432 if vM["source_type"] == "image" && vM["destination_type"] == "volume" { 1433 if vM["volume_size"] == 0 { 1434 return fmt.Errorf("You must specify a volume_size when creating a volume from an image") 1435 } 1436 } 1437 1438 if vM["source_type"] == "blank" && vM["destination_type"] == "local" { 1439 if vM["volume_size"] == 0 { 1440 return fmt.Errorf("You must specify a volume_size when creating a blank block device") 1441 } 1442 } 1443 } 1444 } 1445 1446 return nil 1447 } 1448 1449 func resourceComputeInstancePersonalityHash(v interface{}) int { 1450 var buf bytes.Buffer 1451 m := v.(map[string]interface{}) 1452 buf.WriteString(fmt.Sprintf("%s-", m["file"].(string))) 1453 1454 return hashcode.String(buf.String()) 1455 } 1456 1457 func resourceInstancePersonalityV2(d *schema.ResourceData) servers.Personality { 1458 var personalities servers.Personality 1459 1460 if v := d.Get("personality"); v != nil { 1461 personalityList := v.(*schema.Set).List() 1462 if len(personalityList) > 0 { 1463 for _, p := range personalityList { 1464 rawPersonality := p.(map[string]interface{}) 1465 file := servers.File{ 1466 Path: rawPersonality["file"].(string), 1467 Contents: []byte(rawPersonality["content"].(string)), 1468 } 1469 1470 log.Printf("[DEBUG] OpenStack Compute Instance Personality: %+v", file) 1471 1472 personalities = append(personalities, &file) 1473 } 1474 } 1475 } 1476 1477 return personalities 1478 }