Merge lp:~yamahata/nova/boot-from-volume-2 into lp:~hudson-openstack/nova/trunk

[Isaku Yamahata]

With this branch, boot-from-volume can be marked as completed in some sense.
The remaining is minor if any and will be addressed as bug fixes.

With this branch the following is enabled.
- describe instance attribute
- get_metadata for euca-bundle-vol
- root/ephemeral/swap device support

[Brian Lamar (blamar)]

401 +from nova.api.ec2 import ec2utils
475 +from nova.api.ec2 import ec2utils

The database layer and the compute manager must not depend on something from the API layer. There are a couple degrees of separation missing here. This needs to be rethought, in my opinion.

review: Needs Fixing

[Devin Carlen (devcamcar)]

+1 to Brian's comments. There is insufficient separation of concerns here.

review: Needs Fixing

[Brian Lamar (blamar)]

Moving to WIP due to 2 "Needs Fixings".

[Isaku Yamahata (yamahata)]

On Wed, Jul 20, 2011 at 04:48:39PM -0000, Brian Lamar wrote:
> Review: Needs Fixing
> 401 +from nova.api.ec2 import ec2utils
> 475 +from nova.api.ec2 import ec2utils
>
> The database layer and the compute manager must not depend on something from the API layer. There are a couple degrees of separation missing here. This needs to be rethought, in my opinion.

thank you for review. I addressed it and added unit tests.
So the branch is ready for merge.

--
yamahata

[Brian Lamar (blamar)]

341 +# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>

After asking in the last meeting, I believe code should be copyright OpenStack, LLC.

365 + # NOTE(yamahata): see image_service.s3.s3create()
366 + for bdm in properties.get('mappings', []):
367 + if bdm['virtual'] == 'root':
368 + root_device_name = bdm['device']

This logic seems a little off, I'm not certain why you'd loop here unless there could be multiple mappings with 'virtual' == 'root'. Maybe it is a little late to bring this up, and let me know if it is, but is 'virtual' unique? It would seem that having mappings look like:

{
    "ami": {"device": "/dev/sda"},
    "root": {"device": "sda"},
    "ephemeral0": {"device": "sdb"},
}

instead of:

[
    {'virtual': 'ami', 'device': '/dev/sda'},
    {'virtual': 'root', 'device': 'sda'},
    {'virtual': 'ephemeral0', 'device': 'sdb'},
]

might make the logic a bit cleaner in a lot of areas? This might not work but I thought I'd suggest it. For example, the block of code referenced earlier would become:

root_device_name = mappings.get("root", None)

I'm a little confused that mappings sometimes are a list and other times are a dictionary. Which one is correct?

Can you give more information or point me to documentation on what "ephemeral" means in this context? Seemingly "ephemeral" devices won't persist on reboot, or something to that effect?

review: Needs Fixing

[Vish Ishaya (vishvananda)]

On Jul 25, 2011, at 10:41 AM, Brian Lamar wrote:

> Review: Needs Fixing
> 341 +# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>
>
> After asking in the last meeting, I believe code should be copyright OpenStack, LLC.

I'm not sure what the confusion is here, but we DO NOT require copyright assignment. People are free to add their own copyrights to code that they right. The CLA is what allows us to license the the code through the apache license.

Vish

[Vish Ishaya (vishvananda)]

s/right/write

[Brian Lamar (blamar)]

Thanks Vish, I spoke up at the last meeting but I guess it was missed or I mis-asked the question. Good to have clarification and I'll stop asking for this.

>
> On Jul 25, 2011, at 10:41 AM, Brian Lamar wrote:
>
> > Review: Needs Fixing
> > 341 +# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>
> >
> > After asking in the last meeting, I believe code should be copyright
> OpenStack, LLC.
>
> I'm not sure what the confusion is here, but we DO NOT require copyright
> assignment. People are free to add their own copyrights to code that they
> right. The CLA is what allows us to license the the code through the apache
> license.
>
> Vish

[Vish Ishaya (vishvananda)]

> Can you give more information or point me to documentation on what "ephemeral"
> means in this context? Seemingly "ephemeral" devices won't persist on reboot,
> or something to that effect?

Ephemeral is the aws name for local storage that the vm gets that isn't part of the image. In the libvirt driver we attach a second unformatted drive as the "ephemeral" space.

[Isaku Yamahata (yamahata)]

On Mon, Jul 25, 2011 at 05:41:30PM -0000, Brian Lamar wrote:
> Review: Needs Fixing
> 341 +# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>
>
> After asking in the last meeting, I believe code should be copyright OpenStack, LLC.
>
> 365 + # NOTE(yamahata): see image_service.s3.s3create()
> 366 + for bdm in properties.get('mappings', []):
> 367 + if bdm['virtual'] == 'root':
> 368 + root_device_name = bdm['device']
>
> This logic seems a little off, I'm not certain why you'd loop here unless there could be multiple mappings with 'virtual' == 'root'. Maybe it is a little late to bring this up, and let me know if it is, but is 'virtual' unique? It would seem that having mappings look like:

'virtual' is unique.

> {
> "ami": {"device": "/dev/sda"},
> "root": {"device": "sda"},
> "ephemeral0": {"device": "sdb"},
> }
>
> instead of:
>
> [
> {'virtual': 'ami', 'device': '/dev/sda'},
> {'virtual': 'root', 'device': 'sda'},
> {'virtual': 'ephemeral0', 'device': 'sdb'},
> ]
>
> might make the logic a bit cleaner in a lot of areas? This might not work but I thought I'd suggest it. For example, the block of code referenced earlier would become:
>
> root_device_name = mappings.get("root", None)
>
> I'm a little confused that mappings sometimes are a list and other times are a dictionary. Which one is correct?

A list as the internal representation. It's because they correspond to RDB rows.
Thus internally they are handled as lists consistently.(At least my intension is so)
The conversion from/to lists to/from dicts occurs when parsing API requests/
formatting API results if necessary.

Does it clarify?

Hmm, nova.api.ec2.cloud.CloudController._get_instance_mapping()
should be _format_instance_mapping(). I'll fix it.

> Can you give more information or point me to documentation on what "ephemeral" means in this context? Seemingly "ephemeral" devices won't persist on reboot, or something to that effect?

Vish kindly answered this.

--
yamahata

[lp:~yamahata/nova/boot-from-volume-2]

1331. By Isaku Yamahata on 2011-07-29

api/ec2: rename CloudController._get_instance_mapping into _format_instance_mapping

This patch renames nova.api.ec2.cloud.CouldController._get_instance_mapping
to _format_instance_mapping in order to make it clear that the method is
for API formatting, not for internal use.

[Isaku Yamahata (yamahata)]

> Hmm, nova.api.ec2.cloud.CloudController._get_instance_mapping()
> should be _format_instance_mapping(). I'll fix it.

Done.

[lp:~yamahata/nova/boot-from-volume-2]

1332. By Isaku Yamahata on 2011-08-02

merged with nova trunk

[Vish Ishaya (vishvananda)]

This is all looking very good. Just a question. Will this cause problems for the other hypervisors? Do we need to add support in xen and vmware to create swap partitions based on block_device_mapping?

review: Needs Information

[Isaku Yamahata (yamahata)]

On Tue, Aug 02, 2011 at 10:49:23PM -0000, Vish Ishaya wrote:
> Review: Needs Information
> This is all looking very good. Just a question. Will this cause problems for the other hypervisors?

No (except bugs). As long as the newly introduced features aren't used,
they should work as before.
Even if such features are used, e.g. block device mapping is specified,
they will be simply ignored.

> Do we need to add support in xen and vmware to create swap partitions based on block_device_mapping?

Although I'm not familiar with xen/vmware related code, I'm quite happy to help
those who implement it.

Does any user want it? Is there anyone who will implement it?
We will see the answers soon or after Diablo release.
--
yamahata

[Soren Hansen (soren)]

Can you explain why you pulled the disk_prefix variable into python code instead of leaving it in the template. It was intentinoally put in the template so that if someone wanted to e.g. not use virtio disks with kvm, they didn't have to patch any code, they could just make a new template, setting the disk_prefix to something else, and point nova at the new template. That seems more awkward now.

review: Needs Information

[Isaku Yamahata (yamahata)]

On Thu, Aug 04, 2011 at 11:11:26AM -0000, Soren Hansen wrote:
> Review: Needs Information
> Can you explain why you pulled the disk_prefix variable into python code instead of leaving it in the template. It was intentinoally put in the template so that if someone wanted to e.g. not use virtio disks with kvm, they didn't have to patch any code, they could just make a new template, setting the disk_prefix to something else, and point nova at the new template. That seems more awkward now.

It's because ec2 api exposes disk prefix to the users.
For exmample,
euca-run-instances ...
  -b /dev/vda=nodevice
  -b /dev/sdb=snap-00000003
  -b /dev/hdc=ephemeral0

Thus the user can override the predefined devices (e.g. disk prefix + 'a')
or add new disks.
(Using inconsistent disk prefix would be insane. But this shows
the point well, I think. This is just for the explanation)

So the code needs to check if the device specified by the user
overrides the predefined device or not.
The cheetah template syntax isn't expressive enough to check it.

If disk prefix is so important, how about introducing another flag
like libvirt_disk_prefix?
--
yamahata

[lp:~yamahata/nova/boot-from-volume-2]

1333. By Isaku Yamahata on 2011-08-05

merged with nova trunk.

1334. By Isaku Yamahata on 2011-08-05

fix mismerge

[Vish Ishaya (vishvananda)]

My concerns were addressed

review: Approve

[Devin Carlen (devcamcar)]

mine as well!

review: Approve

[Brian Lamar (blamar)]

review: Approve

