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  }