merge trunk

16 files changed, 215 insertions, 181 deletions

diff --git a/nova/virt/disk.py b/nova/virt/disk.py
index 52b2881e8..9fe164cfb 100644
--- a/nova/virt/disk.py
+++ b/nova/virt/disk.py
@@ -52,13 +52,54 @@ flags.DEFINE_integer('timeout_nbd', 10,
 flags.DEFINE_integer('max_nbd_devices', 16,
                      'maximum number of possible nbd devices')
 
+# NOTE(yamahata): DEFINE_list() doesn't work because the command may
+#                 include ','. For example,
+#                 mkfs.ext3 -O dir_index,extent -E stride=8,stripe-width=16
+#                 --label %(fs_label)s %(target)s
+#
+#                 DEFINE_list() parses its argument by
+#                 [s.strip() for s in argument.split(self._token)]
+#                 where self._token = ','
+#                 No escape nor exceptional handling for ','.
+#                 DEFINE_list() doesn't give us what we need.
+flags.DEFINE_multistring('virt_mkfs',
+                         ['windows=mkfs.ntfs --fast --label %(fs_label)s '
+                          '%(target)s',
+                          # NOTE(yamahata): vfat case
+                          #'windows=mkfs.vfat -n %(fs_label)s %(target)s',
+                          'linux=mkfs.ext3 -L %(fs_label)s -F %(target)s',
+                          'default=mkfs.ext3 -L %(fs_label)s -F %(target)s'],
+                         'mkfs commands for ephemeral device. The format is'
+                         '<os_type>=<mkfs command>')
+
+
+_MKFS_COMMAND = {}
+_DEFAULT_MKFS_COMMAND = None
+
+
+for s in FLAGS.virt_mkfs:
+    # NOTE(yamahata): mkfs command may includes '=' for its options.
+    #                 So item.partition('=') doesn't work here
+    os_type, mkfs_command = s.split('=', 1)
+    if os_type:
+        _MKFS_COMMAND[os_type] = mkfs_command
+    if os_type == 'default':
+        _DEFAULT_MKFS_COMMAND = mkfs_command
+
+
+def mkfs(os_type, fs_label, target):
+    mkfs_command = (_MKFS_COMMAND.get(os_type, _DEFAULT_MKFS_COMMAND) or
+                    '') % locals()
+    if mkfs_command:
+        utils.execute(*mkfs_command.split())
+
 
 def extend(image, size):
     """Increase image to size"""
     file_size = os.path.getsize(image)
     if file_size >= size:
         return
-    utils.execute('truncate', '-s', size, image)
+    utils.execute('qemu-img', 'resize', image, size)
     # NOTE(vish): attempts to resize filesystem
     utils.execute('e2fsck', '-fp', image, check_exit_code=False)
     utils.execute('resize2fs', image, check_exit_code=False)
@@ -148,15 +189,17 @@ def destroy_container(target, instance, nbd=False):
 
     LXC does not support qcow2 images yet.
     """
+    out, err = utils.execute('mount', run_as_root=True)
+    for loop in out.splitlines():
+        if instance['name'] in loop:
+            device = loop.split()[0]
+
     try:
         container_dir = '%s/rootfs' % target
         utils.execute('umount', container_dir, run_as_root=True)
-    finally:
-        out, err = utils.execute('losetup', '-a', run_as_root=True)
-        for loop in out.splitlines():
-            if instance['name'] in loop:
-                device = loop.split(loop, ':')
-                _unlink_device(device, nbd)
+        _unlink_device(device, nbd)
+    except Exception, exn:
+        LOG.exception(_('Failed to remove container: %s'), exn)
 
 
 def _link_device(image, nbd):
@@ -228,8 +271,8 @@ def _inject_metadata_into_fs(metadata, fs, execute=None):
     metadata_path = os.path.join(fs, "meta.js")
     metadata = dict([(m.key, m.value) for m in metadata])
 
-    utils.execute('sudo', 'tee', metadata_path,
-                  process_input=json.dumps(metadata))
+    utils.execute('tee', metadata_path,
+                  process_input=json.dumps(metadata), run_as_root=True)
 
 
 def _inject_key_into_fs(key, fs, execute=None):
diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index d05b51bd9..301346c6b 100644
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -165,12 +165,13 @@ class ComputeDriver(object):
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def reboot(self, instance, network_info):
+    def reboot(self, instance, network_info, reboot_type):
         """Reboot the specified instance.
 
         :param instance: Instance object as returned by DB layer.
         :param network_info:
            :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info`
+        :param reboot_type: Either a HARD or SOFT reboot
         """
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index d5e2bf31b..3596d8353 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -103,7 +103,7 @@ class FakeConnection(driver.ComputeDriver):
         if not instance['name'] in self.instances:
             raise exception.InstanceNotRunning()
 
-    def reboot(self, instance, network_info):
+    def reboot(self, instance, network_info, reboot_type):
         pass
 
     def get_host_ip_addr(self):
diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py
index 03a78db1f..76925b405 100644
--- a/nova/virt/hyperv.py
+++ b/nova/virt/hyperv.py
@@ -367,7 +367,7 @@ class HyperVConnection(driver.ComputeDriver):
                     wmi_obj.Properties_.Item(prop).Value
         return newinst
 
-    def reboot(self, instance, network_info):
+    def reboot(self, instance, network_info, reboot_type):
         """Reboot the specified instance."""
         vm = self._lookup(instance.name)
         if vm is None:
diff --git a/nova/virt/images.py b/nova/virt/images.py
index 54c691a40..810b359d9 100644
--- a/nova/virt/images.py
+++ b/nova/virt/images.py
@@ -37,7 +37,8 @@ def fetch(context, image_href, path, _user_id, _project_id):
     #             when it is added to glance.  Right now there is no
     #             auth checking in glance, so we assume that access was
     #             checked before we got here.
-    (image_service, image_id) = nova.image.get_image_service(image_href)
+    (image_service, image_id) = nova.image.get_image_service(context,
+                                                             image_href)
     with open(path, "wb") as image_file:
         metadata = image_service.get(context, image_id, image_file)
     return metadata
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 56a0f3bb0..31b08be68 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -38,6 +38,7 @@ Supports KVM, LXC, QEMU, UML, and XEN.
 """
 
 import hashlib
+import functools
 import multiprocessing
 import netaddr
 import os
@@ -196,7 +197,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def _test_connection(self):
         try:
-            self._wrapped_conn.getInfo()
+            self._wrapped_conn.getCapabilities()
             return True
         except libvirt.libvirtError as e:
             if e.get_error_code() == libvirt.VIR_ERR_SYSTEM_ERROR and \
@@ -398,10 +399,10 @@ class LibvirtConnection(driver.ComputeDriver):
         virt_dom = self._lookup_by_name(instance['name'])
 
         (image_service, image_id) = nova.image.get_image_service(
-            instance['image_ref'])
+            context, instance['image_ref'])
         base = image_service.show(context, image_id)
         (snapshot_image_service, snapshot_image_id) = \
-            nova.image.get_image_service(image_href)
+            nova.image.get_image_service(context, image_href)
         snapshot = snapshot_image_service.show(context, snapshot_image_id)
 
         metadata = {'is_public': False,
@@ -466,7 +467,7 @@ class LibvirtConnection(driver.ComputeDriver):
         shutil.rmtree(temp_dir)
 
     @exception.wrap_exception()
-    def reboot(self, instance, network_info, xml=None):
+    def reboot(self, instance, network_info, reboot_type=None, xml=None):
         """Reboot a virtual machine, given an instance reference.
 
         This method actually destroys and re-creates the domain to ensure the
@@ -779,6 +780,10 @@ class LibvirtConnection(driver.ComputeDriver):
         if fs_format:
             utils.execute('mkfs', '-t', fs_format, target)
 
+    def _create_ephemeral(self, target, local_size, fs_label, os_type):
+        self._create_local(target, local_size)
+        disk.mkfs(os_type, fs_label, target)
+
     def _create_swap(self, target, swap_gb):
         """Create a swap file of specified size"""
         self._create_local(target, swap_gb)
@@ -867,9 +872,13 @@ class LibvirtConnection(driver.ComputeDriver):
                               local_size=local_gb)
 
         for eph in driver.block_device_info_get_ephemerals(block_device_info):
-            self._cache_image(fn=self._create_local,
+            fn = functools.partial(self._create_ephemeral,
+                                   fs_label='ephemeral%d' % eph['num'],
+                                   os_type=inst.os_type)
+            self._cache_image(fn=fn,
                               target=basepath(_get_eph_disk(eph)),
-                              fname="local_%s" % eph['size'],
+                              fname="ephemeral_%s_%s_%s" %
+                              (eph['num'], eph['size'], inst.os_type),
                               cow=FLAGS.use_cow_images,
                               local_size=eph['size'])
 
@@ -1103,6 +1112,11 @@ class LibvirtConnection(driver.ComputeDriver):
                 nova_context.get_admin_context(), instance['id'],
                 {'root_device_name': '/dev/' + self.default_root_device})
 
+        if local_device:
+            db.instance_update(
+                nova_context.get_admin_context(), instance['id'],
+                {'default_local_device': '/dev/' + self.default_local_device})
+
         swap = driver.block_device_info_get_swap(block_device_info)
         if driver.swap_is_usable(swap):
             xml_info['swap_device'] = block_device.strip_dev(
@@ -1111,6 +1125,9 @@ class LibvirtConnection(driver.ComputeDriver):
               not self._volume_in_mapping(self.default_swap_device,
                                           block_device_info)):
             xml_info['swap_device'] = self.default_swap_device
+            db.instance_update(
+                nova_context.get_admin_context(), instance['id'],
+                {'default_swap_device': '/dev/' + self.default_swap_device})
 
         config_drive = False
         if instance.get('config_drive') or instance.get('config_drive_id'):
@@ -1697,7 +1714,7 @@ class LibvirtConnection(driver.ComputeDriver):
             base = os.path.basename(info['path'])
             # Get image type and create empty disk image.
             instance_disk = os.path.join(instance_dir, base)
-            utils.execute('sudo', 'qemu-img', 'create', '-f', info['type'],
+            utils.execute('qemu-img', 'create', '-f', info['type'],
                           instance_disk, info['local_gb'])
 
         # if image has kernel and ramdisk, just download
@@ -1789,7 +1806,7 @@ class LibvirtConnection(driver.ComputeDriver):
             if disk_type == 'raw':
                 size = int(os.path.getsize(path))
             else:
-                out, err = utils.execute('sudo', 'qemu-img', 'info', path)
+                out, err = utils.execute('qemu-img', 'info', path)
                 size = [i.split('(')[1].split()[0] for i in out.split('\n')
                     if i.strip().find('virtual size') >= 0]
                 size = int(size[0])
diff --git a/nova/virt/libvirt/firewall.py b/nova/virt/libvirt/firewall.py
index c2f4f91e8..0db10c7ce 100644
--- a/nova/virt/libvirt/firewall.py
+++ b/nova/virt/libvirt/firewall.py
@@ -338,8 +338,8 @@ class NWFilterFirewall(FirewallDriver):
                                              'nova-allow-dhcp-server']
 
         if FLAGS.use_ipv6:
-            networks = [network for (network, _m) in network_info if
-                        network['gateway_v6']]
+            networks = [network for (network, info) in network_info if
+                        info['gateway6']]
 
             if networks:
                 instance_secgroup_filter_children.\
diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py
index 4c62d18bb..ae00bca0f 100644
--- a/nova/virt/vmwareapi/fake.py
+++ b/nova/virt/vmwareapi/fake.py
@@ -409,10 +409,10 @@ def fake_plug_vifs(*args, **kwargs):
 

 def fake_get_network(*args, **kwargs):

     """Fake get network."""

-    return [{'type': 'fake'}]

+    return {'type': 'fake'}

 

 

-def fake_fetch_image(image, instance, **kwargs):

+def fake_fetch_image(context, image, instance, **kwargs):

     """Fakes fetch image call. Just adds a reference to the db for the file."""

     ds_name = kwargs.get("datastore_name")

     file_path = kwargs.get("file_path")

@@ -420,12 +420,12 @@ def fake_fetch_image(image, instance, **kwargs):
     _add_file(ds_file_path)

 

 

-def fake_upload_image(image, instance, **kwargs):

+def fake_upload_image(context, image, instance, **kwargs):

     """Fakes the upload of an image."""

     pass

 

 

-def fake_get_vmdk_size_and_properties(image_id, instance):

+def fake_get_vmdk_size_and_properties(context, image_id, instance):

     """Fakes the file size and properties fetch for the image file."""

     props = {"vmware_ostype": "otherGuest",

             "vmware_adaptertype": "lsiLogic"}

diff --git a/nova/virt/vmwareapi/vif.py b/nova/virt/vmwareapi/vif.py
index fb6548b34..9906b89e1 100644
--- a/nova/virt/vmwareapi/vif.py
+++ b/nova/virt/vmwareapi/vif.py
@@ -17,42 +17,35 @@
 
 """VIF drivers for VMWare."""
 
-from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import utils
 from nova.virt.vif import VIFDriver
-from nova.virt.vmwareapi_conn import VMWareAPISession
 from nova.virt.vmwareapi import network_utils
 
 
 LOG = logging.getLogger("nova.virt.vmwareapi.vif")
 
 FLAGS = flags.FLAGS
+FLAGS['vmwareapi_vlan_interface'].SetDefault('vmnic0')
 
 
 class VMWareVlanBridgeDriver(VIFDriver):
     """VIF Driver to setup bridge/VLAN networking using VMWare API."""
 
     def plug(self, instance, network, mapping):
+        """Plug the VIF to specified instance using information passed.
+        Currently we are plugging the VIF(s) during instance creation itself.
+        We can use this method when we add support to add additional NIC to
+        an existing instance."""
+        pass
+
+    def ensure_vlan_bridge(self, session, network):
         """Create a vlan and bridge unless they already exist."""
         vlan_num = network['vlan']
         bridge = network['bridge']
-        bridge_interface = network['bridge_interface']
+        vlan_interface = FLAGS.vmwareapi_vlan_interface
 
-        # Open vmwareapi session
-        host_ip = FLAGS.vmwareapi_host_ip
-        host_username = FLAGS.vmwareapi_host_username
-        host_password = FLAGS.vmwareapi_host_password
-        if not host_ip or host_username is None or host_password is None:
-            raise Exception(_('Must specify vmwareapi_host_ip, '
-                              'vmwareapi_host_username '
-                              'and vmwareapi_host_password to use '
-                              'connection_type=vmwareapi'))
-        session = VMWareAPISession(host_ip, host_username, host_password,
-                                   FLAGS.vmwareapi_api_retry_count)
-        vlan_interface = bridge_interface
         # Check if the vlan_interface physical network adapter exists on the
         # host.
         if not network_utils.check_if_vlan_interface_exists(session,
@@ -92,4 +85,6 @@ class VMWareVlanBridgeDriver(VIFDriver):
                                                pgroup=pg_vlanid)
 
     def unplug(self, instance, network, mapping):
+        """Cleanup operations like deleting port group if no instance
+        is associated with it."""
         pass
diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py
index 82b5f7214..dd1c81196 100644
--- a/nova/virt/vmwareapi/vm_util.py
+++ b/nova/virt/vmwareapi/vm_util.py
@@ -39,8 +39,7 @@ def split_datastore_path(datastore_path):
 

 

 def get_vm_create_spec(client_factory, instance, data_store_name,

-                       network_name="vmnet0",

-                       os_type="otherGuest", network_ref=None):

+                       vif_infos, os_type="otherGuest"):

     """Builds the VM Create spec."""

     config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')

     config_spec.name = instance.name

@@ -61,14 +60,12 @@ def get_vm_create_spec(client_factory, instance, data_store_name,
     config_spec.numCPUs = int(instance.vcpus)

     config_spec.memoryMB = int(instance.memory_mb)

 

-    mac_address = None

-    if instance['mac_addresses']:

-        mac_address = instance['mac_addresses'][0]['address']

+    vif_spec_list = []

+    for vif_info in vif_infos:

+        vif_spec = create_network_spec(client_factory, vif_info)

+        vif_spec_list.append(vif_spec)

 

-    nic_spec = create_network_spec(client_factory,

-                                    network_name, mac_address)

-

-    device_config_spec = [nic_spec]

+    device_config_spec = vif_spec_list

 

     config_spec.deviceChange = device_config_spec

     return config_spec

@@ -93,8 +90,7 @@ def create_controller_spec(client_factory, key):
     return virtual_device_config

 

 

-def create_network_spec(client_factory, network_name, mac_address,

-                        network_ref=None):

+def create_network_spec(client_factory, vif_info):

     """

     Builds a config spec for the addition of a new network

     adapter to the VM.

@@ -109,6 +105,9 @@ def create_network_spec(client_factory, network_name, mac_address,
     # NOTE(asomya): Only works on ESXi if the portgroup binding is set to

     # ephemeral. Invalid configuration if set to static and the NIC does

     # not come up on boot if set to dynamic.

+    network_ref = vif_info['network_ref']

+    network_name = vif_info['network_name']

+    mac_address = vif_info['mac_address']

     backing = None

     if (network_ref and

         network_ref['type'] == "DistributedVirtualPortgroup"):

@@ -295,11 +294,8 @@ def get_dummy_vm_create_spec(client_factory, name, data_store_name):
     return config_spec

 

 

-def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask,

-                               gateway, broadcast, dns):

+def get_machine_id_change_spec(client_factory, machine_id_str):

     """Builds the machine id change config spec."""

-    machine_id_str = "%s;%s;%s;%s;%s;%s" % (mac, ip_addr, netmask,

-                                            gateway, broadcast, dns)

     virtual_machine_config_spec = \

         client_factory.create('ns0:VirtualMachineConfigSpec')

 

diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
index 07a6ba6ab..063b84a62 100644
--- a/nova/virt/vmwareapi/vmops.py
+++ b/nova/virt/vmwareapi/vmops.py
@@ -27,7 +27,6 @@ import urllib2
 import uuid

 

 from nova import context as nova_context

-from nova import db

 from nova import exception

 from nova import flags

 from nova import log as logging

@@ -111,22 +110,6 @@ class VMWareVMOps(object):
         client_factory = self._session._get_vim().client.factory

         service_content = self._session._get_vim().get_service_content()

 

-        network = db.network_get_by_instance(nova_context.get_admin_context(),

-                                            instance['id'])

-

-        net_name = network['bridge']

-

-        def _check_if_network_bridge_exists():

-            network_ref = \

-                network_utils.get_network_with_the_name(self._session,

-                                                        net_name)

-            if network_ref is None:

-                raise exception.NetworkNotFoundForBridge(bridge=net_name)

-            return network_ref

-

-        self.plug_vifs(instance, network_info)

-        network_obj = _check_if_network_bridge_exists()

-

         def _get_datastore_ref():

             """Get the datastore list and choose the first local storage."""

             data_stores = self._session._call_method(vim_util, "get_objects",

@@ -157,7 +140,7 @@ class VMWareVMOps(object):
             repository.

             """

             image_size, image_properties = \

-                    vmware_images.get_vmdk_size_and_properties(

+                    vmware_images.get_vmdk_size_and_properties(context,

                                        instance.image_ref, instance)

             vmdk_file_size_in_kb = int(image_size) / 1024

             os_type = image_properties.get("vmware_ostype", "otherGuest")

@@ -182,11 +165,36 @@ class VMWareVMOps(object):
 

         vm_folder_mor, res_pool_mor = _get_vmfolder_and_res_pool_mors()

 

+        def _check_if_network_bridge_exists(network_name):

+            network_ref = \

+                network_utils.get_network_with_the_name(self._session,

+                                                        network_name)

+            if network_ref is None:

+                raise exception.NetworkNotFoundForBridge(bridge=network_name)

+            return network_ref

+

+        def _get_vif_infos():

+            vif_infos = []

+            for (network, mapping) in network_info:

+                mac_address = mapping['mac']

+                network_name = network['bridge']

+                if mapping.get('should_create_vlan'):

+                    network_ref = self._vif_driver.ensure_vlan_bridge(

+                                                        self._session, network)

+                else:

+                    network_ref = _check_if_network_bridge_exists(network_name)

+                vif_infos.append({'network_name': network_name,

+                                  'mac_address': mac_address,

+                                  'network_ref': network_ref,

+                                 })

+            return vif_infos

+

+        vif_infos = _get_vif_infos()

+

         # Get the create vm config spec

         config_spec = vm_util.get_vm_create_spec(

                             client_factory, instance,

-                            data_store_name, net_name, os_type,

-                            network_obj)

+                            data_store_name, vif_infos, os_type)

 

         def _execute_create_vm():

             """Create VM on ESX host."""

@@ -204,8 +212,10 @@ class VMWareVMOps(object):
 

         _execute_create_vm()

 

-        # Set the machine id for the VM for setting the IP

-        self._set_machine_id(client_factory, instance)

+        # Set the machine.id parameter of the instance to inject

+        # the NIC configuration inside the VM

+        if FLAGS.flat_injected:

+            self._set_machine_id(client_factory, instance, network_info)

 

         # Naming the VM files in correspondence with the VM instance name

         # The flat vmdk file name

@@ -282,6 +292,7 @@ class VMWareVMOps(object):
             # Upload the -flat.vmdk file whose meta-data file we just created

             # above

             vmware_images.fetch_image(

+                context,

                 instance.image_ref,

                 instance,

                 host=self._session._host_ip,

@@ -448,6 +459,7 @@ class VMWareVMOps(object):
             # Upload the contents of -flat.vmdk file which has the disk data.

             LOG.debug(_("Uploading image %s") % snapshot_name)

             vmware_images.upload_image(

+                context,

                 snapshot_name,

                 instance,

                 os_type=os_type,

@@ -716,39 +728,45 @@ class VMWareVMOps(object):
         """Return link to instance's ajax console."""

         return 'http://fakeajaxconsole/fake_url'

 

-    def _set_machine_id(self, client_factory, instance):

+    def _set_machine_id(self, client_factory, instance, network_info):

         """

-        Set the machine id of the VM for guest tools to pick up and change

-        the IP.

+        Set the machine id of the VM for guest tools to pick up and reconfigure

+        the network interfaces.

         """

-        admin_context = nova_context.get_admin_context()

         vm_ref = self._get_vm_ref_from_the_name(instance.name)

         if vm_ref is None:

             raise exception.InstanceNotFound(instance_id=instance.id)

-        network = db.network_get_by_instance(nova_context.get_admin_context(),

-                                            instance['id'])

-        mac_address = None

-        if instance['mac_addresses']:

-            mac_address = instance['mac_addresses'][0]['address']

-

-        net_mask = network["netmask"]

-        gateway = network["gateway"]

-        broadcast = network["broadcast"]

-        # TODO(vish): add support for dns2

-        dns = network["dns1"]

-

-        addresses = db.instance_get_fixed_addresses(admin_context,

-                                                    instance['id'])

-        ip_addr = addresses[0] if addresses else None

+

+        machine_id_str = ''

+        for (network, info) in network_info:

+            # TODO(vish): add support for dns2

+            # TODO(sateesh): add support for injection of ipv6 configuration

+            ip_v4 = ip_v6 = None

+            if 'ips' in info and len(info['ips']) > 0:

+                ip_v4 = info['ips'][0]

+            if 'ip6s' in info and len(info['ip6s']) > 0:

+                ip_v6 = info['ip6s'][0]

+            if len(info['dns']) > 0:

+                dns = info['dns'][0]

+            else:

+                dns = ''

+

+            interface_str = "%s;%s;%s;%s;%s;%s" % \

+                                            (info['mac'],

+                                             ip_v4 and ip_v4['ip'] or '',

+                                             ip_v4 and ip_v4['netmask'] or '',

+                                             info['gateway'],

+                                             info['broadcast'],

+                                             dns)

+            machine_id_str = machine_id_str + interface_str + '#'

 

         machine_id_change_spec = \

-            vm_util.get_machine_id_change_spec(client_factory, mac_address,

-                                               ip_addr, net_mask, gateway,

-                                               broadcast, dns)

+            vm_util.get_machine_id_change_spec(client_factory, machine_id_str)

+

         LOG.debug(_("Reconfiguring VM instance %(name)s to set the machine id "

                   "with ip - %(ip_addr)s") %

                   ({'name': instance.name,

-                   'ip_addr': ip_addr}))

+                   'ip_addr': ip_v4['ip']}))

         reconfig_task = self._session._call_method(self._session._get_vim(),

                            "ReconfigVM_Task", vm_ref,

                            spec=machine_id_change_spec)

@@ -756,7 +774,7 @@ class VMWareVMOps(object):
         LOG.debug(_("Reconfigured VM instance %(name)s to set the machine id "

                   "with ip - %(ip_addr)s") %

                   ({'name': instance.name,

-                   'ip_addr': ip_addr}))

+                   'ip_addr': ip_v4['ip']}))

 

     def _get_datacenter_name_and_ref(self):

         """Get the datacenter name and the reference."""

diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py
index f5f75dae2..53f2d372e 100644
--- a/nova/virt/vmwareapi/vmware_images.py
+++ b/nova/virt/vmwareapi/vmware_images.py
@@ -20,15 +20,13 @@ Utility functions for Image transfer.
 

 from nova import exception

 from nova import flags

-import nova.image

+from nova.image import glance

 from nova import log as logging

 from nova.virt.vmwareapi import io_util

 from nova.virt.vmwareapi import read_write_util

 

 LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images")

 

-FLAGS = flags.FLAGS

-

 QUEUE_BUFFER_SIZE = 10

 

 

@@ -87,36 +85,10 @@ def start_transfer(read_file_handle, data_size, write_file_handle=None,
             write_file_handle.close()

 

 

-def fetch_image(image, instance, **kwargs):

-    """Fetch an image for attaching to the newly created VM."""

-    # Depending upon the image service, make appropriate image service call

-    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

-        func = _get_glance_image

-    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

-        func = _get_s3_image

-    else:

-        raise NotImplementedError(_("The Image Service %s is not implemented")

-                                  % FLAGS.image_service)

-    return func(image, instance, **kwargs)

-

-

-def upload_image(image, instance, **kwargs):

-    """Upload the newly snapshotted VM disk file."""

-    # Depending upon the image service, make appropriate image service call

-    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

-        func = _put_glance_image

-    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

-        func = _put_s3_image

-    else:

-        raise NotImplementedError(_("The Image Service %s is not implemented")

-                                  % FLAGS.image_service)

-    return func(image, instance, **kwargs)

-

-

-def _get_glance_image(image, instance, **kwargs):

+def fetch_image(context, image, instance, **kwargs):

     """Download image from the glance image server."""

     LOG.debug(_("Downloading image %s from glance image server") % image)

-    (glance_client, image_id) = nova.image.get_glance_client(image)

+    (glance_client, image_id) = glance.get_glance_client(context, image)

     metadata, read_iter = glance_client.get_image(image_id)

     read_file_handle = read_write_util.GlanceFileRead(read_iter)

     file_size = int(metadata['size'])

@@ -132,17 +104,7 @@ def _get_glance_image(image, instance, **kwargs):
     LOG.debug(_("Downloaded image %s from glance image server") % image)

 

 

-def _get_s3_image(image, instance, **kwargs):

-    """Download image from the S3 image server."""

-    raise NotImplementedError

-

-

-def _get_local_image(image, instance, **kwargs):

-    """Download image from the local nova compute node."""

-    raise NotImplementedError

-

-

-def _put_glance_image(image, instance, **kwargs):

+def upload_image(context, image, instance, **kwargs):

     """Upload the snapshotted vm disk file to Glance image server."""

     LOG.debug(_("Uploading image %s to the Glance image server") % image)

     read_file_handle = read_write_util.VmWareHTTPReadFile(

@@ -152,7 +114,7 @@ def _put_glance_image(image, instance, **kwargs):
                                 kwargs.get("cookies"),

                                 kwargs.get("file_path"))

     file_size = read_file_handle.get_size()

-    (glance_client, image_id) = nova.image.get_glance_client(image)

+    (glance_client, image_id) = glance.get_glance_client(context, image)

     # The properties and other fields that we need to set for the image.

     image_metadata = {"is_public": True,

                       "disk_format": "vmdk",

@@ -168,17 +130,7 @@ def _put_glance_image(image, instance, **kwargs):
     LOG.debug(_("Uploaded image %s to the Glance image server") % image)

 

 

-def _put_local_image(image, instance, **kwargs):

-    """Upload the snapshotted vm disk file to the local nova compute node."""

-    raise NotImplementedError

-

-

-def _put_s3_image(image, instance, **kwargs):

-    """Upload the snapshotted vm disk file to S3 image server."""

-    raise NotImplementedError

-

-

-def get_vmdk_size_and_properties(image, instance):

+def get_vmdk_size_and_properties(context, image, instance):

     """

     Get size of the vmdk file that is to be downloaded for attach in spawn.

     Need this to create the dummy virtual disk for the meta-data file. The

@@ -186,12 +138,9 @@ def get_vmdk_size_and_properties(image, instance):
     """

 

     LOG.debug(_("Getting image size for the image %s") % image)

-    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

-        (glance_client, image_id) = nova.image.get_glance_client(image)

-        meta_data = glance_client.get_image_meta(image_id)

-        size, properties = meta_data["size"], meta_data["properties"]

-    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

-        raise NotImplementedError

+    (glance_client, image_id) = glance.get_glance_client(context, image)

+    meta_data = glance_client.get_image_meta(image_id)

+    size, properties = meta_data["size"], meta_data["properties"]

     LOG.debug(_("Got image size of %(size)s for the image %(image)s") %

               locals())

     return size, properties

diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py
index 243ee64f5..fa89a8f45 100644
--- a/nova/virt/vmwareapi_conn.py
+++ b/nova/virt/vmwareapi_conn.py
@@ -133,7 +133,7 @@ class VMWareESXConnection(driver.ComputeDriver):
         """Create snapshot from a running VM instance."""

         self._vmops.snapshot(context, instance, name)

 

-    def reboot(self, instance, network_info):

+    def reboot(self, instance, network_info, reboot_type):

         """Reboot VM instance."""

         self._vmops.reboot(instance, network_info)

 

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index efbea7076..302238c98 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -31,12 +31,10 @@ import urllib
 import uuid
 from xml.dom import minidom
 
-import glance.client
 from nova import db
 from nova import exception
 from nova import flags
-import nova.image
-from nova.image import glance as glance_image_service
+from nova.image import glance
 from nova import log as logging
 from nova import utils
 from nova.compute import instance_types
@@ -383,8 +381,7 @@ class VMHelper(HelperBase):
 
         os_type = instance.os_type or FLAGS.default_os_type
 
-        glance_host, glance_port = \
-            glance_image_service.pick_glance_api_server()
+        glance_host, glance_port = glance.pick_glance_api_server()
         params = {'vdi_uuids': vdi_uuids,
                   'image_id': image_id,
                   'glance_host': glance_host,
@@ -447,8 +444,7 @@ class VMHelper(HelperBase):
         # pass them as arguments
         uuid_stack = [str(uuid.uuid4()) for i in xrange(2)]
 
-        glance_host, glance_port = \
-            glance_image_service.pick_glance_api_server()
+        glance_host, glance_port = glance.pick_glance_api_server()
         params = {'image_id': image,
                   'glance_host': glance_host,
                   'glance_port': glance_port,
@@ -546,7 +542,7 @@ class VMHelper(HelperBase):
         else:
             sr_ref = safe_find_sr(session)
 
-        glance_client, image_id = nova.image.get_glance_client(image)
+        glance_client, image_id = glance.get_glance_client(context, image)
         glance_client.set_auth_token(getattr(context, 'auth_token', None))
         meta, image_file = glance_client.get_image(image_id)
         virtual_size = int(meta['size'])
@@ -606,7 +602,7 @@ class VMHelper(HelperBase):
             raise e
 
     @classmethod
-    def determine_disk_image_type(cls, instance):
+    def determine_disk_image_type(cls, instance, context):
         """Disk Image Types are used to determine where the kernel will reside
         within an image. To figure out which type we're dealing with, we use
         the following rules:
@@ -639,7 +635,8 @@ class VMHelper(HelperBase):
                 'vhd': ImageType.DISK_VHD,
                 'iso': ImageType.DISK_ISO}
             image_ref = instance.image_ref
-            glance_client, image_id = nova.image.get_glance_client(image_ref)
+            glance_client, image_id = glance.get_glance_client(context,
+                                                               image_ref)
             meta = glance_client.get_image_meta(image_id)
             disk_format = meta['disk_format']
             try:
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 9c138ee41..6b56d668e 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -135,7 +135,7 @@ class VMOps(object):
         self._session.call_xenapi('VM.start', vm_ref, False, False)
 
     def _create_disks(self, context, instance):
-        disk_image_type = VMHelper.determine_disk_image_type(instance)
+        disk_image_type = VMHelper.determine_disk_image_type(instance, context)
         vdis = VMHelper.fetch_image(context, self._session,
                 instance, instance.image_ref,
                 instance.user_id, instance.project_id,
@@ -176,7 +176,7 @@ class VMOps(object):
                                   power_state.SHUTDOWN)
             return
 
-        disk_image_type = VMHelper.determine_disk_image_type(instance)
+        disk_image_type = VMHelper.determine_disk_image_type(instance, context)
         kernel = None
         ramdisk = None
         try:
@@ -253,6 +253,8 @@ class VMOps(object):
 
         self.create_vifs(vm_ref, instance, network_info)
         self.inject_network_info(instance, network_info, vm_ref)
+        self.inject_hostname(instance, vm_ref, instance['hostname'])
+
         return vm_ref
 
     def _attach_disks(self, instance, disk_image_type, vm_ref, first_vdi_ref,
@@ -624,10 +626,15 @@ class VMOps(object):
                     str(new_disk_size))
             LOG.debug(_("Resize instance %s complete") % (instance.name))
 
-    def reboot(self, instance):
+    def reboot(self, instance, reboot_type):
         """Reboot VM instance."""
         vm_ref = self._get_vm_opaque_ref(instance)
-        task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref)
+
+        if reboot_type == "HARD":
+            task = self._session.call_xenapi('Async.VM.hard_reboot', vm_ref)
+        else:
+            task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref)
+
         self._session.wait_for_task(task, instance.id)
 
     def get_agent_version(self, instance, timeout=None):
@@ -1153,6 +1160,16 @@ class VMOps(object):
         resp = self._make_plugin_call('agent', 'resetnetwork', instance, '',
                                                                args, vm_ref)
 
+    def inject_hostname(self, instance, vm_ref, hostname):
+        """Inject the hostname of the instance into the xenstore."""
+        if instance.os_type == "windows":
+            # NOTE(jk0): Windows hostnames can only be <= 15 chars.
+            hostname = hostname[:15]
+
+        logging.debug(_("injecting hostname to xs for vm: |%s|"), vm_ref)
+        self._session.call_xenapi_request("VM.add_to_xenstore_data",
+                (vm_ref, "vm-data/hostname", hostname))
+
     def list_from_xenstore(self, vm, path):
         """
         Runs the xenstore-ls command to get a listing of all records
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index 0d23e7689..f6dbc19f8 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -203,9 +203,9 @@ class XenAPIConnection(driver.ComputeDriver):
         """ Create snapshot from a running VM instance """
         self._vmops.snapshot(context, instance, image_id)
 
-    def reboot(self, instance, network_info):
+    def reboot(self, instance, network_info, reboot_type):
         """Reboot VM instance"""
-        self._vmops.reboot(instance)
+        self._vmops.reboot(instance, reboot_type)
 
     def set_admin_password(self, instance, new_pass):
         """Set the root/admin password on the VM instance"""