=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-07-26 20:58:02 +0000
+++ nova/api/ec2/cloud.py	2011-08-05 06:31:22 +0000
@@ -30,6 +30,7 @@
 import time
 import shutil
 
+from nova import block_device
 from nova import compute
 from nova import context
 
@@ -78,6 +79,10 @@
 
 # TODO(yamahata): hypervisor dependent default device name
 _DEFAULT_ROOT_DEVICE_NAME = '/dev/sda1'
+_DEFAULT_MAPPINGS = {'ami': 'sda1',
+                     'ephemeral0': 'sda2',
+                     'root': _DEFAULT_ROOT_DEVICE_NAME,
+                     'swap': 'sda3'}
 
 
 def _parse_block_device_mapping(bdm):
@@ -105,7 +110,7 @@
 
 
 def _properties_get_mappings(properties):
-    return ec2utils.mappings_prepend_dev(properties.get('mappings', []))
+    return block_device.mappings_prepend_dev(properties.get('mappings', []))
 
 
 def _format_block_device_mapping(bdm):
@@ -144,8 +149,7 @@
     """Format multiple BlockDeviceMappingItemType"""
     mappings = [{'virtualName': m['virtual'], 'deviceName': m['device']}
                 for m in _properties_get_mappings(properties)
-                if (m['virtual'] == 'swap' or
-                    m['virtual'].startswith('ephemeral'))]
+                if block_device.is_swap_or_ephemeral(m['virtual'])]
 
     block_device_mapping = [_format_block_device_mapping(bdm) for bdm in
                             properties.get('block_device_mapping', [])]
@@ -233,6 +237,30 @@
             state = 'available'
         return image['properties'].get('image_state', state)
 
+    def _format_instance_mapping(self, ctxt, instance_ref):
+        root_device_name = instance_ref['root_device_name']
+        if root_device_name is None:
+            return _DEFAULT_MAPPINGS
+
+        mappings = {}
+        mappings['ami'] = block_device.strip_dev(root_device_name)
+        mappings['root'] = root_device_name
+
+        # 'ephemeralN' and 'swap'
+        for bdm in db.block_device_mapping_get_all_by_instance(
+            ctxt, instance_ref['id']):
+            if (bdm['volume_id'] or bdm['snapshot_id'] or bdm['no_device']):
+                continue
+
+            virtual_name = bdm['virtual_name']
+            if not virtual_name:
+                continue
+
+            if block_device.is_swap_or_ephemeral(virtual_name):
+                mappings[virtual_name] = bdm['device_name']
+
+        return mappings
+
     def get_metadata(self, address):
         ctxt = context.get_admin_context()
         instance_ref = self.compute_api.get_all(ctxt, fixed_ip=address)
@@ -259,18 +287,14 @@
         security_groups = db.security_group_get_by_instance(ctxt,
                                                             instance_ref['id'])
         security_groups = [x['name'] for x in security_groups]
+        mappings = self._format_instance_mapping(ctxt, instance_ref)
         data = {
-            'user-data': base64.b64decode(instance_ref['user_data']),
+            'user-data': self._format_user_data(instance_ref),
             'meta-data': {
                 'ami-id': image_ec2_id,
                 'ami-launch-index': instance_ref['launch_index'],
                 'ami-manifest-path': 'FIXME',
-                'block-device-mapping': {
-                    # TODO(vish): replace with real data
-                    'ami': 'sda1',
-                    'ephemeral0': 'sda2',
-                    'root': _DEFAULT_ROOT_DEVICE_NAME,
-                    'swap': 'sda3'},
+                'block-device-mapping': mappings,
                 'hostname': hostname,
                 'instance-action': 'none',
                 'instance-id': ec2_id,
@@ -948,13 +972,102 @@
                 'status': volume['attach_status'],
                 'volumeId': ec2utils.id_to_ec2_vol_id(volume_id)}
 
-    def _convert_to_set(self, lst, label):
+    @staticmethod
+    def _convert_to_set(lst, label):
         if lst is None or lst == []:
             return None
         if not isinstance(lst, list):
             lst = [lst]
         return [{label: x} for x in lst]
 
+    def _format_kernel_id(self, instance_ref, result, key):
+        kernel_id = instance_ref['kernel_id']
+        if kernel_id is None:
+            return
+        result[key] = self.image_ec2_id(instance_ref['kernel_id'], 'aki')
+
+    def _format_ramdisk_id(self, instance_ref, result, key):
+        ramdisk_id = instance_ref['ramdisk_id']
+        if ramdisk_id is None:
+            return
+        result[key] = self.image_ec2_id(instance_ref['ramdisk_id'], 'ari')
+
+    @staticmethod
+    def _format_user_data(instance_ref):
+        return base64.b64decode(instance_ref['user_data'])
+
+    def describe_instance_attribute(self, context, instance_id, attribute,
+                                    **kwargs):
+        def _unsupported_attribute(instance, result):
+            raise exception.ApiError(_('attribute not supported: %s') %
+                                     attribute)
+
+        def _format_attr_block_device_mapping(instance, result):
+            tmp = {}
+            self._format_instance_root_device_name(instance, tmp)
+            self._format_instance_bdm(context, instance_id,
+                                      tmp['rootDeviceName'], result)
+
+        def _format_attr_disable_api_termination(instance, result):
+            _unsupported_attribute(instance, result)
+
+        def _format_attr_group_set(instance, result):
+            CloudController._format_group_set(instance, result)
+
+        def _format_attr_instance_initiated_shutdown_behavior(instance,
+                                                               result):
+            state_description = instance['state_description']
+            state_to_value = {'stopping': 'stop',
+                              'stopped': 'stop',
+                              'terminating': 'terminate'}
+            value = state_to_value.get(state_description)
+            if value:
+                result['instanceInitiatedShutdownBehavior'] = value
+
+        def _format_attr_instance_type(instance, result):
+            self._format_instance_type(instance, result)
+
+        def _format_attr_kernel(instance, result):
+            self._format_kernel_id(instance, result, 'kernel')
+
+        def _format_attr_ramdisk(instance, result):
+            self._format_ramdisk_id(instance, result, 'ramdisk')
+
+        def _format_attr_root_device_name(instance, result):
+            self._format_instance_root_device_name(instance, result)
+
+        def _format_attr_source_dest_check(instance, result):
+            _unsupported_attribute(instance, result)
+
+        def _format_attr_user_data(instance, result):
+            result['userData'] = self._format_user_data(instance)
+
+        attribute_formatter = {
+            'blockDeviceMapping': _format_attr_block_device_mapping,
+            'disableApiTermination': _format_attr_disable_api_termination,
+            'groupSet': _format_attr_group_set,
+            'instanceInitiatedShutdownBehavior':
+            _format_attr_instance_initiated_shutdown_behavior,
+            'instanceType': _format_attr_instance_type,
+            'kernel': _format_attr_kernel,
+            'ramdisk': _format_attr_ramdisk,
+            'rootDeviceName': _format_attr_root_device_name,
+            'sourceDestCheck': _format_attr_source_dest_check,
+            'userData': _format_attr_user_data,
+            }
+
+        fn = attribute_formatter.get(attribute)
+        if fn is None:
+            raise exception.ApiError(
+                _('attribute not supported: %s') % attribute)
+
+        ec2_instance_id = instance_id
+        instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
+        instance = self.compute_api.get(context, instance_id)
+        result = {'instance_id': ec2_instance_id}
+        fn(instance, result)
+        return result
+
     def describe_instances(self, context, **kwargs):
         return self._format_describe_instances(context, **kwargs)
 
@@ -1001,6 +1114,27 @@
             result['blockDeviceMapping'] = mapping
         result['rootDeviceType'] = root_device_type
 
+    @staticmethod
+    def _format_instance_root_device_name(instance, result):
+        result['rootDeviceName'] = (instance.get('root_device_name') or
+                                    _DEFAULT_ROOT_DEVICE_NAME)
+
+    @staticmethod
+    def _format_instance_type(instance, result):
+        if instance['instance_type']:
+            result['instanceType'] = instance['instance_type'].get('name')
+        else:
+            result['instanceType'] = None
+
+    @staticmethod
+    def _format_group_set(instance, result):
+        security_group_names = []
+        if instance.get('security_groups'):
+            for security_group in instance['security_groups']:
+                security_group_names.append(security_group['name'])
+        result['groupSet'] = CloudController._convert_to_set(
+            security_group_names, 'groupId')
+
     def _format_instances(self, context, instance_id=None, **kwargs):
         # TODO(termie): this method is poorly named as its name does not imply
         #               that it will be making a variety of database calls
@@ -1026,6 +1160,8 @@
             ec2_id = ec2utils.id_to_ec2_id(instance_id)
             i['instanceId'] = ec2_id
             i['imageId'] = self.image_ec2_id(instance['image_ref'])
+            self._format_kernel_id(instance, i, 'kernelId')
+            self._format_ramdisk_id(instance, i, 'ramdiskId')
             i['instanceState'] = {
                 'code': instance['state'],
                 'name': instance['state_description']}
@@ -1054,16 +1190,12 @@
                     instance['project_id'],
                     instance['host'])
             i['productCodesSet'] = self._convert_to_set([], 'product_codes')
-            if instance['instance_type']:
-                i['instanceType'] = instance['instance_type'].get('name')
-            else:
-                i['instanceType'] = None
+            self._format_instance_type(instance, i)
             i['launchTime'] = instance['created_at']
             i['amiLaunchIndex'] = instance['launch_index']
             i['displayName'] = instance['display_name']
             i['displayDescription'] = instance['display_description']
-            i['rootDeviceName'] = (instance.get('root_device_name') or
-                                   _DEFAULT_ROOT_DEVICE_NAME)
+            self._format_instance_root_device_name(instance, i)
             self._format_instance_bdm(context, instance_id,
                                       i['rootDeviceName'], i)
             host = instance['host']
@@ -1073,12 +1205,7 @@
                 r = {}
                 r['reservationId'] = instance['reservation_id']
                 r['ownerId'] = instance['project_id']
-                security_group_names = []
-                if instance.get('security_groups'):
-                    for security_group in instance['security_groups']:
-                        security_group_names.append(security_group['name'])
-                r['groupSet'] = self._convert_to_set(security_group_names,
-                                                     'groupId')
+                self._format_group_set(instance, r)
                 r['instancesSet'] = []
                 reservations[instance['reservation_id']] = r
             reservations[instance['reservation_id']]['instancesSet'].append(i)
@@ -1314,7 +1441,7 @@
         i['architecture'] = image['properties'].get('architecture')
 
         properties = image['properties']
-        root_device_name = ec2utils.properties_root_device_name(properties)
+        root_device_name = block_device.properties_root_device_name(properties)
         root_device_type = 'instance-store'
         for bdm in properties.get('block_device_mapping', []):
             if (bdm.get('device_name') == root_device_name and
@@ -1387,7 +1514,7 @@
 
         def _root_device_name_attribute(image, result):
             result['rootDeviceName'] = \
-                    ec2utils.properties_root_device_name(image['properties'])
+                block_device.properties_root_device_name(image['properties'])
             if result['rootDeviceName'] is None:
                 result['rootDeviceName'] = _DEFAULT_ROOT_DEVICE_NAME
 
@@ -1520,8 +1647,7 @@
             if virtual_name in ('ami', 'root'):
                 continue
 
-            assert (virtual_name == 'swap' or
-                    virtual_name.startswith('ephemeral'))
+            assert block_device.is_swap_or_ephemeral(virtual_name)
             device_name = m['device']
             if device_name in [b['device_name'] for b in mapping
                                if not b.get('no_device', False)]:

=== modified file 'nova/api/ec2/ec2utils.py'
--- nova/api/ec2/ec2utils.py	2011-06-27 11:20:42 +0000
+++ nova/api/ec2/ec2utils.py	2011-08-05 06:31:22 +0000
@@ -135,32 +135,3 @@
                 args[key] = value
 
     return args
-
-
-def properties_root_device_name(properties):
-    """get root device name from image meta data.
-    If it isn't specified, return None.
-    """
-    root_device_name = None
-
-    # NOTE(yamahata): see image_service.s3.s3create()
-    for bdm in properties.get('mappings', []):
-        if bdm['virtual'] == 'root':
-            root_device_name = bdm['device']
-
-    # NOTE(yamahata): register_image's command line can override
-    #                 <machine>.manifest.xml
-    if 'root_device_name' in properties:
-        root_device_name = properties['root_device_name']
-
-    return root_device_name
-
-
-def mappings_prepend_dev(mappings):
-    """Prepend '/dev/' to 'device' entry of swap/ephemeral virtual type"""
-    for m in mappings:
-        virtual = m['virtual']
-        if ((virtual == 'swap' or virtual.startswith('ephemeral')) and
-            (not m['device'].startswith('/'))):
-            m['device'] = '/dev/' + m['device']
-    return mappings

=== added file 'nova/block_device.py'
--- nova/block_device.py	1970-01-01 00:00:00 +0000
+++ nova/block_device.py	2011-08-05 06:31:22 +0000
@@ -0,0 +1,71 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Isaku Yamahata <yamahata@valinux co jp>
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import re
+
+
+def properties_root_device_name(properties):
+    """get root device name from image meta data.
+    If it isn't specified, return None.
+    """
+    root_device_name = None
+
+    # NOTE(yamahata): see image_service.s3.s3create()
+    for bdm in properties.get('mappings', []):
+        if bdm['virtual'] == 'root':
+            root_device_name = bdm['device']
+
+    # NOTE(yamahata): register_image's command line can override
+    #                 <machine>.manifest.xml
+    if 'root_device_name' in properties:
+        root_device_name = properties['root_device_name']
+
+    return root_device_name
+
+
+_ephemeral = re.compile('^ephemeral(\d|[1-9]\d+)$')
+
+
+def is_ephemeral(device_name):
+    return _ephemeral.match(device_name)
+
+
+def ephemeral_num(ephemeral_name):
+    assert is_ephemeral(ephemeral_name)
+    return int(_ephemeral.sub('\\1', ephemeral_name))
+
+
+def is_swap_or_ephemeral(device_name):
+    return device_name == 'swap' or is_ephemeral(device_name)
+
+
+def mappings_prepend_dev(mappings):
+    """Prepend '/dev/' to 'device' entry of swap/ephemeral virtual type"""
+    for m in mappings:
+        virtual = m['virtual']
+        if (is_swap_or_ephemeral(virtual) and
+            (not m['device'].startswith('/'))):
+            m['device'] = '/dev/' + m['device']
+    return mappings
+
+
+_dev = re.compile('^/dev/')
+
+
+def strip_dev(device_name):
+    """remove leading '/dev/'"""
+    return _dev.sub('', device_name)

=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-08-04 16:26:14 +0000
+++ nova/compute/api.py	2011-08-05 06:31:22 +0000
@@ -22,6 +22,7 @@
 import re
 import time
 
+from nova import block_device
 from nova import db
 from nova import exception
 from nova import flags
@@ -32,7 +33,6 @@
 from nova import rpc
 from nova import utils
 from nova import volume
-from nova.api.ec2 import ec2utils
 from nova.compute import instance_types
 from nova.compute import power_state
 from nova.compute.utils import terminate_volumes
@@ -218,7 +218,7 @@
         if reservation_id is None:
             reservation_id = utils.generate_uid('r')
 
-        root_device_name = ec2utils.properties_root_device_name(
+        root_device_name = block_device.properties_root_device_name(
             image['properties'])
 
         base_options = {
@@ -250,34 +250,64 @@
 
         return (num_instances, base_options, image)
 
-    def _update_image_block_device_mapping(self, elevated_context, instance_id,
+    @staticmethod
+    def _ephemeral_size(instance_type, ephemeral_name):
+        num = block_device.ephemeral_num(ephemeral_name)
+
+        # TODO(yamahata): ephemeralN where N > 0
+        # Only ephemeral0 is allowed for now because InstanceTypes
+        # table only allows single local disk, local_gb.
+        # In order to enhance it, we need to add a new columns to
+        # instance_types table.
+        if num > 0:
+            return 0
+
+        return instance_type.get('local_gb')
+
+    def _update_image_block_device_mapping(self, elevated_context,
+                                           instance_type, instance_id,
                                            mappings):
         """tell vm driver to create ephemeral/swap device at boot time by
         updating BlockDeviceMapping
         """
-        for bdm in ec2utils.mappings_prepend_dev(mappings):
+        instance_type = (instance_type or
+                         instance_types.get_default_instance_type())
+
+        for bdm in block_device.mappings_prepend_dev(mappings):
             LOG.debug(_("bdm %s"), bdm)
 
             virtual_name = bdm['virtual']
             if virtual_name == 'ami' or virtual_name == 'root':
                 continue
 
-            assert (virtual_name == 'swap' or
-                    virtual_name.startswith('ephemeral'))
+            if not block_device.is_swap_or_ephemeral(virtual_name):
+                continue
+
+            size = 0
+            if virtual_name == 'swap':
+                size = instance_type.get('swap', 0)
+            elif block_device.is_ephemeral(virtual_name):
+                size = self._ephemeral_size(instance_type, virtual_name)
+
+            if size == 0:
+                continue
+
             values = {
                 'instance_id': instance_id,
                 'device_name': bdm['device'],
-                'virtual_name': virtual_name, }
+                'virtual_name': virtual_name,
+                'volume_size': size}
             self.db.block_device_mapping_update_or_create(elevated_context,
                                                           values)
 
-    def _update_block_device_mapping(self, elevated_context, instance_id,
+    def _update_block_device_mapping(self, elevated_context,
+                                     instance_type, instance_id,
                                      block_device_mapping):
         """tell vm driver to attach volume at boot time by updating
         BlockDeviceMapping
         """
+        LOG.debug(_("block_device_mapping %s"), block_device_mapping)
         for bdm in block_device_mapping:
-            LOG.debug(_('bdm %s'), bdm)
             assert 'device_name' in bdm
 
             values = {'instance_id': instance_id}
@@ -286,10 +316,18 @@
                         'no_device'):
                 values[key] = bdm.get(key)
 
+            virtual_name = bdm.get('virtual_name')
+            if (virtual_name is not None and
+                block_device.is_ephemeral(virtual_name)):
+                size = self._ephemeral_size(instance_type, virtual_name)
+                if size == 0:
+                    continue
+                values['volume_size'] = size
+
             # NOTE(yamahata): NoDevice eliminates devices defined in image
             #                 files by command line option.
             #                 (--block-device-mapping)
-            if bdm.get('virtual_name') == 'NoDevice':
+            if virtual_name == 'NoDevice':
                 values['no_device'] = True
                 for k in ('delete_on_termination', 'volume_id',
                           'snapshot_id', 'volume_id', 'volume_size',
@@ -299,8 +337,8 @@
             self.db.block_device_mapping_update_or_create(elevated_context,
                                                           values)
 
-    def create_db_entry_for_new_instance(self, context, image, base_options,
-             security_group, block_device_mapping, num=1):
+    def create_db_entry_for_new_instance(self, context, instance_type, image,
+            base_options, security_group, block_device_mapping, num=1):
         """Create an entry in the DB for this new instance,
         including any related table updates (such as security group,
         etc).
@@ -333,12 +371,12 @@
                                                 security_group_id)
 
         # BlockDeviceMapping table
-        self._update_image_block_device_mapping(elevated, instance_id,
-            image['properties'].get('mappings', []))
-        self._update_block_device_mapping(elevated, instance_id,
+        self._update_image_block_device_mapping(elevated, instance_type,
+            instance_id, image['properties'].get('mappings', []))
+        self._update_block_device_mapping(elevated, instance_type, instance_id,
             image['properties'].get('block_device_mapping', []))
         # override via command line option
-        self._update_block_device_mapping(elevated, instance_id,
+        self._update_block_device_mapping(elevated, instance_type, instance_id,
                                           block_device_mapping)
 
         # Set sane defaults if not specified
@@ -453,7 +491,8 @@
         instances = []
         LOG.debug(_("Going to run %s instances..."), num_instances)
         for num in range(num_instances):
-            instance = self.create_db_entry_for_new_instance(context, image,
+            instance = self.create_db_entry_for_new_instance(context,
+                                    instance_type, image,
                                     base_options, security_group,
                                     block_device_mapping, num=num)
             instances.append(instance)

=== modified file 'nova/compute/manager.py'
--- nova/compute/manager.py	2011-08-04 21:32:56 +0000
+++ nova/compute/manager.py	2011-08-05 06:31:22 +0000
@@ -45,6 +45,7 @@
 from eventlet import greenthread
 
 import nova.context
+from nova import block_device
 from nova import exception
 from nova import flags
 import nova.image
@@ -260,6 +261,8 @@
 
         volume_api = volume.API()
         block_device_mapping = []
+        swap = None
+        ephemerals = []
         for bdm in self.db.block_device_mapping_get_all_by_instance(
             context, instance_id):
             LOG.debug(_("setting up bdm %s"), bdm)
@@ -267,11 +270,18 @@
             if bdm['no_device']:
                 continue
             if bdm['virtual_name']:
-                # TODO(yamahata):
-                # block devices for swap and ephemeralN will be
-                # created by virt driver locally in compute node.
-                assert (bdm['virtual_name'] == 'swap' or
-                        bdm['virtual_name'].startswith('ephemeral'))
+                virtual_name = bdm['virtual_name']
+                device_name = bdm['device_name']
+                assert block_device.is_swap_or_ephemeral(virtual_name)
+                if virtual_name == 'swap':
+                    swap = {'device_name': device_name,
+                            'swap_size': bdm['volume_size']}
+                elif block_device.is_ephemeral(virtual_name):
+                    eph = {'num': block_device.ephemeral_num(virtual_name),
+                           'virtual_name': virtual_name,
+                           'device_name': device_name,
+                           'size': bdm['volume_size']}
+                    ephemerals.append(eph)
                 continue
 
             if ((bdm['snapshot_id'] is not None) and
@@ -307,7 +317,7 @@
                                              'mount_device':
                                              bdm['device_name']})
 
-        return block_device_mapping
+        return (swap, ephemerals, block_device_mapping)
 
     def _run_instance(self, context, instance_id, **kwargs):
         """Launch a new instance with specified options."""
@@ -348,13 +358,21 @@
                 # all vif creation and network injection, maybe this is correct
                 network_info = []
 
-            bd_mapping = self._setup_block_device_mapping(context, instance_id)
+            (swap, ephemerals,
+             block_device_mapping) = self._setup_block_device_mapping(
+                context, instance_id)
+            block_device_info = {
+                'root_device_name': instance['root_device_name'],
+                'swap': swap,
+                'ephemerals': ephemerals,
+                'block_device_mapping': block_device_mapping}
 
             # TODO(vish) check to make sure the availability zone matches
             self._update_state(context, instance_id, power_state.BUILDING)
 
             try:
-                self.driver.spawn(context, instance, network_info, bd_mapping)
+                self.driver.spawn(context, instance,
+                                  network_info, block_device_info)
             except Exception as ex:  # pylint: disable=W0702
                 msg = _("Instance '%(instance_id)s' failed to spawn. Is "
                         "virtualization enabled in the BIOS? Details: "

=== modified file 'nova/db/sqlalchemy/api.py'
--- nova/db/sqlalchemy/api.py	2011-08-03 23:17:08 +0000
+++ nova/db/sqlalchemy/api.py	2011-08-05 06:31:22 +0000
@@ -20,6 +20,7 @@
 """
 import warnings
 
+from nova import block_device
 from nova import db
 from nova import exception
 from nova import flags
@@ -1681,7 +1682,9 @@
     session = get_session()
     result = session.query(models.Network).\
                 filter(or_(models.Network.cidr == cidr,
-                           models.Network.cidr_v6 == cidr)).first()
+                           models.Network.cidr_v6 == cidr)).\
+                filter_by(deleted=False).\
+                first()
 
     if not result:
         raise exception.NetworkNotFoundForCidr(cidr=cidr)
@@ -2265,6 +2268,20 @@
         else:
             result.update(values)
 
+        # NOTE(yamahata): same virtual device name can be specified multiple
+        #                 times. So delete the existing ones.
+        virtual_name = values['virtual_name']
+        if (virtual_name is not None and
+            block_device.is_swap_or_ephemeral(virtual_name)):
+            session.query(models.BlockDeviceMapping).\
+            filter_by(instance_id=values['instance_id']).\
+            filter_by(virtual_name=virtual_name).\
+            filter(models.BlockDeviceMapping.device_name !=
+                   values['device_name']).\
+            update({'deleted': True,
+                    'deleted_at': utils.utcnow(),
+                    'updated_at': literal_column('updated_at')})
+
 
 @require_context
 def block_device_mapping_get_all_by_instance(context, instance_id):

=== modified file 'nova/image/glance.py'
--- nova/image/glance.py	2011-08-01 18:59:29 +0000
+++ nova/image/glance.py	2011-08-05 06:31:22 +0000
@@ -19,7 +19,9 @@
 
 from __future__ import absolute_import
 
+import copy
 import datetime
+import json
 import random
 
 from glance.common import exception as glance_exception
@@ -194,6 +196,7 @@
         self._set_client_context(context)
         # NOTE(vish): show is to check if image is available
         self.show(context, image_id)
+        image_meta = _convert_to_string(image_meta)
         try:
             image_meta = self.client.update_image(image_id, image_meta, data)
         except glance_exception.NotFound:
@@ -222,11 +225,19 @@
         pass
 
     @classmethod
+    def _translate_to_service(cls, image_meta):
+        image_meta = super(GlanceImageService,
+                           cls)._translate_to_service(image_meta)
+        image_meta = _convert_to_string(image_meta)
+        return image_meta
+
+    @classmethod
     def _translate_to_base(cls, image_meta):
         """Override translation to handle conversion to datetime objects."""
         image_meta = service.BaseImageService._propertify_metadata(
                         image_meta, cls.SERVICE_IMAGE_ATTRS)
         image_meta = _convert_timestamps_to_datetimes(image_meta)
+        image_meta = _convert_from_string(image_meta)
         return image_meta
 
 
@@ -252,3 +263,38 @@
 
     raise ValueError(_('%(timestamp)s does not follow any of the '
                        'signatures: %(ISO_FORMATS)s') % locals())
+
+
+# TODO(yamahata): use block-device-mapping extension to glance
+def _json_loads(properties, attr):
+    prop = properties[attr]
+    if isinstance(prop, basestring):
+        properties[attr] = json.loads(prop)
+
+
+def _json_dumps(properties, attr):
+    prop = properties[attr]
+    if not isinstance(prop, basestring):
+        properties[attr] = json.dumps(prop)
+
+
+_CONVERT_PROPS = ('block_device_mapping', 'mappings')
+
+
+def _convert(method, metadata):
+    metadata = copy.deepcopy(metadata)  # don't touch original metadata
+    properties = metadata.get('properties')
+    if properties:
+        for attr in _CONVERT_PROPS:
+            if attr in properties:
+                method(properties, attr)
+
+    return metadata
+
+
+def _convert_from_string(metadata):
+    return _convert(_json_loads, metadata)
+
+
+def _convert_to_string(metadata):
+    return _convert(_json_dumps, metadata)

=== modified file 'nova/tests/image/test_glance.py'
--- nova/tests/image/test_glance.py	2011-07-25 22:38:59 +0000
+++ nova/tests/image/test_glance.py	2011-08-05 06:31:22 +0000
@@ -235,3 +235,39 @@
                    'updated_at': None,
                    'deleted_at': None}
         return fixture
+
+
+class TestGlanceSerializer(unittest.TestCase):
+    def test_serialize(self):
+        metadata = {'name': 'image1',
+                    'is_public': True,
+                    'foo': 'bar',
+                    'properties': {
+                        'prop1': 'propvalue1',
+                        'mappings': [
+                            {'virtual': 'aaa',
+                             'device': 'bbb'},
+                            {'virtual': 'xxx',
+                             'device': 'yyy'}],
+                        'block_device_mapping': [
+                            {'virtual_device': 'fake',
+                             'device_name': '/dev/fake'},
+                            {'virtual_device': 'ephemeral0',
+                             'device_name': '/dev/fake0'}]}}
+
+        converted_expected = {
+            'name': 'image1',
+            'is_public': True,
+            'foo': 'bar',
+            'properties': {
+                'prop1': 'propvalue1',
+                'mappings':
+                '[{"device": "bbb", "virtual": "aaa"}, '
+                '{"device": "yyy", "virtual": "xxx"}]',
+                'block_device_mapping':
+                '[{"virtual_device": "fake", "device_name": "/dev/fake"}, '
+                '{"virtual_device": "ephemeral0", '
+                '"device_name": "/dev/fake0"}]'}}
+        converted = glance._convert_to_string(metadata)
+        self.assertEqual(converted, converted_expected)
+        self.assertEqual(glance._convert_from_string(converted), metadata)

=== modified file 'nova/tests/test_api.py'
--- nova/tests/test_api.py	2011-07-28 01:17:21 +0000
+++ nova/tests/test_api.py	2011-08-05 06:31:22 +0000
@@ -27,6 +27,7 @@
 import StringIO
 import webob
 
+from nova import block_device
 from nova import context
 from nova import exception
 from nova import test
@@ -147,10 +148,12 @@
         properties0 = {'mappings': mappings}
         properties1 = {'root_device_name': '/dev/sdb', 'mappings': mappings}
 
-        root_device_name = ec2utils.properties_root_device_name(properties0)
+        root_device_name = block_device.properties_root_device_name(
+            properties0)
         self.assertEqual(root_device_name, '/dev/sda1')
 
-        root_device_name = ec2utils.properties_root_device_name(properties1)
+        root_device_name = block_device.properties_root_device_name(
+            properties1)
         self.assertEqual(root_device_name, '/dev/sdb')
 
     def test_mapping_prepend_dev(self):
@@ -184,7 +187,7 @@
              'device': '/dev/sdc1'},
             {'virtual': 'ephemeral1',
              'device': '/dev/sdc1'}]
-        self.assertDictListMatch(ec2utils.mappings_prepend_dev(mappings),
+        self.assertDictListMatch(block_device.mappings_prepend_dev(mappings),
                                  expected_result)
 
 

=== added file 'nova/tests/test_block_device.py'
--- nova/tests/test_block_device.py	1970-01-01 00:00:00 +0000
+++ nova/tests/test_block_device.py	2011-08-05 06:31:22 +0000
@@ -0,0 +1,87 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Isaku Yamahata
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Tests for Block Device utility functions.
+"""
+
+from nova import block_device
+from nova import test
+
+
+class BlockDeviceTestCase(test.TestCase):
+    def test_properties(self):
+        root_device0 = '/dev/sda'
+        root_device1 = '/dev/sdb'
+        mappings = [{'virtual': 'root',
+                     'device': root_device0}]
+
+        properties0 = {'mappings': mappings}
+        properties1 = {'mappings': mappings,
+                       'root_device_name': root_device1}
+
+        self.assertEqual(block_device.properties_root_device_name({}), None)
+        self.assertEqual(
+            block_device.properties_root_device_name(properties0),
+            root_device0)
+        self.assertEqual(
+            block_device.properties_root_device_name(properties1),
+            root_device1)
+
+    def test_ephemeral(self):
+        self.assertFalse(block_device.is_ephemeral('ephemeral'))
+        self.assertTrue(block_device.is_ephemeral('ephemeral0'))
+        self.assertTrue(block_device.is_ephemeral('ephemeral1'))
+        self.assertTrue(block_device.is_ephemeral('ephemeral11'))
+        self.assertFalse(block_device.is_ephemeral('root'))
+        self.assertFalse(block_device.is_ephemeral('swap'))
+        self.assertFalse(block_device.is_ephemeral('/dev/sda1'))
+
+        self.assertEqual(block_device.ephemeral_num('ephemeral0'), 0)
+        self.assertEqual(block_device.ephemeral_num('ephemeral1'), 1)
+        self.assertEqual(block_device.ephemeral_num('ephemeral11'), 11)
+
+        self.assertFalse(block_device.is_swap_or_ephemeral('ephemeral'))
+        self.assertTrue(block_device.is_swap_or_ephemeral('ephemeral0'))
+        self.assertTrue(block_device.is_swap_or_ephemeral('ephemeral1'))
+        self.assertTrue(block_device.is_swap_or_ephemeral('swap'))
+        self.assertFalse(block_device.is_swap_or_ephemeral('root'))
+        self.assertFalse(block_device.is_swap_or_ephemeral('/dev/sda1'))
+
+    def test_mappings_prepend_dev(self):
+        mapping = [
+            {'virtual': 'ami', 'device': '/dev/sda'},
+            {'virtual': 'root', 'device': 'sda'},
+            {'virtual': 'ephemeral0', 'device': 'sdb'},
+            {'virtual': 'swap', 'device': 'sdc'},
+            {'virtual': 'ephemeral1', 'device': 'sdd'},
+            {'virtual': 'ephemeral2', 'device': 'sde'}]
+
+        expected = [
+            {'virtual': 'ami', 'device': '/dev/sda'},
+            {'virtual': 'root', 'device': 'sda'},
+            {'virtual': 'ephemeral0', 'device': '/dev/sdb'},
+            {'virtual': 'swap', 'device': '/dev/sdc'},
+            {'virtual': 'ephemeral1', 'device': '/dev/sdd'},
+            {'virtual': 'ephemeral2', 'device': '/dev/sde'}]
+
+        prepended = block_device.mappings_prepend_dev(mapping)
+        self.assertEqual(prepended.sort(), expected.sort())
+
+    def test_strip_dev(self):
+        self.assertEqual(block_device.strip_dev('/dev/sda'), 'sda')
+        self.assertEqual(block_device.strip_dev('sda'), 'sda')

=== modified file 'nova/tests/test_cloud.py'
--- nova/tests/test_cloud.py	2011-08-03 21:13:37 +0000
+++ nova/tests/test_cloud.py	2011-08-05 06:31:22 +0000
@@ -17,6 +17,8 @@
 #    under the License.
 import mox
 
+import functools
+
 from base64 import b64decode
 from M2Crypto import BIO
 from M2Crypto import RSA
@@ -892,13 +894,16 @@
     def test_modify_image_attribute(self):
         modify_image_attribute = self.cloud.modify_image_attribute
 
+        fake_metadata = {'id': 1, 'container_format': 'ami',
+                         'properties': {'kernel_id': 1, 'ramdisk_id': 1,
+                                        'type': 'machine'}, 'is_public': False}
+
         def fake_show(meh, context, id):
-            return {'id': 1, 'container_format': 'ami',
-                    'properties': {'kernel_id': 1, 'ramdisk_id': 1,
-                    'type': 'machine'}, 'is_public': False}
+            return fake_metadata
 
         def fake_update(meh, context, image_id, metadata, data=None):
-            return metadata
+            fake_metadata.update(metadata)
+            return fake_metadata
 
         self.stubs.Set(fake._FakeImageService, 'show', fake_show)
         self.stubs.Set(fake._FakeImageService, 'show_by_name', fake_show)
@@ -1464,3 +1469,147 @@
         # TODO(yamahata): clean up snapshot created by CreateImage.
 
         self._restart_compute_service()
+
+    @staticmethod
+    def _fake_bdm_get(ctxt, id):
+            return [{'volume_id': 87654321,
+                     'snapshot_id': None,
+                     'no_device': None,
+                     'virtual_name': None,
+                     'delete_on_termination': True,
+                     'device_name': '/dev/sdh'},
+                    {'volume_id': None,
+                     'snapshot_id': 98765432,
+                     'no_device': None,
+                     'virtual_name': None,
+                     'delete_on_termination': True,
+                     'device_name': '/dev/sdi'},
+                    {'volume_id': None,
+                     'snapshot_id': None,
+                     'no_device': True,
+                     'virtual_name': None,
+                     'delete_on_termination': None,
+                     'device_name': None},
+                    {'volume_id': None,
+                     'snapshot_id': None,
+                     'no_device': None,
+                     'virtual_name': 'ephemeral0',
+                     'delete_on_termination': None,
+                     'device_name': '/dev/sdb'},
+                    {'volume_id': None,
+                     'snapshot_id': None,
+                     'no_device': None,
+                     'virtual_name': 'swap',
+                     'delete_on_termination': None,
+                     'device_name': '/dev/sdc'},
+                    {'volume_id': None,
+                     'snapshot_id': None,
+                     'no_device': None,
+                     'virtual_name': 'ephemeral1',
+                     'delete_on_termination': None,
+                     'device_name': '/dev/sdd'},
+                    {'volume_id': None,
+                     'snapshot_id': None,
+                     'no_device': None,
+                     'virtual_name': 'ephemeral2',
+                     'delete_on_termination': None,
+                     'device_name': '/dev/sd3'},
+                    ]
+
+    def test_get_instance_mapping(self):
+        """Make sure that _get_instance_mapping works"""
+        ctxt = None
+        instance_ref0 = {'id': 0,
+                         'root_device_name': None}
+        instance_ref1 = {'id': 0,
+                         'root_device_name': '/dev/sda1'}
+
+        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
+                       self._fake_bdm_get)
+
+        expected = {'ami': 'sda1',
+                    'root': '/dev/sda1',
+                    'ephemeral0': '/dev/sdb',
+                    'swap': '/dev/sdc',
+                    'ephemeral1': '/dev/sdd',
+                    'ephemeral2': '/dev/sd3'}
+
+        self.assertEqual(self.cloud._format_instance_mapping(ctxt,
+                                                             instance_ref0),
+                         cloud._DEFAULT_MAPPINGS)
+        self.assertEqual(self.cloud._format_instance_mapping(ctxt,
+                                                             instance_ref1),
+                         expected)
+
+    def test_describe_instance_attribute(self):
+        """Make sure that describe_instance_attribute works"""
+        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
+                       self._fake_bdm_get)
+
+        def fake_get(ctxt, instance_id):
+            return {
+                'id': 0,
+                'root_device_name': '/dev/sdh',
+                'security_groups': [{'name': 'fake0'}, {'name': 'fake1'}],
+                'state_description': 'stopping',
+                'instance_type': {'name': 'fake_type'},
+                'kernel_id': 1,
+                'ramdisk_id': 2,
+                'user_data': 'fake-user data',
+                }
+        self.stubs.Set(self.cloud.compute_api, 'get', fake_get)
+
+        def fake_volume_get(ctxt, volume_id, session=None):
+            if volume_id == 87654321:
+                return {'id': volume_id,
+                        'attach_time': '13:56:24',
+                        'status': 'in-use'}
+            raise exception.VolumeNotFound(volume_id=volume_id)
+        self.stubs.Set(db.api, 'volume_get', fake_volume_get)
+
+        get_attribute = functools.partial(
+            self.cloud.describe_instance_attribute,
+            self.context, 'i-12345678')
+
+        bdm = get_attribute('blockDeviceMapping')
+        bdm['blockDeviceMapping'].sort()
+
+        expected_bdm = {'instance_id': 'i-12345678',
+                        'rootDeviceType': 'ebs',
+                        'blockDeviceMapping': [
+                            {'deviceName': '/dev/sdh',
+                             'ebs': {'status': 'in-use',
+                                     'deleteOnTermination': True,
+                                     'volumeId': 87654321,
+                                     'attachTime': '13:56:24'}}]}
+        expected_bdm['blockDeviceMapping'].sort()
+        self.assertEqual(bdm, expected_bdm)
+        # NOTE(yamahata): this isn't supported
+        # get_attribute('disableApiTermination')
+        groupSet = get_attribute('groupSet')
+        groupSet['groupSet'].sort()
+        expected_groupSet = {'instance_id': 'i-12345678',
+                             'groupSet': [{'groupId': 'fake0'},
+                                          {'groupId': 'fake1'}]}
+        expected_groupSet['groupSet'].sort()
+        self.assertEqual(groupSet, expected_groupSet)
+        self.assertEqual(get_attribute('instanceInitiatedShutdownBehavior'),
+                         {'instance_id': 'i-12345678',
+                          'instanceInitiatedShutdownBehavior': 'stop'})
+        self.assertEqual(get_attribute('instanceType'),
+                         {'instance_id': 'i-12345678',
+                          'instanceType': 'fake_type'})
+        self.assertEqual(get_attribute('kernel'),
+                         {'instance_id': 'i-12345678',
+                          'kernel': 'aki-00000001'})
+        self.assertEqual(get_attribute('ramdisk'),
+                         {'instance_id': 'i-12345678',
+                          'ramdisk': 'ari-00000002'})
+        self.assertEqual(get_attribute('rootDeviceName'),
+                         {'instance_id': 'i-12345678',
+                          'rootDeviceName': '/dev/sdh'})
+        # NOTE(yamahata): this isn't supported
+        # get_attribute('sourceDestCheck')
+        self.assertEqual(get_attribute('userData'),
+                         {'instance_id': 'i-12345678',
+                          'userData': '}\xa9\x1e\xba\xc7\xabu\xabZ'})

=== modified file 'nova/tests/test_compute.py'
--- nova/tests/test_compute.py	2011-08-03 11:31:10 +0000
+++ nova/tests/test_compute.py	2011-08-05 06:31:22 +0000
@@ -877,15 +877,17 @@
         return bdm
 
     def test_update_block_device_mapping(self):
+        swap_size = 1
+        instance_type = {'swap': swap_size}
         instance_id = self._create_instance()
         mappings = [
                 {'virtual': 'ami', 'device': 'sda1'},
                 {'virtual': 'root', 'device': '/dev/sda1'},
 
+                {'virtual': 'swap', 'device': 'sdb4'},
+                {'virtual': 'swap', 'device': 'sdb3'},
+                {'virtual': 'swap', 'device': 'sdb2'},
                 {'virtual': 'swap', 'device': 'sdb1'},
-                {'virtual': 'swap', 'device': 'sdb2'},
-                {'virtual': 'swap', 'device': 'sdb3'},
-                {'virtual': 'swap', 'device': 'sdb4'},
 
                 {'virtual': 'ephemeral0', 'device': 'sdc1'},
                 {'virtual': 'ephemeral1', 'device': 'sdc2'},
@@ -927,32 +929,36 @@
                  'no_device': True}]
 
         self.compute_api._update_image_block_device_mapping(
-            self.context, instance_id, mappings)
+            self.context, instance_type, instance_id, mappings)
 
         bdms = [self._parse_db_block_device_mapping(bdm_ref)
                 for bdm_ref in db.block_device_mapping_get_all_by_instance(
                     self.context, instance_id)]
         expected_result = [
-            {'virtual_name': 'swap', 'device_name': '/dev/sdb1'},
-            {'virtual_name': 'swap', 'device_name': '/dev/sdb2'},
-            {'virtual_name': 'swap', 'device_name': '/dev/sdb3'},
-            {'virtual_name': 'swap', 'device_name': '/dev/sdb4'},
+            {'virtual_name': 'swap', 'device_name': '/dev/sdb1',
+             'volume_size': swap_size},
             {'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1'},
-            {'virtual_name': 'ephemeral1', 'device_name': '/dev/sdc2'},
-            {'virtual_name': 'ephemeral2', 'device_name': '/dev/sdc3'}]
+
+            # NOTE(yamahata): ATM only ephemeral0 is supported.
+            #                 they're ignored for now
+            #{'virtual_name': 'ephemeral1', 'device_name': '/dev/sdc2'},
+            #{'virtual_name': 'ephemeral2', 'device_name': '/dev/sdc3'}
+            ]
         bdms.sort()
         expected_result.sort()
         self.assertDictListMatch(bdms, expected_result)
 
         self.compute_api._update_block_device_mapping(
-            self.context, instance_id, block_device_mapping)
+            self.context, instance_types.get_default_instance_type(),
+            instance_id, block_device_mapping)
         bdms = [self._parse_db_block_device_mapping(bdm_ref)
                 for bdm_ref in db.block_device_mapping_get_all_by_instance(
                     self.context, instance_id)]
         expected_result = [
             {'snapshot_id': 0x12345678, 'device_name': '/dev/sda1'},
 
-            {'virtual_name': 'swap', 'device_name': '/dev/sdb1'},
+            {'virtual_name': 'swap', 'device_name': '/dev/sdb1',
+             'volume_size': swap_size},
             {'snapshot_id': 0x23456789, 'device_name': '/dev/sdb2'},
             {'snapshot_id': 0x3456789A, 'device_name': '/dev/sdb3'},
             {'no_device': True, 'device_name': '/dev/sdb4'},
@@ -974,3 +980,13 @@
             self.context, instance_id):
             db.block_device_mapping_destroy(self.context, bdm['id'])
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_ephemeral_size(self):
+        local_size = 2
+        inst_type = {'local_gb': local_size}
+        self.assertEqual(self.compute_api._ephemeral_size(inst_type,
+                                                          'ephemeral0'),
+                         local_size)
+        self.assertEqual(self.compute_api._ephemeral_size(inst_type,
+                                                          'ephemeral1'),
+                         0)

=== modified file 'nova/tests/test_libvirt.py'
--- nova/tests/test_libvirt.py	2011-08-03 19:22:58 +0000
+++ nova/tests/test_libvirt.py	2011-08-05 06:31:22 +0000
@@ -169,6 +169,7 @@
                      'project_id':    'fake',
                      'bridge':        'br101',
                      'image_ref':     '123456',
+                     'local_gb':      20,
                      'instance_type_id': '5'}  # m1.small
 
     def lazy_load_library_exists(self):
@@ -744,6 +745,42 @@
         ip = conn.get_host_ip_addr()
         self.assertEquals(ip, FLAGS.my_ip)
 
+    def test_volume_in_mapping(self):
+        conn = connection.LibvirtConnection(False)
+        swap = {'device_name': '/dev/sdb',
+                'swap_size': 1}
+        ephemerals = [{'num': 0,
+                       'virtual_name': 'ephemeral0',
+                       'device_name': '/dev/sdc1',
+                       'size': 1},
+                      {'num': 2,
+                       'virtual_name': 'ephemeral2',
+                       'device_name': '/dev/sdd',
+                       'size': 1}]
+        block_device_mapping = [{'mount_device': '/dev/sde',
+                                 'device_path': 'fake_device'},
+                                {'mount_device': '/dev/sdf',
+                                 'device_path': 'fake_device'}]
+        block_device_info = {
+                'root_device_name': '/dev/sda',
+                'swap': swap,
+                'ephemerals': ephemerals,
+                'block_device_mapping': block_device_mapping}
+
+        def _assert_volume_in_mapping(device_name, true_or_false):
+            self.assertEquals(conn._volume_in_mapping(device_name,
+                                                      block_device_info),
+                              true_or_false)
+
+        _assert_volume_in_mapping('sda', False)
+        _assert_volume_in_mapping('sdb', True)
+        _assert_volume_in_mapping('sdc1', True)
+        _assert_volume_in_mapping('sdd', True)
+        _assert_volume_in_mapping('sde', True)
+        _assert_volume_in_mapping('sdf', True)
+        _assert_volume_in_mapping('sdg', False)
+        _assert_volume_in_mapping('sdh1', False)
+
 
 class NWFilterFakes:
     def __init__(self):

=== modified file 'nova/tests/test_metadata.py'
--- nova/tests/test_metadata.py	2011-06-27 13:58:17 +0000
+++ nova/tests/test_metadata.py	2011-08-05 06:31:22 +0000
@@ -43,6 +43,7 @@
                          'reservation_id': 'r-xxxxxxxx',
                          'user_data': '',
                          'image_ref': 7,
+                         'root_device_name': '/dev/sda1',
                          'hostname': 'test'})
 
         def instance_get(*args, **kwargs):

=== added file 'nova/tests/test_virt.py'
--- nova/tests/test_virt.py	1970-01-01 00:00:00 +0000
+++ nova/tests/test_virt.py	2011-08-05 06:31:22 +0000
@@ -0,0 +1,83 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Isaku Yamahata
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova import flags
+from nova import test
+from nova.virt import driver
+
+FLAGS = flags.FLAGS
+
+
+class TestVirtDriver(test.TestCase):
+    def test_block_device(self):
+        swap = {'device_name': '/dev/sdb',
+                'swap_size': 1}
+        ephemerals = [{'num': 0,
+                       'virtual_name': 'ephemeral0',
+                       'device_name': '/dev/sdc1',
+                       'size': 1}]
+        block_device_mapping = [{'mount_device': '/dev/sde',
+                                 'device_path': 'fake_device'}]
+        block_device_info = {
+                'root_device_name': '/dev/sda',
+                'swap': swap,
+                'ephemerals': ephemerals,
+                'block_device_mapping': block_device_mapping}
+
+        empty_block_device_info = {}
+
+        self.assertEqual(
+            driver.block_device_info_get_root(block_device_info), '/dev/sda')
+        self.assertEqual(
+            driver.block_device_info_get_root(empty_block_device_info), None)
+        self.assertEqual(
+            driver.block_device_info_get_root(None), None)
+
+        self.assertEqual(
+            driver.block_device_info_get_swap(block_device_info), swap)
+        self.assertEqual(driver.block_device_info_get_swap(
+            empty_block_device_info)['device_name'], None)
+        self.assertEqual(driver.block_device_info_get_swap(
+            empty_block_device_info)['swap_size'], 0)
+        self.assertEqual(
+            driver.block_device_info_get_swap({'swap': None})['device_name'],
+            None)
+        self.assertEqual(
+            driver.block_device_info_get_swap({'swap': None})['swap_size'],
+            0)
+        self.assertEqual(
+            driver.block_device_info_get_swap(None)['device_name'], None)
+        self.assertEqual(
+            driver.block_device_info_get_swap(None)['swap_size'], 0)
+
+        self.assertEqual(
+            driver.block_device_info_get_ephemerals(block_device_info),
+            ephemerals)
+        self.assertEqual(
+            driver.block_device_info_get_ephemerals(empty_block_device_info),
+            [])
+        self.assertEqual(
+            driver.block_device_info_get_ephemerals(None),
+            [])
+
+    def test_swap_is_usable(self):
+        self.assertFalse(driver.swap_is_usable(None))
+        self.assertFalse(driver.swap_is_usable({'device_name': None}))
+        self.assertFalse(driver.swap_is_usable({'device_name': '/dev/sdb',
+                                                'swap_size': 0}))
+        self.assertTrue(driver.swap_is_usable({'device_name': '/dev/sdb',
+                                                'swap_size': 1}))

=== modified file 'nova/virt/driver.py'
--- nova/virt/driver.py	2011-07-29 21:58:27 +0000
+++ nova/virt/driver.py	2011-08-05 06:31:22 +0000
@@ -32,6 +32,33 @@
         self.state = state
 
 
+def block_device_info_get_root(block_device_info):
+    block_device_info = block_device_info or {}
+    return block_device_info.get('root_device_name')
+
+
+def block_device_info_get_swap(block_device_info):
+    block_device_info = block_device_info or {}
+    return block_device_info.get('swap') or {'device_name': None,
+                                             'swap_size': 0}
+
+
+def swap_is_usable(swap):
+    return swap and swap['device_name'] and swap['swap_size'] > 0
+
+
+def block_device_info_get_ephemerals(block_device_info):
+    block_device_info = block_device_info or {}
+    ephemerals = block_device_info.get('ephemerals') or []
+    return ephemerals
+
+
+def block_device_info_get_mapping(block_device_info):
+    block_device_info = block_device_info or {}
+    block_device_mapping = block_device_info.get('block_device_mapping') or []
+    return block_device_mapping
+
+
 class ComputeDriver(object):
     """Base class for compute drivers.
 
@@ -65,8 +92,8 @@
         # TODO(Vek): Need to pass context in for access to auth_token
         raise NotImplementedError()
 
-    def spawn(self, context, instance, network_info,
-              block_device_mapping=None):
+    def spawn(self, context, instance,
+              network_info=None, block_device_info=None):
         """Launch a VM for the specified instance"""
         raise NotImplementedError()
 

=== modified file 'nova/virt/fake.py'
--- nova/virt/fake.py	2011-08-02 21:45:57 +0000
+++ nova/virt/fake.py	2011-08-05 06:31:22 +0000
@@ -129,8 +129,8 @@
             info_list.append(self._map_to_instance_info(instance))
         return info_list
 
-    def spawn(self, context, instance, network_info,
-              block_device_mapping=None):
+    def spawn(self, context, instance,
+              network_info=None, block_device_info=None):
         """
         Create a new instance/VM/domain on the virtualization platform.
 

=== modified file 'nova/virt/hyperv.py'
--- nova/virt/hyperv.py	2011-07-29 21:58:27 +0000
+++ nova/virt/hyperv.py	2011-08-05 06:31:22 +0000
@@ -138,8 +138,8 @@
 
         return instance_infos
 
-    def spawn(self, context, instance, network_info,
-              block_device_mapping=None):
+    def spawn(self, context, instance,
+              network_info=None, block_device_info=None):
         """ Create a new VM and start it."""
         vm = self._lookup(instance.name)
         if vm is not None:

=== modified file 'nova/virt/libvirt.xml.template'
--- nova/virt/libvirt.xml.template	2011-07-26 00:41:55 +0000
+++ nova/virt/libvirt.xml.template	2011-08-05 06:31:22 +0000
@@ -3,24 +3,22 @@
     <memory>${memory_kb}</memory>
     <os>
 #if $type == 'lxc'
-    #set $disk_prefix = ''
     #set $disk_bus = ''
         <type>exe</type>
         <init>/sbin/init</init>
 #else if $type == 'uml'
-    #set $disk_prefix = 'ubd'
     #set $disk_bus = 'uml'
         <type>uml</type>
         <kernel>/usr/bin/linux</kernel>
-        <root>/dev/ubda</root>
+        #set $root_device_name = $getVar('root_device_name', '/dev/ubda')
+        <root>${root_device_name}</root>
 #else
     #if $type == 'xen'
-        #set $disk_prefix = 'sd'
         #set $disk_bus = 'scsi'
             <type>linux</type>
-            <root>/dev/xvda</root>
+            #set $root_device_name = $getVar('root_device_name', '/dev/xvda')
+            <root>${root_device_name}</root>
     #else
-        #set $disk_prefix = 'vd'
         #set $disk_bus = 'virtio'
             <type>hvm</type>
     #end if
@@ -33,7 +31,8 @@
             #if $type == 'xen'
                 <cmdline>ro</cmdline>
             #else
-                <cmdline>root=/dev/vda console=ttyS0</cmdline>
+                #set $root_device_name = $getVar('root_device_name', '/dev/vda')
+                <cmdline>root=${root_device_name} console=ttyS0</cmdline>
             #end if
             #if $getVar('ramdisk', None)
                 <initrd>${ramdisk}</initrd>
@@ -71,16 +70,30 @@
         <disk type='file'>
             <driver type='${driver_type}'/>
             <source file='${basepath}/disk'/>
-            <target dev='${disk_prefix}a' bus='${disk_bus}'/>
+            <target dev='${root_device}' bus='${disk_bus}'/>
         </disk>
         #end if
-        #if $getVar('local', False)
+        #if $getVar('local_device', False)
             <disk type='file'>
                 <driver type='${driver_type}'/>
                 <source file='${basepath}/disk.local'/>
-                <target dev='${disk_prefix}b' bus='${disk_bus}'/>
+                <target dev='${local_device}' bus='${disk_bus}'/>
             </disk>
         #end if
+	#for $eph in $ephemerals
+	     <disk type='block'>
+                <driver type='${driver_type}'/>
+                <source dev='${basepath}/${eph.device_path}'/>
+                <target dev='${eph.device}' bus='${disk_bus}'/>
+	     </disk>
+	#end for
+	#if $getVar('swap_device', False)
+            <disk type='file'>
+                <driver type='${driver_type}'/>
+                <source file='${basepath}/disk.swap'/>
+                <target dev='${swap_device}' bus='${disk_bus}'/>
+            </disk>
+	#end if
         #for $vol in $volumes
             <disk type='${vol.type}'>
                 <driver type='raw'/>

=== modified file 'nova/virt/libvirt/connection.py'
--- nova/virt/libvirt/connection.py	2011-08-05 02:22:13 +0000
+++ nova/virt/libvirt/connection.py	2011-08-05 06:31:22 +0000
@@ -54,6 +54,7 @@
 from eventlet import greenthread
 from eventlet import tpool
 
+from nova import block_device
 from nova import context as nova_context
 from nova import db
 from nova import exception
@@ -151,8 +152,8 @@
         Template = t.Template
 
 
-def _strip_dev(mount_path):
-        return re.sub(r'^/dev/', '', mount_path)
+def _get_eph_disk(ephemeral):
+    return 'disk.eph' + str(ephemeral['num'])
 
 
 class LibvirtConnection(driver.ComputeDriver):
@@ -570,15 +571,14 @@
     # NOTE(ilyaalekseyev): Implementation like in multinics
     # for xenapi(tr3buchet)
     @exception.wrap_exception()
-    def spawn(self, context, instance, network_info,
-              block_device_mapping=None):
+    def spawn(self, context, instance,
+              network_info=None, block_device_info=None):
         xml = self.to_xml(instance, False, network_info=network_info,
-                          block_device_mapping=block_device_mapping)
-        block_device_mapping = block_device_mapping or []
+                          block_device_info=block_device_info)
         self.firewall_driver.setup_basic_filtering(instance, network_info)
         self.firewall_driver.prepare_instance_filter(instance, network_info)
         self._create_image(context, instance, xml, network_info=network_info,
-                           block_device_mapping=block_device_mapping)
+                           block_device_info=block_device_info)
         domain = self._create_new_domain(xml)
         LOG.debug(_("instance %s: is running"), instance['name'])
         self.firewall_driver.apply_instance_filter(instance)
@@ -755,11 +755,14 @@
         utils.execute('truncate', target, '-s', "%dG" % local_gb)
         # TODO(vish): should we format disk by default?
 
+    def _create_swap(self, target, swap_gb):
+        """Create a swap file of specified size"""
+        self._create_local(target, swap_gb)
+        utils.execute('mkswap', target)
+
     def _create_image(self, context, inst, libvirt_xml, suffix='',
                       disk_images=None, network_info=None,
-                      block_device_mapping=None):
-        block_device_mapping = block_device_mapping or []
-
+                      block_device_info=None):
         if not suffix:
             suffix = ''
 
@@ -818,8 +821,8 @@
             size = None
             root_fname += "_sm"
 
-        if not self._volume_in_mapping(self.root_mount_device,
-                                       block_device_mapping):
+        if not self._volume_in_mapping(self.default_root_device,
+                                       block_device_info):
             self._cache_image(fn=self._fetch_image,
                               context=context,
                               target=basepath('disk'),
@@ -830,13 +833,38 @@
                               project_id=inst['project_id'],
                               size=size)
 
-        if inst_type['local_gb'] and not self._volume_in_mapping(
-            self.local_mount_device, block_device_mapping):
+        local_gb = inst['local_gb']
+        if local_gb and not self._volume_in_mapping(
+            self.default_local_device, block_device_info):
             self._cache_image(fn=self._create_local,
                               target=basepath('disk.local'),
-                              fname="local_%s" % inst_type['local_gb'],
-                              cow=FLAGS.use_cow_images,
-                              local_gb=inst_type['local_gb'])
+                              fname="local_%s" % local_gb,
+                              cow=FLAGS.use_cow_images,
+                              local_gb=local_gb)
+
+        for eph in driver.block_device_info_get_ephemerals(block_device_info):
+            self._cache_image(fn=self._create_local,
+                              target=basepath(_get_eph_disk(eph)),
+                              fname="local_%s" % eph['size'],
+                              cow=FLAGS.use_cow_images,
+                              local_gb=eph['size'])
+
+        swap_gb = 0
+
+        swap = driver.block_device_info_get_swap(block_device_info)
+        if driver.swap_is_usable(swap):
+            swap_gb = swap['swap_size']
+        elif (inst_type['swap'] > 0 and
+              not self._volume_in_mapping(self.default_swap_device,
+                                          block_device_info)):
+            swap_gb = inst_type['swap']
+
+        if swap_gb > 0:
+            self._cache_image(fn=self._create_swap,
+                              target=basepath('disk.swap'),
+                              fname="swap_%s" % swap_gb,
+                              cow=FLAGS.use_cow_images,
+                              swap_gb=swap_gb)
 
         # For now, we assume that if we're not using a kernel, we're using a
         # partitioned disk image where the target partition is the first
@@ -917,16 +945,35 @@
         if FLAGS.libvirt_type == 'uml':
             utils.execute('sudo', 'chown', 'root', basepath('disk'))
 
-    root_mount_device = 'vda'  # FIXME for now. it's hard coded.
-    local_mount_device = 'vdb'  # FIXME for now. it's hard coded.
-
-    def _volume_in_mapping(self, mount_device, block_device_mapping):
-        mount_device_ = _strip_dev(mount_device)
-        for vol in block_device_mapping:
-            vol_mount_device = _strip_dev(vol['mount_device'])
-            if vol_mount_device == mount_device_:
-                return True
-        return False
+    if FLAGS.libvirt_type == 'uml':
+        _disk_prefix = 'ubd'
+    elif FLAGS.libvirt_type == 'xen':
+        _disk_prefix = 'sd'
+    elif FLAGS.libvirt_type == 'lxc':
+        _disk_prefix = ''
+    else:
+        _disk_prefix = 'vd'
+
+    default_root_device = _disk_prefix + 'a'
+    default_local_device = _disk_prefix + 'b'
+    default_swap_device = _disk_prefix + 'c'
+
+    def _volume_in_mapping(self, mount_device, block_device_info):
+        block_device_list = [block_device.strip_dev(vol['mount_device'])
+                             for vol in
+                             driver.block_device_info_get_mapping(
+                                 block_device_info)]
+        swap = driver.block_device_info_get_swap(block_device_info)
+        if driver.swap_is_usable(swap):
+            block_device_list.append(
+                block_device.strip_dev(swap['device_name']))
+        block_device_list += [block_device.strip_dev(ephemeral['device_name'])
+                              for ephemeral in
+                              driver.block_device_info_get_ephemerals(
+                                  block_device_info)]
+
+        LOG.debug(_("block_device_list %s"), block_device_list)
+        return block_device.strip_dev(mount_device) in block_device_list
 
     def _get_volume_device_info(self, device_path):
         if device_path.startswith('/dev/'):
@@ -938,8 +985,9 @@
             raise exception.InvalidDevicePath(path=device_path)
 
     def _prepare_xml_info(self, instance, rescue=False, network_info=None,
-                          block_device_mapping=None):
-        block_device_mapping = block_device_mapping or []
+                          block_device_info=None):
+        block_device_mapping = driver.block_device_info_get_mapping(
+            block_device_info)
         # TODO(adiantum) remove network_info creation code
         # when multinics will be completed
         if not network_info:
@@ -958,17 +1006,27 @@
             driver_type = 'raw'
 
         for vol in block_device_mapping:
-            vol['mount_device'] = _strip_dev(vol['mount_device'])
+            vol['mount_device'] = block_device.strip_dev(vol['mount_device'])
             (vol['type'], vol['protocol'], vol['name']) = \
                 self._get_volume_device_info(vol['device_path'])
 
-        ebs_root = self._volume_in_mapping(self.root_mount_device,
-                                           block_device_mapping)
-        if self._volume_in_mapping(self.local_mount_device,
-                                   block_device_mapping):
-            local_gb = False
-        else:
-            local_gb = inst_type['local_gb']
+        ebs_root = self._volume_in_mapping(self.default_root_device,
+                                           block_device_info)
+
+        local_device = False
+        if not (self._volume_in_mapping(self.default_local_device,
+                                        block_device_info) or
+                0 in [eph['num'] for eph in
+                      driver.block_device_info_get_ephemerals(
+                          block_device_info)]):
+            if instance['local_gb'] > 0:
+                local_device = self.default_local_device
+
+        ephemerals = []
+        for eph in driver.block_device_info_get_ephemerals(block_device_info):
+            ephemerals.append({'device_path': _get_eph_disk(eph),
+                               'device': block_device.strip_dev(
+                                   eph['device_name'])})
 
         xml_info = {'type': FLAGS.libvirt_type,
                     'name': instance['name'],
@@ -977,12 +1035,35 @@
                     'memory_kb': inst_type['memory_mb'] * 1024,
                     'vcpus': inst_type['vcpus'],
                     'rescue': rescue,
-                    'local': local_gb,
+                    'disk_prefix': self._disk_prefix,
                     'driver_type': driver_type,
                     'vif_type': FLAGS.libvirt_vif_type,
                     'nics': nics,
                     'ebs_root': ebs_root,
-                    'volumes': block_device_mapping}
+                    'local_device': local_device,
+                    'volumes': block_device_mapping,
+                    'ephemerals': ephemerals}
+
+        root_device_name = driver.block_device_info_get_root(block_device_info)
+        if root_device_name:
+            xml_info['root_device'] = block_device.strip_dev(root_device_name)
+            xml_info['root_device_name'] = root_device_name
+        else:
+            # NOTE(yamahata):
+            # for nova.api.ec2.cloud.CloudController.get_metadata()
+            xml_info['root_device'] = self.default_root_device
+            db.instance_update(
+                nova_context.get_admin_context(), instance['id'],
+                {'root_device_name': '/dev/' + self.default_root_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(
+                swap['device_name'])
+        elif (inst_type['swap'] > 0 and
+              not self._volume_in_mapping(self.default_swap_device,
+                                          block_device_info)):
+            xml_info['swap_device'] = self.default_swap_device
 
         if FLAGS.vnc_enabled and FLAGS.libvirt_type not in ('lxc', 'uml'):
             xml_info['vncserver_host'] = FLAGS.vncserver_host
@@ -998,12 +1079,11 @@
         return xml_info
 
     def to_xml(self, instance, rescue=False, network_info=None,
-               block_device_mapping=None):
-        block_device_mapping = block_device_mapping or []
+               block_device_info=None):
         # TODO(termie): cache?
         LOG.debug(_('instance %s: starting toXML method'), instance['name'])
         xml_info = self._prepare_xml_info(instance, rescue, network_info,
-                                          block_device_mapping)
+                                          block_device_info)
         xml = str(Template(self.libvirt_xml, searchList=[xml_info]))
         LOG.debug(_('instance %s: finished toXML method'), instance['name'])
         return xml

=== modified file 'nova/virt/xenapi_conn.py'
--- nova/virt/xenapi_conn.py	2011-08-05 02:22:13 +0000
+++ nova/virt/xenapi_conn.py	2011-08-05 06:31:22 +0000
@@ -184,8 +184,8 @@
     def list_instances_detail(self):
         return self._vmops.list_instances_detail()
 
-    def spawn(self, context, instance, network_info,
-              block_device_mapping=None):
+    def spawn(self, context, instance,
+              network_info=None, block_device_info=None):
         """Create VM instance"""
         self._vmops.spawn(context, instance, network_info)