merge with trunk, resolve conflicts

69 files changed, 3952 insertions, 768 deletions

diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 890d57fe7..cf1734281 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -262,6 +262,8 @@ class Authorizer(wsgi.Middleware):
                 'TerminateInstances': ['projectmanager', 'sysadmin'],
                 'RebootInstances': ['projectmanager', 'sysadmin'],
                 'UpdateInstance': ['projectmanager', 'sysadmin'],
+                'StartInstances': ['projectmanager', 'sysadmin'],
+                'StopInstances': ['projectmanager', 'sysadmin'],
                 'DeleteVolume': ['projectmanager', 'sysadmin'],
                 'DescribeImages': ['all'],
                 'DeregisterImage': ['projectmanager', 'sysadmin'],
@@ -269,6 +271,7 @@ class Authorizer(wsgi.Middleware):
                 'DescribeImageAttribute': ['all'],
                 'ModifyImageAttribute': ['projectmanager', 'sysadmin'],
                 'UpdateImage': ['projectmanager', 'sysadmin'],
+                'CreateImage': ['projectmanager', 'sysadmin'],
             },
             'AdminController': {
                 # All actions have the same permission: ['none'] (the default)
@@ -325,13 +328,13 @@ class Executor(wsgi.Application):
         except exception.VolumeNotFound as ex:
             LOG.info(_('VolumeNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = ec2utils.id_to_ec2_id(ex.volume_id, 'vol-%08x')
+            ec2_id = ec2utils.id_to_ec2_vol_id(ex.volume_id)
             message = _('Volume %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.SnapshotNotFound as ex:
             LOG.info(_('SnapshotNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = ec2utils.id_to_ec2_id(ex.snapshot_id, 'snap-%08x')
+            ec2_id = ec2utils.id_to_ec2_snap_id(ex.snapshot_id)
             message = _('Snapshot %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.NotFound as ex:
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index acfd1361c..16ca1ed2a 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -27,6 +27,7 @@ import netaddr
 import os
 import urllib
 import tempfile
+import time
 import shutil
 
 from nova import compute
@@ -75,6 +76,95 @@ def _gen_key(context, user_id, key_name):
     return {'private_key': private_key, 'fingerprint': fingerprint}
 
 
+# TODO(yamahata): hypervisor dependent default device name
+_DEFAULT_ROOT_DEVICE_NAME = '/dev/sda1'
+
+
+def _parse_block_device_mapping(bdm):
+    """Parse BlockDeviceMappingItemType into flat hash
+    BlockDevicedMapping.<N>.DeviceName
+    BlockDevicedMapping.<N>.Ebs.SnapshotId
+    BlockDevicedMapping.<N>.Ebs.VolumeSize
+    BlockDevicedMapping.<N>.Ebs.DeleteOnTermination
+    BlockDevicedMapping.<N>.Ebs.NoDevice
+    BlockDevicedMapping.<N>.VirtualName
+    => remove .Ebs and allow volume id in SnapshotId
+    """
+    ebs = bdm.pop('ebs', None)
+    if ebs:
+        ec2_id = ebs.pop('snapshot_id', None)
+        if ec2_id:
+            id = ec2utils.ec2_id_to_id(ec2_id)
+            if ec2_id.startswith('snap-'):
+                bdm['snapshot_id'] = id
+            elif ec2_id.startswith('vol-'):
+                bdm['volume_id'] = id
+            ebs.setdefault('delete_on_termination', True)
+        bdm.update(ebs)
+    return bdm
+
+
+def _properties_get_mappings(properties):
+    return ec2utils.mappings_prepend_dev(properties.get('mappings', []))
+
+
+def _format_block_device_mapping(bdm):
+    """Contruct BlockDeviceMappingItemType
+    {'device_name': '...', 'snapshot_id': , ...}
+    => BlockDeviceMappingItemType
+    """
+    keys = (('deviceName', 'device_name'),
+             ('virtualName', 'virtual_name'))
+    item = {}
+    for name, k in keys:
+        if k in bdm:
+            item[name] = bdm[k]
+    if bdm.get('no_device'):
+        item['noDevice'] = True
+    if ('snapshot_id' in bdm) or ('volume_id' in bdm):
+        ebs_keys = (('snapshotId', 'snapshot_id'),
+                    ('snapshotId', 'volume_id'),        # snapshotId is abused
+                    ('volumeSize', 'volume_size'),
+                    ('deleteOnTermination', 'delete_on_termination'))
+        ebs = {}
+        for name, k in ebs_keys:
+            if k in bdm:
+                if k == 'snapshot_id':
+                    ebs[name] = ec2utils.id_to_ec2_snap_id(bdm[k])
+                elif k == 'volume_id':
+                    ebs[name] = ec2utils.id_to_ec2_vol_id(bdm[k])
+                else:
+                    ebs[name] = bdm[k]
+        assert 'snapshotId' in ebs
+        item['ebs'] = ebs
+    return item
+
+
+def _format_mappings(properties, result):
+    """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'))]
+
+    block_device_mapping = [_format_block_device_mapping(bdm) for bdm in
+                            properties.get('block_device_mapping', [])]
+
+    # NOTE(yamahata): overwrite mappings with block_device_mapping
+    for bdm in block_device_mapping:
+        for i in range(len(mappings)):
+            if bdm['deviceName'] == mappings[i]['deviceName']:
+                del mappings[i]
+                break
+        mappings.append(bdm)
+
+    # NOTE(yamahata): trim ebs.no_device == true. Is this necessary?
+    mappings = [bdm for bdm in mappings if not (bdm.get('noDevice', False))]
+
+    if mappings:
+        result['blockDeviceMapping'] = mappings
+
+
 class CloudController(object):
     """ CloudController provides the critical dispatch between
  inbound API calls through the endpoint and messages
@@ -179,7 +269,7 @@ class CloudController(object):
                     # TODO(vish): replace with real data
                     'ami': 'sda1',
                     'ephemeral0': 'sda2',
-                    'root': '/dev/sda1',
+                    'root': _DEFAULT_ROOT_DEVICE_NAME,
                     'swap': 'sda3'},
                 'hostname': hostname,
                 'instance-action': 'none',
@@ -307,9 +397,8 @@ class CloudController(object):
 
     def _format_snapshot(self, context, snapshot):
         s = {}
-        s['snapshotId'] = ec2utils.id_to_ec2_id(snapshot['id'], 'snap-%08x')
-        s['volumeId'] = ec2utils.id_to_ec2_id(snapshot['volume_id'],
-                                              'vol-%08x')
+        s['snapshotId'] = ec2utils.id_to_ec2_snap_id(snapshot['id'])
+        s['volumeId'] = ec2utils.id_to_ec2_vol_id(snapshot['volume_id'])
         s['status'] = snapshot['status']
         s['startTime'] = snapshot['created_at']
         s['progress'] = snapshot['progress']
@@ -686,7 +775,7 @@ class CloudController(object):
             instance_data = '%s[%s]' % (instance_ec2_id,
                                         volume['instance']['host'])
         v = {}
-        v['volumeId'] = ec2utils.id_to_ec2_id(volume['id'], 'vol-%08x')
+        v['volumeId'] = ec2utils.id_to_ec2_vol_id(volume['id'])
         v['status'] = volume['status']
         v['size'] = volume['size']
         v['availabilityZone'] = volume['availability_zone']
@@ -708,8 +797,7 @@ class CloudController(object):
         else:
             v['attachmentSet'] = [{}]
         if volume.get('snapshot_id') != None:
-            v['snapshotId'] = ec2utils.id_to_ec2_id(volume['snapshot_id'],
-                                                    'snap-%08x')
+            v['snapshotId'] = ec2utils.id_to_ec2_snap_id(volume['snapshot_id'])
         else:
             v['snapshotId'] = None
 
@@ -772,7 +860,7 @@ class CloudController(object):
                 'instanceId': ec2utils.id_to_ec2_id(instance_id),
                 'requestId': context.request_id,
                 'status': volume['attach_status'],
-                'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}
+                'volumeId': ec2utils.id_to_ec2_vol_id(volume_id)}
 
     def detach_volume(self, context, volume_id, **kwargs):
         volume_id = ec2utils.ec2_id_to_id(volume_id)
@@ -784,7 +872,7 @@ class CloudController(object):
                 'instanceId': ec2utils.id_to_ec2_id(instance['id']),
                 'requestId': context.request_id,
                 'status': volume['attach_status'],
-                'volumeId': ec2utils.id_to_ec2_id(volume_id, 'vol-%08x')}
+                'volumeId': ec2utils.id_to_ec2_vol_id(volume_id)}
 
     def _convert_to_set(self, lst, label):
         if lst is None or lst == []:
@@ -808,6 +896,37 @@ class CloudController(object):
         assert len(i) == 1
         return i[0]
 
+    def _format_instance_bdm(self, context, instance_id, root_device_name,
+                             result):
+        """Format InstanceBlockDeviceMappingResponseItemType"""
+        root_device_type = 'instance-store'
+        mapping = []
+        for bdm in db.block_device_mapping_get_all_by_instance(context,
+                                                               instance_id):
+            volume_id = bdm['volume_id']
+            if (volume_id is None or bdm['no_device']):
+                continue
+
+            if (bdm['device_name'] == root_device_name and
+                (bdm['snapshot_id'] or bdm['volume_id'])):
+                assert not bdm['virtual_name']
+                root_device_type = 'ebs'
+
+            vol = self.volume_api.get(context, volume_id=volume_id)
+            LOG.debug(_("vol = %s\n"), vol)
+            # TODO(yamahata): volume attach time
+            ebs = {'volumeId': volume_id,
+                   'deleteOnTermination': bdm['delete_on_termination'],
+                   'attachTime': vol['attach_time'] or '-',
+                   'status': vol['status'], }
+            res = {'deviceName': bdm['device_name'],
+                   'ebs': ebs, }
+            mapping.append(res)
+
+        if mapping:
+            result['blockDeviceMapping'] = mapping
+        result['rootDeviceType'] = root_device_type
+
     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
@@ -869,6 +988,10 @@ class CloudController(object):
             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_bdm(context, instance_id,
+                                      i['rootDeviceName'], i)
             host = instance['host']
             zone = self._get_availability_zone_by_host(context, host)
             i['placement'] = {'availabilityZone': zone}
@@ -956,23 +1079,7 @@ class CloudController(object):
             ramdisk = self._get_image(context, kwargs['ramdisk_id'])
             kwargs['ramdisk_id'] = ramdisk['id']
         for bdm in kwargs.get('block_device_mapping', []):
-            # NOTE(yamahata)
-            # BlockDevicedMapping.<N>.DeviceName
-            # BlockDevicedMapping.<N>.Ebs.SnapshotId
-            # BlockDevicedMapping.<N>.Ebs.VolumeSize
-            # BlockDevicedMapping.<N>.Ebs.DeleteOnTermination
-            # BlockDevicedMapping.<N>.VirtualName
-            # => remove .Ebs and allow volume id in SnapshotId
-            ebs = bdm.pop('ebs', None)
-            if ebs:
-                ec2_id = ebs.pop('snapshot_id')
-                id = ec2utils.ec2_id_to_id(ec2_id)
-                if ec2_id.startswith('snap-'):
-                    bdm['snapshot_id'] = id
-                elif ec2_id.startswith('vol-'):
-                    bdm['volume_id'] = id
-                ebs.setdefault('delete_on_termination', True)
-                bdm.update(ebs)
+            _parse_block_device_mapping(bdm)
 
         image = self._get_image(context, kwargs['image_id'])
 
@@ -1131,6 +1238,20 @@ class CloudController(object):
         i['imageType'] = display_mapping.get(image_type)
         i['isPublic'] = image.get('is_public') == True
         i['architecture'] = image['properties'].get('architecture')
+
+        properties = image['properties']
+        root_device_name = ec2utils.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
+                ('snapshot_id' in bdm or 'volume_id' in bdm) and
+                not bdm.get('no_device')):
+                root_device_type = 'ebs'
+        i['rootDeviceName'] = (root_device_name or _DEFAULT_ROOT_DEVICE_NAME)
+        i['rootDeviceType'] = root_device_type
+
+        _format_mappings(properties, i)
+
         return i
 
     def describe_images(self, context, image_id=None, **kwargs):
@@ -1155,30 +1276,64 @@ class CloudController(object):
         self.image_service.delete(context, internal_id)
         return {'imageId': image_id}
 
+    def _register_image(self, context, metadata):
+        image = self.image_service.create(context, metadata)
+        image_type = self._image_type(image.get('container_format'))
+        image_id = self.image_ec2_id(image['id'], image_type)
+        return image_id
+
     def register_image(self, context, image_location=None, **kwargs):
         if image_location is None and 'name' in kwargs:
             image_location = kwargs['name']
         metadata = {'properties': {'image_location': image_location}}
-        image = self.image_service.create(context, metadata)
-        image_type = self._image_type(image.get('container_format'))
-        image_id = self.image_ec2_id(image['id'],
-                                     image_type)
+
+        if 'root_device_name' in kwargs:
+            metadata['properties']['root_device_name'] = \
+            kwargs.get('root_device_name')
+
+        mappings = [_parse_block_device_mapping(bdm) for bdm in
+                    kwargs.get('block_device_mapping', [])]
+        if mappings:
+            metadata['properties']['block_device_mapping'] = mappings
+
+        image_id = self._register_image(context, metadata)
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
         return {'imageId': image_id}
 
     def describe_image_attribute(self, context, image_id, attribute, **kwargs):
-        if attribute != 'launchPermission':
+        def _block_device_mapping_attribute(image, result):
+            _format_mappings(image['properties'], result)
+
+        def _launch_permission_attribute(image, result):
+            result['launchPermission'] = []
+            if image['is_public']:
+                result['launchPermission'].append({'group': 'all'})
+
+        def _root_device_name_attribute(image, result):
+            result['rootDeviceName'] = \
+                    ec2utils.properties_root_device_name(image['properties'])
+            if result['rootDeviceName'] is None:
+                result['rootDeviceName'] = _DEFAULT_ROOT_DEVICE_NAME
+
+        supported_attributes = {
+            'blockDeviceMapping': _block_device_mapping_attribute,
+            'launchPermission': _launch_permission_attribute,
+            'rootDeviceName': _root_device_name_attribute,
+            }
+
+        fn = supported_attributes.get(attribute)
+        if fn is None:
             raise exception.ApiError(_('attribute not supported: %s')
                                      % attribute)
         try:
             image = self._get_image(context, image_id)
         except exception.NotFound:
             raise exception.ImageNotFound(image_id=image_id)
-        result = {'imageId': image_id, 'launchPermission': []}
-        if image['is_public']:
-            result['launchPermission'].append({'group': 'all'})
+
+        result = {'imageId': image_id}
+        fn(image, result)
         return result
 
     def modify_image_attribute(self, context, image_id, attribute,
@@ -1209,3 +1364,109 @@ class CloudController(object):
         internal_id = ec2utils.ec2_id_to_id(image_id)
         result = self.image_service.update(context, internal_id, dict(kwargs))
         return result
+
+    # TODO(yamahata): race condition
+    # At the moment there is no way to prevent others from
+    # manipulating instances/volumes/snapshots.
+    # As other code doesn't take it into consideration, here we don't
+    # care of it for now. Ostrich algorithm
+    def create_image(self, context, instance_id, **kwargs):
+        # NOTE(yamahata): name/description are ignored by register_image(),
+        #                 do so here
+        no_reboot = kwargs.get('no_reboot', False)
+
+        ec2_instance_id = instance_id
+        instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
+        instance = self.compute_api.get(context, instance_id)
+
+        # stop the instance if necessary
+        restart_instance = False
+        if not no_reboot:
+            state_description = instance['state_description']
+
+            # if the instance is in subtle state, refuse to proceed.
+            if state_description not in ('running', 'stopping', 'stopped'):
+                raise exception.InstanceNotRunning(instance_id=ec2_instance_id)
+
+            if state_description == 'running':
+                restart_instance = True
+                self.compute_api.stop(context, instance_id=instance_id)
+
+            # wait instance for really stopped
+            start_time = time.time()
+            while state_description != 'stopped':
+                time.sleep(1)
+                instance = self.compute_api.get(context, instance_id)
+                state_description = instance['state_description']
+                # NOTE(yamahata): timeout and error. 1 hour for now for safety.
+                #                 Is it too short/long?
+                #                 Or is there any better way?
+                timeout = 1 * 60 * 60 * 60
+                if time.time() > start_time + timeout:
+                    raise exception.ApiError(
+                        _('Couldn\'t stop instance with in %d sec') % timeout)
+
+        src_image = self._get_image(context, instance['image_ref'])
+        properties = src_image['properties']
+        if instance['root_device_name']:
+            properties['root_device_name'] = instance['root_device_name']
+
+        mapping = []
+        bdms = db.block_device_mapping_get_all_by_instance(context,
+                                                           instance_id)
+        for bdm in bdms:
+            if bdm.no_device:
+                continue
+            m = {}
+            for attr in ('device_name', 'snapshot_id', 'volume_id',
+                         'volume_size', 'delete_on_termination', 'no_device',
+                         'virtual_name'):
+                val = getattr(bdm, attr)
+                if val is not None:
+                    m[attr] = val
+
+            volume_id = m.get('volume_id')
+            if m.get('snapshot_id') and volume_id:
+                # create snapshot based on volume_id
+                vol = self.volume_api.get(context, volume_id=volume_id)
+                # NOTE(yamahata): Should we wait for snapshot creation?
+                #                 Linux LVM snapshot creation completes in
+                #                 short time, it doesn't matter for now.
+                snapshot = self.volume_api.create_snapshot_force(
+                    context, volume_id=volume_id, name=vol['display_name'],
+                    description=vol['display_description'])
+                m['snapshot_id'] = snapshot['id']
+                del m['volume_id']
+
+            if m:
+                mapping.append(m)
+
+        for m in _properties_get_mappings(properties):
+            virtual_name = m['virtual']
+            if virtual_name in ('ami', 'root'):
+                continue
+
+            assert (virtual_name == 'swap' or
+                    virtual_name.startswith('ephemeral'))
+            device_name = m['device']
+            if device_name in [b['device_name'] for b in mapping
+                               if not b.get('no_device', False)]:
+                continue
+
+            # NOTE(yamahata): swap and ephemeral devices are specified in
+            #                 AMI, but disabled for this instance by user.
+            #                 So disable those device by no_device.
+            mapping.append({'device_name': device_name, 'no_device': True})
+
+        if mapping:
+            properties['block_device_mapping'] = mapping
+
+        for attr in ('status', 'location', 'id'):
+            src_image.pop(attr, None)
+
+        image_id = self._register_image(context, src_image)
+
+        if restart_instance:
+            self.compute_api.start(context, instance_id=instance_id)
+
+        return {'imageId': image_id}
diff --git a/nova/api/ec2/ec2utils.py b/nova/api/ec2/ec2utils.py
index 222e1de1e..bae1e0ee5 100644
--- a/nova/api/ec2/ec2utils.py
+++ b/nova/api/ec2/ec2utils.py
@@ -34,6 +34,17 @@ def id_to_ec2_id(instance_id, template='i-%08x'):
     return template % instance_id
 
 
+def id_to_ec2_snap_id(instance_id):
+    """Convert an snapshot ID (int) to an ec2 snapshot ID
+    (snap-[base 16 number])"""
+    return id_to_ec2_id(instance_id, 'snap-%08x')
+
+
+def id_to_ec2_vol_id(instance_id):
+    """Convert an volume ID (int) to an ec2 volume ID (vol-[base 16 number])"""
+    return id_to_ec2_id(instance_id, 'vol-%08x')
+
+
 _c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
 
 
@@ -124,3 +135,32 @@ def dict_from_dotted_str(items):
                 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
diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index f24017df0..e87d7c754 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -125,6 +125,10 @@ class APIRouter(base_wsgi.Router):
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("ip", "ips", controller=ips.create_resource(version),
+                        parent_resource=dict(member_name='server',
+                                             collection_name='servers'))
+
         mapper.resource("image", "images",
                         controller=images.create_resource(version),
                         collection={'detail': 'GET'})
@@ -144,9 +148,6 @@ class APIRouterV10(APIRouter):
 
     def _setup_routes(self, mapper):
         super(APIRouterV10, self)._setup_routes(mapper, '1.0')
-        mapper.resource("image", "images",
-                        controller=images.create_resource('1.0'),
-                        collection={'detail': 'GET'})
 
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
@@ -157,11 +158,6 @@ class APIRouterV10(APIRouter):
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
-        mapper.resource("ip", "ips", controller=ips.create_resource(),
-                        collection=dict(public='GET', private='GET'),
-                        parent_resource=dict(member_name='server',
-                                             collection_name='servers'))
-
 
 class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
diff --git a/nova/api/openstack/accounts.py b/nova/api/openstack/accounts.py
index e3201b14f..a13a758ab 100644
--- a/nova/api/openstack/accounts.py
+++ b/nova/api/openstack/accounts.py
@@ -47,10 +47,10 @@ class Controller(object):
             raise exception.AdminRequired()
 
     def index(self, req):
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def detail(self, req):
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def show(self, req, id):
         """Return data about the given account id"""
@@ -65,7 +65,7 @@ class Controller(object):
     def create(self, req, body):
         """We use update with create-or-update semantics
            because the id comes from an external source"""
-        raise faults.Fault(webob.exc.HTTPNotImplemented())
+        raise webob.exc.HTTPNotImplemented()
 
     def update(self, req, id, body):
         """This is really create or update."""
diff --git a/nova/api/openstack/backup_schedules.py b/nova/api/openstack/backup_schedules.py
index 3e95aedf3..7ff0d999e 100644
--- a/nova/api/openstack/backup_schedules.py
+++ b/nova/api/openstack/backup_schedules.py
@@ -19,7 +19,6 @@ import time
 
 from webob import exc
 
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -36,20 +35,20 @@ class Controller(object):
 
     def index(self, req, server_id, **kwargs):
         """ Returns the list of backup schedules for a given instance """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def show(self, req, server_id, id, **kwargs):
         """ Returns a single backup schedule for a given instance """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def create(self, req, server_id, **kwargs):
         """ No actual update method required, since the existing API allows
         both create and update through a POST """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, server_id, id, **kwargs):
         """ Deletes an existing backup schedule """
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
 
 def create_resource():
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 8e12ce0c0..57031ebf1 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -53,10 +53,10 @@ def get_pagination_params(request):
             params[param] = int(request.GET[param])
         except ValueError:
             msg = _('%s param must be an integer') % param
-            raise webob.exc.HTTPBadRequest(msg)
+            raise webob.exc.HTTPBadRequest(explanation=msg)
         if params[param] < 0:
             msg = _('%s param must be positive') % param
-            raise webob.exc.HTTPBadRequest(msg)
+            raise webob.exc.HTTPBadRequest(explanation=msg)
 
     return params
 
@@ -77,18 +77,22 @@ def limited(items, request, max_limit=FLAGS.osapi_max_limit):
     try:
         offset = int(request.GET.get('offset', 0))
     except ValueError:
-        raise webob.exc.HTTPBadRequest(_('offset param must be an integer'))
+        msg = _('offset param must be an integer')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     try:
         limit = int(request.GET.get('limit', max_limit))
     except ValueError:
-        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
+        msg = _('limit param must be an integer')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     if limit < 0:
-        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+        msg = _('limit param must be positive')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     if offset < 0:
-        raise webob.exc.HTTPBadRequest(_('offset param must be positive'))
+        msg = _('offset param must be positive')
+        raise webob.exc.HTTPBadRequest(explanation=msg)
 
     limit = min(max_limit, limit or max_limit)
     range_end = offset + limit
@@ -111,7 +115,8 @@ def limited_by_marker(items, request, max_limit=FLAGS.osapi_max_limit):
                 start_index = i + 1
                 break
         if start_index < 0:
-            raise webob.exc.HTTPBadRequest(_('marker [%s] not found' % marker))
+            msg = _('marker [%s] not found') % marker
+            raise webob.exc.HTTPBadRequest(explanation=msg)
     range_end = start_index + limit
     return items[start_index:range_end]
 
diff --git a/nova/api/openstack/consoles.py b/nova/api/openstack/consoles.py
index 7a43fba96..d2655acfa 100644
--- a/nova/api/openstack/consoles.py
+++ b/nova/api/openstack/consoles.py
@@ -16,10 +16,10 @@
 #    under the License.
 
 from webob import exc
+import webob
 
 from nova import console
 from nova import exception
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -71,12 +71,12 @@ class Controller(object):
                                         int(server_id),
                                         int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         return _translate_detail_keys(console)
 
     def update(self, req, server_id, id):
         """You can't update a console"""
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, server_id, id):
         """Deletes a console"""
@@ -85,8 +85,8 @@ class Controller(object):
                                             int(server_id),
                                             int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
 
 def create_resource():
diff --git a/nova/api/openstack/contrib/multinic.py b/nova/api/openstack/contrib/multinic.py
index 841061721..da8dcee5d 100644
--- a/nova/api/openstack/contrib/multinic.py
+++ b/nova/api/openstack/contrib/multinic.py
@@ -16,6 +16,7 @@
 """The multinic extension."""
 
 from webob import exc
+import webob
 
 from nova import compute
 from nova import log as logging
@@ -103,7 +104,7 @@ class Multinic(extensions.ExtensionDescriptor):
         except Exception, e:
             LOG.exception(_("Error in addFixedIp %s"), e)
             return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _remove_fixed_ip(self, input_dict, req, id):
         """Removes an IP from an instance."""
@@ -122,4 +123,4 @@ class Multinic(extensions.ExtensionDescriptor):
         except Exception, e:
             LOG.exception(_("Error in removeFixedIp %s"), e)
             return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
diff --git a/nova/api/openstack/contrib/volumes.py b/nova/api/openstack/contrib/volumes.py
index e5e2c5b50..827e36097 100644
--- a/nova/api/openstack/contrib/volumes.py
+++ b/nova/api/openstack/contrib/volumes.py
@@ -16,6 +16,7 @@
 """The volumes extension."""
 
 from webob import exc
+import webob
 
 from nova import compute
 from nova import exception
@@ -104,7 +105,7 @@ class VolumeController(object):
             self.volume_api.delete(context, volume_id=id)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def index(self, req):
         """Returns a summary list of volumes."""
@@ -279,7 +280,7 @@ class VolumeAttachmentController(object):
         self.compute_api.detach_volume(context,
                                        volume_id=volume_id)
 
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _items(self, req, server_id, entity_maker):
         """Returns a list of attachments, transformed through entity_maker."""
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 2654e3c40..7249f1261 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -28,7 +28,6 @@ from nova import quota
 from nova import utils
 
 from nova.compute import instance_types
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova.auth import manager as auth_manager
 
@@ -70,7 +69,7 @@ class CreateInstanceHelper(object):
         return type from this method is left to the caller.
         """
         if not body:
-            raise faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
 
         context = req.environ['nova.context']
 
@@ -94,7 +93,7 @@ class CreateInstanceHelper(object):
         except Exception, e:
             msg = _("Cannot find requested image %(image_href)s: %(e)s" %
                                                                     locals())
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
         personality = body['server'].get('personality')
 
@@ -102,7 +101,11 @@ class CreateInstanceHelper(object):
         if personality:
             injected_files = self._get_injected_files(personality)
 
-        flavor_id = self.controller._flavor_id_from_req_data(body)
+        try:
+            flavor_id = self.controller._flavor_id_from_req_data(body)
+        except ValueError as error:
+            msg = _("Invalid flavorRef provided.")
+            raise exc.HTTPBadRequest(explanation=msg)
 
         if not 'name' in body['server']:
             msg = _("Server name is not defined")
@@ -153,8 +156,10 @@ class CreateInstanceHelper(object):
             self._handle_quota_error(error)
         except exception.ImageNotFound as error:
             msg = _("Can not find requested image")
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
-
+            raise exc.HTTPBadRequest(explanation=msg)
+        except exception.FlavorNotFound as error:
+            msg = _("Invalid flavorRef provided.")
+            raise exc.HTTPBadRequest(explanation=msg)
         # Let the caller deal with unhandled exceptions.
 
     def _handle_quota_error(self, error):
diff --git a/nova/api/openstack/faults.py b/nova/api/openstack/faults.py
index b9a23c126..24cde69e4 100644
--- a/nova/api/openstack/faults.py
+++ b/nova/api/openstack/faults.py
@@ -40,6 +40,7 @@ class Fault(webob.exc.HTTPException):
     def __init__(self, exception):
         """Create a Fault for the given webob.exc.exception."""
         self.wrapped_exc = exception
+        self.status_int = exception.status_int
 
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
diff --git a/nova/api/openstack/flavors.py b/nova/api/openstack/flavors.py
index 6fab13147..b4bda68d4 100644
--- a/nova/api/openstack/flavors.py
+++ b/nova/api/openstack/flavors.py
@@ -16,6 +16,7 @@
 #    under the License.
 
 import webob
+import xml.dom.minidom as minidom
 
 from nova import db
 from nova import exception
@@ -74,19 +75,65 @@ class ControllerV11(Controller):
         return views.flavors.ViewBuilderV11(base_url)
 
 
+class FlavorXMLSerializer(wsgi.XMLDictSerializer):
+
+    def __init__(self):
+        super(FlavorXMLSerializer, self).__init__(xmlns=wsgi.XMLNS_V11)
+
+    def _flavor_to_xml(self, xml_doc, flavor, detailed):
+        flavor_node = xml_doc.createElement('flavor')
+        flavor_node.setAttribute('id', str(flavor['id']))
+        flavor_node.setAttribute('name', flavor['name'])
+
+        if detailed:
+            flavor_node.setAttribute('ram', str(flavor['ram']))
+            flavor_node.setAttribute('disk', str(flavor['disk']))
+
+        link_nodes = self._create_link_nodes(xml_doc, flavor['links'])
+        for link_node in link_nodes:
+            flavor_node.appendChild(link_node)
+        return flavor_node
+
+    def _flavors_list_to_xml(self, xml_doc, flavors, detailed):
+        container_node = xml_doc.createElement('flavors')
+
+        for flavor in flavors:
+            item_node = self._flavor_to_xml(xml_doc, flavor, detailed)
+            container_node.appendChild(item_node)
+        return container_node
+
+    def show(self, flavor_container):
+        xml_doc = minidom.Document()
+        flavor = flavor_container['flavor']
+        node = self._flavor_to_xml(xml_doc, flavor, True)
+        return self.to_xml_string(node, True)
+
+    def detail(self, flavors_container):
+        xml_doc = minidom.Document()
+        flavors = flavors_container['flavors']
+        node = self._flavors_list_to_xml(xml_doc, flavors, True)
+        return self.to_xml_string(node, True)
+
+    def index(self, flavors_container):
+        xml_doc = minidom.Document()
+        flavors = flavors_container['flavors']
+        node = self._flavors_list_to_xml(xml_doc, flavors, False)
+        return self.to_xml_string(node, True)
+
+
 def create_resource(version='1.0'):
     controller = {
         '1.0': ControllerV10,
         '1.1': ControllerV11,
     }[version]()
 
-    xmlns = {
-        '1.0': wsgi.XMLNS_V10,
-        '1.1': wsgi.XMLNS_V11,
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(xmlns=wsgi.XMLNS_V10),
+        '1.1': FlavorXMLSerializer(),
     }[version]
 
     body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns),
+        'application/xml': xml_serializer,
     }
 
     serializer = wsgi.ResponseSerializer(body_serializers)
diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index 4f33844fa..c0fc8c09b 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -22,7 +22,6 @@ from nova import flags
 from nova import image
 from nova import quota
 from nova import utils
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -62,7 +61,7 @@ class Controller(object):
         if id in metadata:
             return {'meta': {id: metadata[id]}}
         else:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def create(self, req, image_id, body):
         context = req.environ['nova.context']
@@ -105,7 +104,7 @@ class Controller(object):
         img = self.image_service.show(context, image_id)
         metadata = self._get_metadata(context, image_id)
         if not id in metadata:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         metadata.pop(id)
         img['properties'] = metadata
         self.image_service.update(context, image_id, img, None)
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index d0317583e..30e4fd389 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -25,7 +25,6 @@ from nova import flags
 import nova.image
 from nova import log
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import image_metadata
 from nova.api.openstack import servers
 from nova.api.openstack.views import images as images_view
@@ -35,7 +34,13 @@ from nova.api.openstack import wsgi
 LOG = log.getLogger('nova.api.openstack.images')
 FLAGS = flags.FLAGS
 
-SUPPORTED_FILTERS = ['name', 'status']
+SUPPORTED_FILTERS = {
+    'name': 'name',
+    'status': 'status',
+    'changes-since': 'changes-since',
+    'server': 'property-instance_ref',
+    'type': 'property-image_type',
+}
 
 
 class Controller(object):
@@ -62,8 +67,9 @@ class Controller(object):
         filters = {}
         for param in req.str_params:
             if param in SUPPORTED_FILTERS or param.startswith('property-'):
-                filters[param] = req.str_params.get(param)
-
+                # map filter name or carry through if property-*
+                filter_name = SUPPORTED_FILTERS.get(param, param)
+                filters[filter_name] = req.str_params.get(param)
         return filters
 
     def show(self, req, id):
@@ -78,7 +84,7 @@ class Controller(object):
             image = self._image_service.show(context, id)
         except (exception.NotFound, exception.InvalidImageRef):
             explanation = _("Image not found.")
-            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
+            raise webob.exc.HTTPNotFound(explanation=explanation)
 
         return dict(image=self.get_builder(req).build(image, detail=True))
 
diff --git a/nova/api/openstack/ips.py b/nova/api/openstack/ips.py
index 23e5432d6..2996b032d 100644
--- a/nova/api/openstack/ips.py
+++ b/nova/api/openstack/ips.py
@@ -20,9 +20,9 @@ import time
 from webob import exc
 
 import nova
-from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 from nova.api.openstack import wsgi
+from nova import db
 
 
 class Controller(object):
@@ -30,39 +30,87 @@ class Controller(object):
 
     def __init__(self):
         self.compute_api = nova.compute.API()
-        self.builder = nova.api.openstack.views.addresses.ViewBuilderV10()
 
     def _get_instance(self, req, server_id):
         try:
             instance = self.compute_api.get(
                 req.environ['nova.context'], server_id)
         except nova.exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
         return instance
 
+    def create(self, req, server_id, body):
+        raise exc.HTTPNotImplemented()
+
+    def delete(self, req, server_id, id):
+        raise exc.HTTPNotImplemented()
+
+
+class ControllerV10(Controller):
+
     def index(self, req, server_id):
         instance = self._get_instance(req, server_id)
-        return {'addresses': self.builder.build(instance)}
+        builder = nova.api.openstack.views.addresses.ViewBuilderV10()
+        return {'addresses': builder.build(instance)}
 
-    def public(self, req, server_id):
+    def show(self, req, server_id, id):
         instance = self._get_instance(req, server_id)
-        return {'public': self.builder.build_public_parts(instance)}
+        builder = self._get_view_builder(req)
+        if id == 'private':
+            view = builder.build_private_parts(instance)
+        elif id == 'public':
+            view = builder.build_public_parts(instance)
+        else:
+            msg = _("Only private and public networks available")
+            raise exc.HTTPNotFound(explanation=msg)
+
+        return {id: view}
+
+    def _get_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV10()
 
-    def private(self, req, server_id):
-        instance = self._get_instance(req, server_id)
-        return {'private': self.builder.build_private_parts(instance)}
+
+class ControllerV11(Controller):
+
+    def index(self, req, server_id):
+        context = req.environ['nova.context']
+        interfaces = self._get_virtual_interfaces(context, server_id)
+        networks = self._get_view_builder(req).build(interfaces)
+        return {'addresses': networks}
 
     def show(self, req, server_id, id):
-        return faults.Fault(exc.HTTPNotImplemented())
+        context = req.environ['nova.context']
+        interfaces = self._get_virtual_interfaces(context, server_id)
+        network = self._get_view_builder(req).build_network(interfaces, id)
 
-    def create(self, req, server_id, body):
-        return faults.Fault(exc.HTTPNotImplemented())
+        if network is None:
+            msg = _("Instance is not a member of specified network")
+            raise exc.HTTPNotFound(explanation=msg)
 
-    def delete(self, req, server_id, id):
-        return faults.Fault(exc.HTTPNotImplemented())
+        return network
+
+    def _get_virtual_interfaces(self, context, server_id):
+        try:
+            return db.api.virtual_interface_get_by_instance(context, server_id)
+        except nova.exception.InstanceNotFound:
+            msg = _("Instance does not exist")
+            raise exc.HTTPNotFound(explanation=msg)
+
+    def _get_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV11()
+
+
+def create_resource(version):
+    controller = {
+        '1.0': ControllerV10,
+        '1.1': ControllerV11,
+    }[version]()
 
+    xmlns = {
+        '1.0': wsgi.XMLNS_V10,
+        '1.1': wsgi.XMLNS_V11,
+    }[version]
 
-def create_resource():
     metadata = {
         'list_collections': {
             'public':  {'item_name': 'ip', 'item_key': 'addr'},
@@ -72,8 +120,8 @@ def create_resource():
 
     body_serializers = {
         'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
-                                                  xmlns=wsgi.XMLNS_V10),
+                                                  xmlns=xmlns),
     }
     serializer = wsgi.ResponseSerializer(body_serializers)
 
-    return wsgi.Resource(Controller(), serializer=serializer)
+    return wsgi.Resource(controller, serializer=serializer)
diff --git a/nova/api/openstack/limits.py b/nova/api/openstack/limits.py
index d08287f6b..86afa3b62 100644
--- a/nova/api/openstack/limits.py
+++ b/nova/api/openstack/limits.py
@@ -25,14 +25,15 @@ import re
 import time
 import urllib
 import webob.exc
+from xml.dom import minidom
 
 from collections import defaultdict
 
 from webob.dec import wsgify
 
 from nova import quota
+from nova import utils
 from nova import wsgi as base_wsgi
-from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
 from nova.api.openstack.views import limits as limits_views
@@ -76,6 +77,58 @@ class LimitsControllerV11(LimitsController):
         return limits_views.ViewBuilderV11()
 
 
+class LimitsXMLSerializer(wsgi.XMLDictSerializer):
+
+    xmlns = wsgi.XMLNS_V11
+
+    def __init__(self):
+        pass
+
+    def _create_rates_node(self, xml_doc, rates):
+        rates_node = xml_doc.createElement('rates')
+        for rate in rates:
+            rate_node = xml_doc.createElement('rate')
+            rate_node.setAttribute('uri', rate['uri'])
+            rate_node.setAttribute('regex', rate['regex'])
+
+            for limit in rate['limit']:
+                limit_node = xml_doc.createElement('limit')
+                limit_node.setAttribute('value', str(limit['value']))
+                limit_node.setAttribute('verb', limit['verb'])
+                limit_node.setAttribute('remaining', str(limit['remaining']))
+                limit_node.setAttribute('unit', limit['unit'])
+                limit_node.setAttribute('next-available',
+                                        str(limit['next-available']))
+                rate_node.appendChild(limit_node)
+
+            rates_node.appendChild(rate_node)
+        return rates_node
+
+    def _create_absolute_node(self, xml_doc, absolutes):
+        absolute_node = xml_doc.createElement('absolute')
+        for key, value in absolutes.iteritems():
+            limit_node = xml_doc.createElement('limit')
+            limit_node.setAttribute('name', key)
+            limit_node.setAttribute('value', str(value))
+            absolute_node.appendChild(limit_node)
+        return absolute_node
+
+    def _limits_to_xml(self, xml_doc, limits):
+        limits_node = xml_doc.createElement('limits')
+        rates_node = self._create_rates_node(xml_doc, limits['rate'])
+        limits_node.appendChild(rates_node)
+
+        absolute_node = self._create_absolute_node(xml_doc, limits['absolute'])
+        limits_node.appendChild(absolute_node)
+
+        return limits_node
+
+    def index(self, limits_dict):
+        xml_doc = minidom.Document()
+        node = self._limits_to_xml(xml_doc, limits_dict['limits'])
+        return self.to_xml_string(node, False)
+
+
 def create_resource(version='1.0'):
     controller = {
         '1.0': LimitsControllerV10,
@@ -97,9 +150,13 @@ def create_resource(version='1.0'):
         },
     }
 
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(xmlns=xmlns, metadata=metadata),
+        '1.1': LimitsXMLSerializer(),
+    }[version]
+
     body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(xmlns=xmlns,
-                                                  metadata=metadata),
+        'application/xml': xml_serializer,
     }
 
     serializer = wsgi.ResponseSerializer(body_serializers)
@@ -119,6 +176,8 @@ class Limit(object):
         60 * 60 * 24: "DAY",
     }
 
+    UNIT_MAP = dict([(v, k) for k, v in UNITS.items()])
+
     def __init__(self, verb, uri, regex, value, unit):
         """
         Initialize a new `Limit`.
@@ -224,16 +283,30 @@ class RateLimitingMiddleware(base_wsgi.Middleware):
     is stored in memory for this implementation.
     """
 
-    def __init__(self, application, limits=None):
+    def __init__(self, application, limits=None, limiter=None, **kwargs):
         """
         Initialize new `RateLimitingMiddleware`, which wraps the given WSGI
         application and sets up the given limits.
 
         @param application: WSGI application to wrap
-        @param limits: List of dictionaries describing limits
+        @param limits: String describing limits
+        @param limiter: String identifying class for representing limits
+
+        Other parameters are passed to the constructor for the limiter.
         """
         base_wsgi.Middleware.__init__(self, application)
-        self._limiter = Limiter(limits or DEFAULT_LIMITS)
+
+        # Select the limiter class
+        if limiter is None:
+            limiter = Limiter
+        else:
+            limiter = utils.import_class(limiter)
+
+        # Parse the limits, if any are provided
+        if limits is not None:
+            limits = limiter.parse_limits(limits)
+
+        self._limiter = limiter(limits or DEFAULT_LIMITS, **kwargs)
 
     @wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
@@ -271,7 +344,7 @@ class Limiter(object):
     Rate-limit checking class which handles limits in memory.
     """
 
-    def __init__(self, limits):
+    def __init__(self, limits, **kwargs):
         """
         Initialize the new `Limiter`.
 
@@ -280,6 +353,12 @@ class Limiter(object):
         self.limits = copy.deepcopy(limits)
         self.levels = defaultdict(lambda: copy.deepcopy(limits))
 
+        # Pick up any per-user limit information
+        for key, value in kwargs.items():
+            if key.startswith('user:'):
+                username = key[5:]
+                self.levels[username] = self.parse_limits(value)
+
     def get_limits(self, username=None):
         """
         Return the limits for a given user.
@@ -305,6 +384,66 @@ class Limiter(object):
 
         return None, None
 
+    # Note: This method gets called before the class is instantiated,
+    # so this must be either a static method or a class method.  It is
+    # used to develop a list of limits to feed to the constructor.  We
+    # put this in the class so that subclasses can override the
+    # default limit parsing.
+    @staticmethod
+    def parse_limits(limits):
+        """
+        Convert a string into a list of Limit instances.  This
+        implementation expects a semicolon-separated sequence of
+        parenthesized groups, where each group contains a
+        comma-separated sequence consisting of HTTP method,
+        user-readable URI, a URI reg-exp, an integer number of
+        requests which can be made, and a unit of measure.  Valid
+        values for the latter are "SECOND", "MINUTE", "HOUR", and
+        "DAY".
+
+        @return: List of Limit instances.
+        """
+
+        # Handle empty limit strings
+        limits = limits.strip()
+        if not limits:
+            return []
+
+        # Split up the limits by semicolon
+        result = []
+        for group in limits.split(';'):
+            group = group.strip()
+            if group[:1] != '(' or group[-1:] != ')':
+                raise ValueError("Limit rules must be surrounded by "
+                                 "parentheses")
+            group = group[1:-1]
+
+            # Extract the Limit arguments
+            args = [a.strip() for a in group.split(',')]
+            if len(args) != 5:
+                raise ValueError("Limit rules must contain the following "
+                                 "arguments: verb, uri, regex, value, unit")
+
+            # Pull out the arguments
+            verb, uri, regex, value, unit = args
+
+            # Upper-case the verb
+            verb = verb.upper()
+
+            # Convert value--raises ValueError if it's not integer
+            value = int(value)
+
+            # Convert unit
+            unit = unit.upper()
+            if unit not in Limit.UNIT_MAP:
+                raise ValueError("Invalid units specified")
+            unit = Limit.UNIT_MAP[unit]
+
+            # Build a limit
+            result.append(Limit(verb, uri, regex, value, unit))
+
+        return result
+
 
 class WsgiLimiter(object):
     """
@@ -388,3 +527,19 @@ class WsgiLimiterProxy(object):
             return None, None
 
         return resp.getheader("X-Wait-Seconds"), resp.read() or None
+
+    # Note: This method gets called before the class is instantiated,
+    # so this must be either a static method or a class method.  It is
+    # used to develop a list of limits to feed to the constructor.
+    # This implementation returns an empty list, since all limit
+    # decisions are made by a remote server.
+    @staticmethod
+    def parse_limits(limits):
+        """
+        Ignore a limits string--simply doesn't apply for the limit
+        proxy.
+
+        @return: Empty list.
+        """
+
+        return []
diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
index 3b9169f81..d4f42bbf5 100644
--- a/nova/api/openstack/server_metadata.py
+++ b/nova/api/openstack/server_metadata.py
@@ -18,7 +18,6 @@
 from webob import exc
 
 from nova import compute
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova import exception
 from nova import quota
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 12af44a8d..7bef1d9b2 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -17,15 +17,16 @@ import base64
 import traceback
 
 from webob import exc
+import webob
 
 from nova import compute
+from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import create_instance_helper as helper
-from nova.api.openstack import faults
 import nova.api.openstack.views.addresses
 import nova.api.openstack.views.flavors
 import nova.api.openstack.views.images
@@ -62,7 +63,7 @@ class Controller(object):
             return exc.HTTPBadRequest(explanation=str(err))
         return servers
 
-    def _get_view_builder(self, req):
+    def _build_view(self, req, instance, is_detail=False):
         raise NotImplementedError()
 
     def _limit_items(self, items, req):
@@ -88,8 +89,7 @@ class Controller(object):
                 fixed_ip=fixed_ip,
                 recurse_zones=recurse_zones)
         limited_list = self._limit_items(instance_list, req)
-        builder = self._get_view_builder(req)
-        servers = [builder.build(inst, is_detail)['server']
+        servers = [self._build_view(req, inst, is_detail)['server']
                 for inst in limited_list]
         return dict(servers=servers)
 
@@ -99,20 +99,16 @@ class Controller(object):
         try:
             instance = self.compute_api.routing_get(
                 req.environ['nova.context'], id)
-            builder = self._get_view_builder(req)
-            return builder.build(instance, is_detail=True)
+            return self._build_view(req, instance, is_detail=True)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def create(self, req, body):
         """ Creates a new server for a given user """
         extra_values = None
         result = None
-        try:
-            extra_values, instances = self.helper.create_instance(
-                    req, body, self.compute_api.create)
-        except faults.Fault, f:
-            return f
+        extra_values, instances = self.helper.create_instance(
+                req, body, self.compute_api.create)
 
         # We can only return 1 instance via the API, if we happen to
         # build more than one...  instances is a list, so we'll just
@@ -121,8 +117,7 @@ class Controller(object):
         for key in ['instance_type', 'image_ref']:
             inst[key] = extra_values[key]
 
-        builder = self._get_view_builder(req)
-        server = builder.build(inst, is_detail=True)
+        server = self._build_view(req, inst, is_detail=True)
         server['server']['adminPass'] = extra_values['password']
         return server
 
@@ -133,7 +128,7 @@ class Controller(object):
             raise exc.HTTPUnprocessableEntity()
 
         if not body:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
 
         ctxt = req.environ['nova.context']
         update_dict = {}
@@ -148,7 +143,7 @@ class Controller(object):
         try:
             self.compute_api.update(ctxt, id, **update_dict)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
         return exc.HTTPNoContent()
 
@@ -172,7 +167,7 @@ class Controller(object):
         for key in actions.keys():
             if key in body:
                 return actions[key](body, req, id)
-        return faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def _action_change_password(self, input_dict, req, id):
         return exc.HTTPNotImplemented()
@@ -182,7 +177,7 @@ class Controller(object):
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in confirm-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
+            raise exc.HTTPBadRequest()
         return exc.HTTPNoContent()
 
     def _action_revert_resize(self, input_dict, req, id):
@@ -190,8 +185,8 @@ class Controller(object):
             self.compute_api.revert_resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in revert-resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     def _action_resize(self, input_dict, req, id):
         return exc.HTTPNotImplemented()
@@ -201,23 +196,23 @@ class Controller(object):
             reboot_type = input_dict['reboot']['type']
         else:
             LOG.exception(_("Missing argument 'type' for reboot"))
-            return faults.Fault(exc.HTTPUnprocessableEntity())
+            raise exc.HTTPUnprocessableEntity()
         try:
             # TODO(gundlach): pass reboot_type, support soft reboot in
             # virt driver
             self.compute_api.reboot(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in reboot %s"), e)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     def _action_migrate(self, input_dict, req, id):
         try:
             self.compute_api.resize(req.environ['nova.context'], id)
         except Exception, e:
             LOG.exception(_("Error in migrate %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def lock(self, req, id):
@@ -232,8 +227,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::lock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unlock(self, req, id):
@@ -248,8 +243,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unlock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_lock(self, req, id):
@@ -263,8 +258,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::get_lock %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def reset_network(self, req, id, body):
@@ -278,8 +273,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::reset_network %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def inject_network_info(self, req, id, body):
@@ -293,8 +288,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::inject_network_info %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def pause(self, req, id, body):
@@ -305,8 +300,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::pause %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unpause(self, req, id, body):
@@ -317,8 +312,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("Compute.api::unpause %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def suspend(self, req, id, body):
@@ -329,8 +324,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::suspend %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def resume(self, req, id, body):
@@ -341,8 +336,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::resume %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def rescue(self, req, id):
@@ -353,8 +348,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::rescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def unrescue(self, req, id):
@@ -365,8 +360,8 @@ class Controller(object):
         except:
             readable = traceback.format_exc()
             LOG.exception(_("compute.api::unrescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_ajax_console(self, req, id):
@@ -375,8 +370,8 @@ class Controller(object):
             self.compute_api.get_ajax_console(req.environ['nova.context'],
                 int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def get_vnc_console(self, req, id):
@@ -385,8 +380,8 @@ class Controller(object):
             self.compute_api.get_vnc_console(req.environ['nova.context'],
                                              int(id))
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     @scheduler_api.redirect_handler
     def diagnostics(self, req, id):
@@ -417,8 +412,8 @@ class ControllerV10(Controller):
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()
+            raise exc.HTTPNotFound()
+        return webob.Response(status_int=202)
 
     def _image_ref_from_req_data(self, data):
         return data['server']['imageId']
@@ -426,10 +421,10 @@ class ControllerV10(Controller):
     def _flavor_id_from_req_data(self, data):
         return data['server']['flavorId']
 
-    def _get_view_builder(self, req):
-        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV10()
-        return nova.api.openstack.views.servers.ViewBuilderV10(
-            addresses_builder)
+    def _build_view(self, req, instance, is_detail=False):
+        addresses = nova.api.openstack.views.addresses.ViewBuilderV10()
+        builder = nova.api.openstack.views.servers.ViewBuilderV10(addresses)
+        return builder.build(instance, is_detail=is_detail)
 
     def _limit_items(self, items, req):
         return common.limited(items, req)
@@ -441,18 +436,14 @@ class ControllerV10(Controller):
 
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
-        try:
-            if 'resize' in input_dict and 'flavorId' in input_dict['resize']:
-                flavor_id = input_dict['resize']['flavorId']
-                self.compute_api.resize(req.environ['nova.context'], id,
-                        flavor_id)
-            else:
-                LOG.exception(_("Missing 'flavorId' argument for resize"))
-                return faults.Fault(exc.HTTPUnprocessableEntity())
-        except Exception, e:
-            LOG.exception(_("Error in resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+        if 'resize' in input_dict and 'flavorId' in input_dict['resize']:
+            flavor_id = input_dict['resize']['flavorId']
+            self.compute_api.resize(req.environ['nova.context'], id,
+                    flavor_id)
+        else:
+            LOG.exception(_("Missing 'flavorId' argument for resize"))
+            raise exc.HTTPUnprocessableEntity()
+        return webob.Response(status_int=202)
 
     def _action_rebuild(self, info, request, instance_id):
         context = request.environ['nova.context']
@@ -463,18 +454,16 @@ class ControllerV10(Controller):
         except (KeyError, TypeError):
             msg = _("Could not parse imageId from request.")
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
         try:
             self.compute_api.rebuild(context, instance_id, image_id)
         except exception.BuildInProgress:
             msg = _("Instance %d is currently being rebuilt.") % instance_id
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPConflict(explanation=msg))
+            raise exc.HTTPConflict(explanation=msg)
 
-        response = exc.HTTPAccepted()
-        response.empty_body = True
-        return response
+        return webob.Response(status_int=202)
 
     def _get_server_admin_password(self, server):
         """ Determine the admin password for a server on creation """
@@ -489,7 +478,7 @@ class ControllerV11(Controller):
         try:
             self.compute_api.delete(req.environ['nova.context'], id)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
     def _image_ref_from_req_data(self, data):
         return data['server']['imageRef']
@@ -498,16 +487,18 @@ class ControllerV11(Controller):
         href = data['server']['flavorRef']
         return common.get_id_from_href(href)
 
-    def _get_view_builder(self, req):
+    def _build_view(self, req, instance, is_detail=False):
         base_url = req.application_url
         flavor_builder = nova.api.openstack.views.flavors.ViewBuilderV11(
             base_url)
         image_builder = nova.api.openstack.views.images.ViewBuilderV11(
             base_url)
         addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
-        return nova.api.openstack.views.servers.ViewBuilderV11(
+        builder = nova.api.openstack.views.servers.ViewBuilderV11(
             addresses_builder, flavor_builder, image_builder, base_url)
 
+        return builder.build(instance, is_detail=is_detail)
+
     def _action_change_password(self, input_dict, req, id):
         context = req.environ['nova.context']
         if (not 'changePassword' in input_dict
@@ -519,7 +510,7 @@ class ControllerV11(Controller):
             msg = _("Invalid adminPass")
             return exc.HTTPBadRequest(explanation=msg)
         self.compute_api.set_admin_password(context, id, password)
-        return exc.HTTPAccepted()
+        return webob.Response(status_int=202)
 
     def _limit_items(self, items, req):
         return common.limited_by_marker(items, req)
@@ -531,7 +522,7 @@ class ControllerV11(Controller):
         except AttributeError as ex:
             msg = _("Unable to parse metadata key/value pairs.")
             LOG.debug(msg)
-            raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
     def _decode_personalities(self, personalities):
         """Decode the Base64-encoded personalities."""
@@ -542,14 +533,14 @@ class ControllerV11(Controller):
             except (KeyError, TypeError):
                 msg = _("Unable to parse personality path/contents.")
                 LOG.info(msg)
-                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+                raise exc.HTTPBadRequest(explanation=msg)
 
             try:
                 personality["contents"] = base64.b64decode(contents)
             except TypeError:
                 msg = _("Personality content could not be Base64 decoded.")
                 LOG.info(msg)
-                raise faults.Fault(exc.HTTPBadRequest(explanation=msg))
+                raise exc.HTTPBadRequest(explanation=msg)
 
     def _action_resize(self, input_dict, req, id):
         """ Resizes a given instance to the flavor size requested """
@@ -561,11 +552,11 @@ class ControllerV11(Controller):
                         flavor_id)
             else:
                 LOG.exception(_("Missing 'flavorRef' argument for resize"))
-                return faults.Fault(exc.HTTPUnprocessableEntity())
+                raise exc.HTTPUnprocessableEntity()
         except Exception, e:
             LOG.exception(_("Error in resize %s"), e)
-            return faults.Fault(exc.HTTPBadRequest())
-        return exc.HTTPAccepted()
+            raise exc.HTTPBadRequest()
+        return webob.Response(status_int=202)
 
     def _action_rebuild(self, info, request, instance_id):
         context = request.environ['nova.context']
@@ -576,7 +567,7 @@ class ControllerV11(Controller):
         except (KeyError, TypeError):
             msg = _("Could not parse imageRef from request.")
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPBadRequest(explanation=msg))
+            raise exc.HTTPBadRequest(explanation=msg)
 
         personalities = info["rebuild"].get("personality", [])
         metadata = info["rebuild"].get("metadata")
@@ -592,11 +583,9 @@ class ControllerV11(Controller):
         except exception.BuildInProgress:
             msg = _("Instance %d is currently being rebuilt.") % instance_id
             LOG.debug(msg)
-            return faults.Fault(exc.HTTPConflict(explanation=msg))
+            raise exc.HTTPConflict(explanation=msg)
 
-        response = exc.HTTPAccepted()
-        response.empty_body = True
-        return response
+        return webob.Response(status_int=202)
 
     def get_default_xmlns(self, req):
         return common.XML_NS_V11
diff --git a/nova/api/openstack/shared_ip_groups.py b/nova/api/openstack/shared_ip_groups.py
index cf2ddbabb..54d0a8334 100644
--- a/nova/api/openstack/shared_ip_groups.py
+++ b/nova/api/openstack/shared_ip_groups.py
@@ -17,7 +17,6 @@
 
 from webob import exc
 
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -26,27 +25,27 @@ class Controller(object):
 
     def index(self, req, **kwargs):
         """ Returns a list of Shared IP Groups for the user """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def show(self, req, id, **kwargs):
         """ Shows in-depth information on a specific Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def update(self, req, id, **kwargs):
         """ You can't update a Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def delete(self, req, id, **kwargs):
         """ Deletes a Shared IP Group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def detail(self, req, **kwargs):
         """ Returns a complete list of Shared IP Groups """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
     def create(self, req, **kwargs):
         """ Creates a new Shared IP group """
-        raise faults.Fault(exc.HTTPNotImplemented())
+        raise exc.HTTPNotImplemented()
 
 
 def create_resource():
diff --git a/nova/api/openstack/users.py b/nova/api/openstack/users.py
index 6ae1eaf2a..8dd72d559 100644
--- a/nova/api/openstack/users.py
+++ b/nova/api/openstack/users.py
@@ -19,7 +19,6 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 from nova.auth import manager
 
@@ -69,7 +68,7 @@ class Controller(object):
             user = None
 
         if user is None:
-            raise faults.Fault(exc.HTTPNotFound())
+            raise exc.HTTPNotFound()
 
         return dict(user=_translate_keys(user))
 
diff --git a/nova/api/openstack/versions.py b/nova/api/openstack/versions.py
index a634c3267..df7a94b7e 100644
--- a/nova/api/openstack/versions.py
+++ b/nova/api/openstack/versions.py
@@ -15,13 +15,18 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from datetime import datetime
 import webob
 import webob.dec
+from xml.dom import minidom
 
 import nova.api.openstack.views.versions
 from nova.api.openstack import wsgi
 
 
+ATOM_XMLNS = "http://www.w3.org/2005/Atom"
+
+
 class Versions(wsgi.Resource):
     def __init__(self):
         metadata = {
@@ -32,11 +37,19 @@ class Versions(wsgi.Resource):
         }
 
         body_serializers = {
-            'application/xml': wsgi.XMLDictSerializer(metadata=metadata),
+            'application/atom+xml': VersionsAtomSerializer(metadata=metadata),
+            'application/xml': VersionsXMLSerializer(metadata=metadata),
         }
         serializer = wsgi.ResponseSerializer(body_serializers)
 
-        wsgi.Resource.__init__(self, None, serializer=serializer)
+        supported_content_types = ('application/json',
+                                   'application/xml',
+                                   'application/atom+xml')
+        deserializer = wsgi.RequestDeserializer(
+            supported_content_types=supported_content_types)
+
+        wsgi.Resource.__init__(self, None, serializer=serializer,
+                               deserializer=deserializer)
 
     def dispatch(self, request, *args):
         """Respond to a request for all OpenStack API versions."""
@@ -44,13 +57,143 @@ class Versions(wsgi.Resource):
             {
                 "id": "v1.1",
                 "status": "CURRENT",
+                #TODO(wwolf) get correct value for these
+                "updated": "2011-07-18T11:30:00Z",
             },
             {
                 "id": "v1.0",
                 "status": "DEPRECATED",
+                #TODO(wwolf) get correct value for these
+                "updated": "2010-10-09T11:30:00Z",
             },
         ]
 
         builder = nova.api.openstack.views.versions.get_view_builder(request)
         versions = [builder.build(version) for version in version_objs]
         return dict(versions=versions)
+
+
+class VersionsXMLSerializer(wsgi.XMLDictSerializer):
+    def _versions_to_xml(self, versions):
+        root = self._xml_doc.createElement('versions')
+
+        for version in versions:
+            root.appendChild(self._create_version_node(version))
+
+        return root
+
+    def _create_version_node(self, version):
+        version_node = self._xml_doc.createElement('version')
+        version_node.setAttribute('id', version['id'])
+        version_node.setAttribute('status', version['status'])
+        version_node.setAttribute('updated', version['updated'])
+
+        for link in version['links']:
+            link_node = self._xml_doc.createElement('atom:link')
+            link_node.setAttribute('rel', link['rel'])
+            link_node.setAttribute('href', link['href'])
+            version_node.appendChild(link_node)
+
+        return version_node
+
+    def default(self, data):
+        self._xml_doc = minidom.Document()
+        node = self._versions_to_xml(data['versions'])
+
+        return self.to_xml_string(node)
+
+
+class VersionsAtomSerializer(wsgi.XMLDictSerializer):
+    def __init__(self, metadata=None, xmlns=None):
+        if not xmlns:
+            self.xmlns = ATOM_XMLNS
+        else:
+            self.xmlns = xmlns
+
+    def _create_text_elem(self, name, text, type=None):
+        elem = self._xml_doc.createElement(name)
+        if type:
+            elem.setAttribute('type', type)
+        elem_text = self._xml_doc.createTextNode(text)
+        elem.appendChild(elem_text)
+        return elem
+
+    def _get_most_recent_update(self, versions):
+        recent = None
+        for version in versions:
+            updated = datetime.strptime(version['updated'],
+                                        '%Y-%m-%dT%H:%M:%SZ')
+            if not recent:
+                recent = updated
+            elif updated > recent:
+                recent = updated
+
+        return recent.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def _get_base_url(self, link_href):
+        # Make sure no trailing /
+        link_href = link_href.rstrip('/')
+        return link_href.rsplit('/', 1)[0] + '/'
+
+    def _create_meta(self, root, versions):
+        title = self._create_text_elem('title', 'Available API Versions',
+                                       type='text')
+        # Set this updated to the most recently updated version
+        recent = self._get_most_recent_update(versions)
+        updated = self._create_text_elem('updated', recent)
+
+        base_url = self._get_base_url(versions[0]['links'][0]['href'])
+        id = self._create_text_elem('id', base_url)
+        link = self._xml_doc.createElement('link')
+        link.setAttribute('rel', 'self')
+        link.setAttribute('href', base_url)
+
+        author = self._xml_doc.createElement('author')
+        author_name = self._create_text_elem('name', 'Rackspace')
+        author_uri = self._create_text_elem('uri', 'http://www.rackspace.com/')
+        author.appendChild(author_name)
+        author.appendChild(author_uri)
+
+        root.appendChild(title)
+        root.appendChild(updated)
+        root.appendChild(id)
+        root.appendChild(author)
+        root.appendChild(link)
+
+    def _create_version_entries(self, root, versions):
+        for version in versions:
+            entry = self._xml_doc.createElement('entry')
+
+            id = self._create_text_elem('id', version['links'][0]['href'])
+            title = self._create_text_elem('title',
+                                           'Version %s' % version['id'],
+                                           type='text')
+            updated = self._create_text_elem('updated', version['updated'])
+
+            entry.appendChild(id)
+            entry.appendChild(title)
+            entry.appendChild(updated)
+
+            for link in version['links']:
+                link_node = self._xml_doc.createElement('link')
+                link_node.setAttribute('rel', link['rel'])
+                link_node.setAttribute('href', link['href'])
+            entry.appendChild(link_node)
+
+            content = self._create_text_elem('content',
+                'Version %s %s (%s)' %
+                    (version['id'],
+                     version['status'],
+                     version['updated']),
+                type='text')
+
+            entry.appendChild(content)
+            root.appendChild(entry)
+
+    def default(self, data):
+        self._xml_doc = minidom.Document()
+        node = self._xml_doc.createElementNS(self.xmlns, 'feed')
+        self._create_meta(node, data['versions'])
+        self._create_version_entries(node, data['versions'])
+
+        return self.to_xml_string(node)
diff --git a/nova/api/openstack/views/addresses.py b/nova/api/openstack/views/addresses.py
index b59eb4751..ddbf7a144 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -15,18 +15,22 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from nova import flags
 from nova import utils
 from nova.api.openstack import common
 
+FLAGS = flags.FLAGS
+
 
 class ViewBuilder(object):
-    ''' Models a server addresses response as a python dictionary.'''
+    """Models a server addresses response as a python dictionary."""
 
     def build(self, inst):
         raise NotImplementedError()
 
 
 class ViewBuilderV10(ViewBuilder):
+
     def build(self, inst):
         private_ips = self.build_private_parts(inst)
         public_ips = self.build_public_parts(inst)
@@ -40,11 +44,46 @@ class ViewBuilderV10(ViewBuilder):
 
 
 class ViewBuilderV11(ViewBuilder):
-    def build(self, inst):
-        # TODO(tr3buchet) - this shouldn't be hard coded to 4...
-        private_ips = utils.get_from_path(inst, 'fixed_ips/address')
-        private_ips = [dict(version=4, addr=a) for a in private_ips]
-        public_ips = utils.get_from_path(inst,
-                                         'fixed_ips/floating_ips/address')
-        public_ips = [dict(version=4, addr=a) for a in public_ips]
-        return dict(public=public_ips, private=private_ips)
+
+    def build(self, interfaces):
+        networks = {}
+        for interface in interfaces:
+            network_label = interface['network']['label']
+
+            if network_label not in networks:
+                networks[network_label] = []
+
+            ip_addresses = list(self._extract_ipv4_addresses(interface))
+
+            if FLAGS.use_ipv6:
+                ipv6_address = self._extract_ipv6_address(interface)
+                if ipv6_address is not None:
+                    ip_addresses.append(ipv6_address)
+
+            networks[network_label].extend(ip_addresses)
+
+        return networks
+
+    def build_network(self, interfaces, network_label):
+        for interface in interfaces:
+            if interface['network']['label'] == network_label:
+                ips = list(self._extract_ipv4_addresses(interface))
+                ipv6 = self._extract_ipv6_address(interface)
+                if ipv6 is not None:
+                    ips.append(ipv6)
+                return {network_label: ips}
+        return None
+
+    def _extract_ipv4_addresses(self, interface):
+        for fixed_ip in interface['fixed_ips']:
+            yield self._build_ip_entity(fixed_ip['address'], 4)
+            for floating_ip in fixed_ip.get('floating_ips', []):
+                yield self._build_ip_entity(floating_ip['address'], 4)
+
+    def _extract_ipv6_address(self, interface):
+        fixed_ipv6 = interface.get('fixed_ipv6')
+        if fixed_ipv6 is not None:
+            return self._build_ip_entity(fixed_ipv6, 6)
+
+    def _build_ip_entity(self, address, version):
+        return {'addr': address, 'version': version}
diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index 5c0510377..873ce212a 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -121,16 +121,20 @@ class ViewBuilderV11(ViewBuilder):
         href = self.generate_href(image_obj["id"])
         bookmark = self.generate_bookmark(image_obj["id"])
 
-        image["links"] = [{
-            "rel": "self",
-            "href": href,
-        }]
+        image["links"] = [
+            {
+                "rel": "self",
+                "href": href,
+            },
+            {
+                "rel": "bookmark",
+                "href": bookmark,
+            },
+
+        ]
 
         if detail:
             image["metadata"] = image_obj.get("properties", {})
-            image["links"].append({"rel": "bookmark",
-                                   "href": bookmark,
-            })
 
         return image
 
diff --git a/nova/api/openstack/views/limits.py b/nova/api/openstack/views/limits.py
index 934b4921a..f603d7cb4 100644
--- a/nova/api/openstack/views/limits.py
+++ b/nova/api/openstack/views/limits.py
@@ -15,9 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import datetime
 import time
 
 from nova.api.openstack import common
+from nova import utils
 
 
 class ViewBuilder(object):
@@ -113,10 +115,12 @@ class ViewBuilderV11(ViewBuilder):
         return limits
 
     def _build_rate_limit(self, rate_limit):
+        next_avail = \
+            datetime.datetime.utcfromtimestamp(rate_limit["resetTime"])
         return {
             "verb": rate_limit["verb"],
             "value": rate_limit["value"],
             "remaining": int(rate_limit["remaining"]),
             "unit": rate_limit["unit"],
-            "next-available": rate_limit["resetTime"],
+            "next-available": utils.isotime(at=next_avail),
         }
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 67fb6a84e..7131db088 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -77,13 +77,12 @@ class ViewBuilder(object):
         inst_dict = {
             'id': inst['id'],
             'name': inst['display_name'],
-            'addresses': self.addresses_builder.build(inst),
             'status': power_mapping[inst.get('state')]}
 
         ctxt = nova.context.get_admin_context()
         compute_api = nova.compute.API()
 
-        if compute_api.has_finished_migration(ctxt, inst['id']):
+        if compute_api.has_finished_migration(ctxt, inst['uuid']):
             inst_dict['status'] = 'RESIZE-CONFIRM'
 
         # Return the metadata as a dictionary
@@ -98,10 +97,15 @@ class ViewBuilder(object):
 
         self._build_image(inst_dict, inst)
         self._build_flavor(inst_dict, inst)
+        self._build_addresses(inst_dict, inst)
 
         inst_dict['uuid'] = inst['uuid']
         return dict(server=inst_dict)
 
+    def _build_addresses(self, response, inst):
+        """Return the addresses sub-resource of a server."""
+        raise NotImplementedError()
+
     def _build_image(self, response, inst):
         """Return the image sub-resource of a server."""
         raise NotImplementedError()
@@ -128,6 +132,9 @@ class ViewBuilderV10(ViewBuilder):
         if 'instance_type' in dict(inst):
             response['flavorId'] = inst['instance_type']['flavorid']
 
+    def _build_addresses(self, response, inst):
+        response['addresses'] = self.addresses_builder.build(inst)
+
 
 class ViewBuilderV11(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
@@ -151,6 +158,10 @@ class ViewBuilderV11(ViewBuilder):
             flavor_ref = self.flavor_builder.generate_href(flavor_id)
             response["flavorRef"] = flavor_ref
 
+    def _build_addresses(self, response, inst):
+        interfaces = inst.get('virtual_interfaces', [])
+        response['addresses'] = self.addresses_builder.build(interfaces)
+
     def _build_extra(self, response, inst):
         self._build_links(response, inst)
 
diff --git a/nova/api/openstack/views/versions.py b/nova/api/openstack/views/versions.py
index d0145c94a..9fa8f49dc 100644
--- a/nova/api/openstack/views/versions.py
+++ b/nova/api/openstack/views/versions.py
@@ -36,6 +36,7 @@ class ViewBuilder(object):
         version = {
             "id": version_data["id"],
             "status": version_data["status"],
+            "updated": version_data["updated"],
             "links": self._build_links(version_data),
         }
 
@@ -56,4 +57,4 @@ class ViewBuilder(object):
 
     def generate_href(self, version_number):
         """Create an url that refers to a specific version_number."""
-        return os.path.join(self.base_url, version_number)
+        return os.path.join(self.base_url, version_number) + '/'
diff --git a/nova/api/openstack/wsgi.py b/nova/api/openstack/wsgi.py
index c3f841aa5..1e5a5143d 100644
--- a/nova/api/openstack/wsgi.py
+++ b/nova/api/openstack/wsgi.py
@@ -20,21 +20,22 @@ LOG = logging.getLogger('nova.api.openstack.wsgi')
 class Request(webob.Request):
     """Add some Openstack API-specific logic to the base webob.Request."""
 
-    def best_match_content_type(self):
+    def best_match_content_type(self, supported_content_types=None):
         """Determine the requested response content-type.
 
         Based on the query extension then the Accept header.
 
         """
-        supported = ('application/json', 'application/xml')
+        supported_content_types = supported_content_types or \
+            ('application/json', 'application/xml')
 
         parts = self.path.rsplit('.', 1)
         if len(parts) > 1:
             ctype = 'application/{0}'.format(parts[1])
-            if ctype in supported:
+            if ctype in supported_content_types:
                 return ctype
 
-        bm = self.accept.best_match(supported)
+        bm = self.accept.best_match(supported_content_types)
 
         # default to application/json if we don't find a preference
         return bm or 'application/json'
@@ -151,7 +152,12 @@ class RequestHeadersDeserializer(ActionDispatcher):
 class RequestDeserializer(object):
     """Break up a Request object into more useful pieces."""
 
-    def __init__(self, body_deserializers=None, headers_deserializer=None):
+    def __init__(self, body_deserializers=None, headers_deserializer=None,
+                 supported_content_types=None):
+
+        self.supported_content_types = supported_content_types or \
+                ('application/json', 'application/xml')
+
         self.body_deserializers = {
             'application/xml': XMLDeserializer(),
             'application/json': JSONDeserializer(),
@@ -213,7 +219,7 @@ class RequestDeserializer(object):
             raise exception.InvalidContentType(content_type=content_type)
 
     def get_expected_content_type(self, request):
-        return request.best_match_content_type()
+        return request.best_match_content_type(self.supported_content_types)
 
     def get_action_args(self, request_environment):
         """Parse dictionary created by routes library."""
@@ -412,6 +418,7 @@ class Resource(wsgi.Application):
     serialized by requested content type.
 
     """
+
     def __init__(self, controller, deserializer=None, serializer=None):
         """
         :param controller: object that implement methods created by routes lib
@@ -441,7 +448,11 @@ class Resource(wsgi.Application):
             msg = _("Malformed request body")
             return faults.Fault(webob.exc.HTTPBadRequest(explanation=msg))
 
-        action_result = self.dispatch(request, action, args)
+        try:
+            action_result = self.dispatch(request, action, args)
+        except webob.exc.HTTPException as ex:
+            LOG.info(_("HTTP exception thrown: %s"), unicode(ex))
+            action_result = faults.Fault(ex)
 
         #TODO(bcwaldon): find a more elegant way to pass through non-dict types
         if type(action_result) is dict or action_result is None:
diff --git a/nova/api/openstack/zones.py b/nova/api/openstack/zones.py
index 2e02ec380..f7fd87bcd 100644
--- a/nova/api/openstack/zones.py
+++ b/nova/api/openstack/zones.py
@@ -27,7 +27,6 @@ from nova.scheduler import api
 
 from nova.api.openstack import create_instance_helper as helper
 from nova.api.openstack import common
-from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -127,11 +126,8 @@ class Controller(object):
         Returns a reservation ID (a UUID).
         """
         result = None
-        try:
-            extra_values, result = self.helper.create_instance(req, body,
-                                    self.compute_api.create_all_at_once)
-        except faults.Fault, f:
-            return f
+        extra_values, result = self.helper.create_instance(req, body,
+                                self.compute_api.create_all_at_once)
 
         reservation_id = result
         return {'reservation_id': reservation_id}
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 432658bbb..9994e5724 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -32,6 +32,7 @@ from nova import quota
 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
@@ -217,6 +218,9 @@ class API(base.Base):
         if reservation_id is None:
             reservation_id = utils.generate_uid('r')
 
+        root_device_name = ec2utils.properties_root_device_name(
+            image['properties'])
+
         base_options = {
             'reservation_id': reservation_id,
             'image_ref': image_href,
@@ -241,11 +245,61 @@ class API(base.Base):
             'availability_zone': availability_zone,
             'os_type': os_type,
             'architecture': architecture,
-            'vm_mode': vm_mode}
+            'vm_mode': vm_mode,
+            'root_device_name': root_device_name}
+
+        return (num_instances, base_options, image)
+
+    def _update_image_block_device_mapping(self, elevated_context, 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):
+            LOG.debug(_("bdm %s"), bdm)
+
+            virtual_name = bdm['virtual']
+            if virtual_name == 'ami' or virtual_name == 'root':
+                continue
 
-        return (num_instances, base_options)
+            assert (virtual_name == 'swap' or
+                    virtual_name.startswith('ephemeral'))
+            values = {
+                'instance_id': instance_id,
+                'device_name': bdm['device'],
+                'virtual_name': virtual_name, }
+            self.db.block_device_mapping_update_or_create(elevated_context,
+                                                          values)
+
+    def _update_block_device_mapping(self, elevated_context, instance_id,
+                                     block_device_mapping):
+        """tell vm driver to attach volume at boot time by updating
+        BlockDeviceMapping
+        """
+        for bdm in block_device_mapping:
+            LOG.debug(_('bdm %s'), bdm)
+            assert 'device_name' in bdm
 
-    def create_db_entry_for_new_instance(self, context, base_options,
+            values = {'instance_id': instance_id}
+            for key in ('device_name', 'delete_on_termination', 'virtual_name',
+                        'snapshot_id', 'volume_id', 'volume_size',
+                        'no_device'):
+                values[key] = bdm.get(key)
+
+            # NOTE(yamahata): NoDevice eliminates devices defined in image
+            #                 files by command line option.
+            #                 (--block-device-mapping)
+            if bdm.get('virtual_name') == 'NoDevice':
+                values['no_device'] = True
+                for k in ('delete_on_termination', 'volume_id',
+                          'snapshot_id', 'volume_id', 'volume_size',
+                          'virtual_name'):
+                    values[k] = None
+
+            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):
         """Create an entry in the DB for this new instance,
         including any related table updates (such as security group,
@@ -278,23 +332,14 @@ class API(base.Base):
                                                 instance_id,
                                                 security_group_id)
 
-        block_device_mapping = block_device_mapping or []
-        # NOTE(yamahata)
-        # tell vm driver to attach volume at boot time by updating
-        # BlockDeviceMapping
-        for bdm in block_device_mapping:
-            LOG.debug(_('bdm %s'), bdm)
-            assert 'device_name' in bdm
-            values = {
-                'instance_id': instance_id,
-                'device_name': bdm['device_name'],
-                'delete_on_termination': bdm.get('delete_on_termination'),
-                'virtual_name': bdm.get('virtual_name'),
-                'snapshot_id': bdm.get('snapshot_id'),
-                'volume_id': bdm.get('volume_id'),
-                'volume_size': bdm.get('volume_size'),
-                'no_device': bdm.get('no_device')}
-            self.db.block_device_mapping_create(elevated, values)
+        # BlockDeviceMapping table
+        self._update_image_block_device_mapping(elevated, instance_id,
+            image['properties'].get('mappings', []))
+        self._update_block_device_mapping(elevated, instance_id,
+            image['properties'].get('block_device_mapping', []))
+        # override via command line option
+        self._update_block_device_mapping(elevated, instance_id,
+                                          block_device_mapping)
 
         # Set sane defaults if not specified
         updates = {}
@@ -356,7 +401,7 @@ class API(base.Base):
         """Provision the instances by passing the whole request to
         the Scheduler for execution. Returns a Reservation ID
         related to the creation of all of these instances."""
-        num_instances, base_options = self._check_create_parameters(
+        num_instances, base_options, image = self._check_create_parameters(
                                context, instance_type,
                                image_href, kernel_id, ramdisk_id,
                                min_count, max_count,
@@ -394,7 +439,7 @@ class API(base.Base):
         Returns a list of instance dicts.
         """
 
-        num_instances, base_options = self._check_create_parameters(
+        num_instances, base_options, image = self._check_create_parameters(
                                context, instance_type,
                                image_href, kernel_id, ramdisk_id,
                                min_count, max_count,
@@ -404,10 +449,11 @@ class API(base.Base):
                                injected_files, admin_password, zone_blob,
                                reservation_id)
 
+        block_device_mapping = block_device_mapping or []
         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,
+            instance = self.create_db_entry_for_new_instance(context, image,
                                     base_options, security_group,
                                     block_device_mapping, num=num)
             instances.append(instance)
@@ -421,10 +467,10 @@ class API(base.Base):
 
         return [dict(x.iteritems()) for x in instances]
 
-    def has_finished_migration(self, context, instance_id):
+    def has_finished_migration(self, context, instance_uuid):
         """Returns true if an instance has a finished migration."""
         try:
-            db.migration_get_by_instance_and_status(context, instance_id,
+            db.migration_get_by_instance_and_status(context, instance_uuid,
                     'finished')
             return True
         except exception.NotFound:
@@ -822,39 +868,50 @@ class API(base.Base):
                                    instance_id,
                                    params=rebuild_params)
 
+    @scheduler_api.reroute_compute("revert_resize")
     def revert_resize(self, context, instance_id):
         """Reverts a resize, deleting the 'new' instance in the process."""
         context = context.elevated()
+        instance_ref = self._get_instance(context, instance_id,
+                'revert_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
-                instance_id, 'finished')
+                instance_ref['uuid'], 'finished')
         if not migration_ref:
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
 
         params = {'migration_id': migration_ref['id']}
-        self._cast_compute_message('revert_resize', context, instance_id,
-                migration_ref['dest_compute'], params=params)
+        self._cast_compute_message('revert_resize', context,
+                                   instance_ref['uuid'],
+                                   migration_ref['source_compute'],
+                                   params=params)
+
         self.db.migration_update(context, migration_ref['id'],
                 {'status': 'reverted'})
 
+    @scheduler_api.reroute_compute("confirm_resize")
     def confirm_resize(self, context, instance_id):
         """Confirms a migration/resize and deletes the 'old' instance."""
         context = context.elevated()
+        instance_ref = self._get_instance(context, instance_id,
+                'confirm_resize')
         migration_ref = self.db.migration_get_by_instance_and_status(context,
-                instance_id, 'finished')
+                instance_ref['uuid'], 'finished')
         if not migration_ref:
             raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
                                                       status='finished')
-        instance_ref = self.db.instance_get(context, instance_id)
         params = {'migration_id': migration_ref['id']}
-        self._cast_compute_message('confirm_resize', context, instance_id,
-                migration_ref['source_compute'], params=params)
+        self._cast_compute_message('confirm_resize', context,
+                                   instance_ref['uuid'],
+                                   migration_ref['dest_compute'],
+                                   params=params)
 
         self.db.migration_update(context, migration_ref['id'],
                 {'status': 'confirmed'})
         self.db.instance_update(context, instance_id,
                 {'host': migration_ref['dest_compute'], })
 
+    @scheduler_api.reroute_compute("resize")
     def resize(self, context, instance_id, flavor_id=None):
         """Resize (ie, migrate) a running instance.
 
@@ -862,8 +919,8 @@ class API(base.Base):
         the original flavor_id. If flavor_id is not None, the instance should
         be migrated to a new host and resized to the new flavor_id.
         """
-        instance = self.db.instance_get(context, instance_id)
-        current_instance_type = instance['instance_type']
+        instance_ref = self._get_instance(context, instance_id, 'resize')
+        current_instance_type = instance_ref['instance_type']
 
         # If flavor_id is not provided, only migrate the instance.
         if not flavor_id:
@@ -891,10 +948,11 @@ class API(base.Base):
             raise exception.ApiError(_("Invalid flavor: cannot use"
                     "the same flavor. "))
 
+        instance_ref = self._get_instance(context, instance_id, 'resize')
         self._cast_scheduler_message(context,
                     {"method": "prep_resize",
                      "args": {"topic": FLAGS.compute_topic,
-                              "instance_id": instance_id,
+                              "instance_id": instance_ref['uuid'],
                               "flavor_id": new_instance_type['id']}})
 
     @scheduler_api.reroute_compute("add_fixed_ip")
diff --git a/nova/compute/instance_types.py b/nova/compute/instance_types.py
index 1d246e445..c13a629a9 100644
--- a/nova/compute/instance_types.py
+++ b/nova/compute/instance_types.py
@@ -112,7 +112,7 @@ def get_instance_type(id):
         return get_default_instance_type()
     try:
         ctxt = context.get_admin_context()
-        return db.instance_type_get_by_id(ctxt, id)
+        return db.instance_type_get(ctxt, id)
     except exception.DBError:
         raise exception.ApiError(_("Unknown instance type: %s") % id)
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 960dfea54..5819a520a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -77,8 +77,6 @@ flags.DEFINE_integer('live_migration_retry_count', 30,
 flags.DEFINE_integer("rescue_timeout", 0,
                      "Automatically unrescue an instance after N seconds."
                      " Set to 0 to disable.")
-flags.DEFINE_bool('auto_assign_floating_ip', False,
-                  'Autoassigning floating ip to VM')
 flags.DEFINE_integer('host_state_interval', 120,
                      'Interval in seconds for querying the host status')
 
@@ -93,6 +91,10 @@ def checks_instance_lock(function):
     """Decorator to prevent action against locked instances for non-admins."""
     @functools.wraps(function)
     def decorated_function(self, context, instance_id, *args, **kwargs):
+        #TODO(anyone): this being called instance_id is forcing a slightly
+        # confusing convention of pushing instance_uuids
+        # through an "instance_id" key in the queue args dict when
+        # casting through the compute API
         LOG.info(_("check_instance_lock: decorating: |%s|"), function,
                  context=context)
         LOG.info(_("check_instance_lock: arguments: |%(self)s| |%(context)s|"
@@ -224,6 +226,17 @@ class ComputeManager(manager.SchedulerDependentManager):
         for bdm in self.db.block_device_mapping_get_all_by_instance(
             context, instance_id):
             LOG.debug(_("setting up bdm %s"), bdm)
+
+            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'))
+                continue
+
             if ((bdm['snapshot_id'] is not None) and
                 (bdm['volume_id'] is None)):
                 # TODO(yamahata): default name and description
@@ -256,15 +269,6 @@ class ComputeManager(manager.SchedulerDependentManager):
                 block_device_mapping.append({'device_path': dev_path,
                                              'mount_device':
                                              bdm['device_name']})
-            elif bdm['virtual_name'] is not None:
-                # TODO(yamahata): ephemeral/swap device support
-                LOG.debug(_('block_device_mapping: '
-                            'ephemeral device is not supported yet'))
-            else:
-                # TODO(yamahata): NoDevice support
-                assert bdm['no_device']
-                LOG.debug(_('block_device_mapping: '
-                            'no device is not supported yet'))
 
         return block_device_mapping
 
@@ -272,16 +276,19 @@ class ComputeManager(manager.SchedulerDependentManager):
         """Launch a new instance with specified options."""
         context = context.elevated()
         instance = self.db.instance_get(context, instance_id)
-        instance.injected_files = kwargs.get('injected_files', [])
-        instance.admin_pass = kwargs.get('admin_password', None)
         if instance['name'] in self.driver.list_instances():
             raise exception.Error(_("Instance has already been created"))
         LOG.audit(_("instance %s: starting..."), instance_id,
                   context=context)
-        self.db.instance_update(context,
-                                instance_id,
-                                {'host': self.host, 'launched_on': self.host})
-
+        updates = {}
+        updates['host'] = self.host
+        updates['launched_on'] = self.host
+        # NOTE(vish): used by virt but not in database
+        updates['injected_files'] = kwargs.get('injected_files', [])
+        updates['admin_pass'] = kwargs.get('admin_password', None)
+        instance = self.db.instance_update(context,
+                                           instance_id,
+                                           updates)
         self.db.instance_set_state(context,
                                    instance_id,
                                    power_state.NOSTATE,
@@ -668,8 +675,10 @@ class ComputeManager(manager.SchedulerDependentManager):
     @checks_instance_lock
     def confirm_resize(self, context, instance_id, migration_id):
         """Destroys the source instance."""
-        context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+        migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
+
         self.driver.destroy(instance_ref)
         usage_info = utils.usage_from_instance(instance_ref)
         notifier.notify('compute.%s' % self.host,
@@ -686,17 +695,16 @@ class ComputeManager(manager.SchedulerDependentManager):
         source machine.
 
         """
-        instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
 
         self.driver.destroy(instance_ref)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'finish_revert_resize',
-                 'args': {
-                       'migration_id': migration_ref['id'],
-                       'instance_id': instance_id, },
+                 'args': {'migration_id': migration_ref['id']},
                 })
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
@@ -708,17 +716,20 @@ class ComputeManager(manager.SchedulerDependentManager):
         in the database.
 
         """
-        instance_ref = self.db.instance_get(context, instance_id)
         migration_ref = self.db.migration_get(context, migration_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
+
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['old_flavor_id'])
 
         # Just roll back the record. There's no need to resize down since
         # the 'old' VM already has the preferred attributes
-        self.db.instance_update(context, instance_id,
+        self.db.instance_update(context, instance_ref['uuid'],
            dict(memory_mb=instance_type['memory_mb'],
                 vcpus=instance_type['vcpus'],
-                local_gb=instance_type['local_gb']))
+                local_gb=instance_type['local_gb'],
+                instance_type_id=instance_type['id']))
 
         self.driver.revert_resize(instance_ref)
         self.db.migration_update(context, migration_id,
@@ -738,35 +749,42 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         context = context.elevated()
-        instance_ref = self.db.instance_get(context, instance_id)
+
+        # Because of checks_instance_lock, this must currently be called
+        # instance_id. However, the compute API is always passing the UUID
+        # of the instance down
+        instance_ref = self.db.instance_get_by_uuid(context, instance_id)
+
         if instance_ref['host'] == FLAGS.host:
             raise exception.Error(_(
                     'Migration error: destination same as source!'))
 
-        instance_type = self.db.instance_type_get_by_flavor_id(context,
+        old_instance_type = self.db.instance_type_get(context,
+                instance_ref['instance_type_id'])
+        new_instance_type = self.db.instance_type_get_by_flavor_id(context,
                 flavor_id)
+
         migration_ref = self.db.migration_create(context,
-                {'instance_id': instance_id,
+                {'instance_uuid': instance_ref['uuid'],
                  'source_compute': instance_ref['host'],
                  'dest_compute': FLAGS.host,
                  'dest_host':   self.driver.get_host_ip_addr(),
-                 'old_flavor_id': instance_type['flavorid'],
+                 'old_flavor_id': old_instance_type['flavorid'],
                  'new_flavor_id': flavor_id,
                  'status':      'pre-migrating'})
 
-        LOG.audit(_('instance %s: migrating to '), instance_id,
+        LOG.audit(_('instance %s: migrating'), instance_ref['uuid'],
                 context=context)
         topic = self.db.queue_get_for(context, FLAGS.compute_topic,
                 instance_ref['host'])
         rpc.cast(context, topic,
                 {'method': 'resize_instance',
-                 'args': {
-                       'migration_id': migration_ref['id'],
-                       'instance_id': instance_id, },
-                })
+                 'args': {'instance_id': instance_ref['uuid'],
+                          'migration_id': migration_ref['id']}})
+
         usage_info = utils.usage_from_instance(instance_ref,
-                              new_instance_type=instance_type['name'],
-                              new_instance_type_id=instance_type['id'])
+                              new_instance_type=new_instance_type['name'],
+                              new_instance_type_id=new_instance_type['id'])
         notifier.notify('compute.%s' % self.host,
                             'compute.instance.resize.prep',
                             notifier.INFO,
@@ -777,7 +795,9 @@ class ComputeManager(manager.SchedulerDependentManager):
     def resize_instance(self, context, instance_id, migration_id):
         """Starts the migration of a running instance to another host."""
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
+
         self.db.migration_update(context,
                                  migration_id,
                                  {'status': 'migrating'})
@@ -793,10 +813,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         topic = self.db.queue_get_for(context,
                                       FLAGS.compute_topic,
                                       migration_ref['dest_compute'])
+        params = {'migration_id': migration_id,
+                  'disk_info': disk_info,
+                  'instance_id': instance_ref['uuid']}
         rpc.cast(context, topic, {'method': 'finish_resize',
-                                  'args': {'migration_id': migration_id,
-                                           'instance_id': instance_id,
-                                           'disk_info': disk_info}})
+                                  'args': params})
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
     @checks_instance_lock
@@ -808,24 +829,21 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         """
         migration_ref = self.db.migration_get(context, migration_id)
-        instance_ref = self.db.instance_get(context,
-                migration_ref['instance_id'])
-        # TODO(mdietz): apply the rest of the instance_type attributes going
-        # after they're supported
+        instance_ref = self.db.instance_get_by_uuid(context,
+                migration_ref.instance_uuid)
         instance_type = self.db.instance_type_get_by_flavor_id(context,
                 migration_ref['new_flavor_id'])
-        self.db.instance_update(context, instance_id,
+        self.db.instance_update(context, instance_ref.uuid,
                dict(instance_type_id=instance_type['id'],
                     memory_mb=instance_type['memory_mb'],
                     vcpus=instance_type['vcpus'],
                     local_gb=instance_type['local_gb']))
 
-        # reload the updated instance ref
-        # FIXME(mdietz): is there reload functionality?
-        instance = self.db.instance_get(context, instance_id)
+        instance_ref = self.db.instance_get_by_uuid(context,
+                                            instance_ref.uuid)
         network_info = self.network_api.get_instance_nw_info(context,
-                                                             instance)
-        self.driver.finish_resize(instance, disk_info, network_info)
+                                                             instance_ref)
+        self.driver.finish_resize(instance_ref, disk_info, network_info)
 
         self.db.migration_update(context, migration_id,
                 {'status': 'finished', })
@@ -957,7 +975,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         context = context.elevated()
         LOG.debug(_('instance %s: getting locked state'), instance_id,
                   context=context)
-        instance_ref = self.db.instance_get(context, instance_id)
+        if utils.is_uuid_like(instance_id):
+            uuid = instance_id
+            instance_ref = self.db.instance_get_by_uuid(context, uuid)
+        else:
+            instance_ref = self.db.instance_get(context, instance_id)
         return instance_ref['locked']
 
     @checks_instance_lock
diff --git a/nova/db/api.py b/nova/db/api.py
index b7c5700e5..47308bdba 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -314,9 +314,9 @@ def migration_get(context, migration_id):
     return IMPL.migration_get(context, migration_id)
 
 
-def migration_get_by_instance_and_status(context, instance_id, status):
-    """Finds a migration by the instance id its migrating."""
-    return IMPL.migration_get_by_instance_and_status(context, instance_id,
+def migration_get_by_instance_and_status(context, instance_uuid, status):
+    """Finds a migration by the instance uuid its migrating."""
+    return IMPL.migration_get_by_instance_and_status(context, instance_uuid,
             status)
 
 
@@ -332,13 +332,14 @@ def fixed_ip_associate(context, address, instance_id):
     return IMPL.fixed_ip_associate(context, address, instance_id)
 
 
-def fixed_ip_associate_pool(context, network_id, instance_id):
-    """Find free ip in network and associate it to instance.
+def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None):
+    """Find free ip in network and associate it to instance or host.
 
     Raises if one is not available.
 
     """
-    return IMPL.fixed_ip_associate_pool(context, network_id, instance_id)
+    return IMPL.fixed_ip_associate_pool(context, network_id,
+                                        instance_id, host)
 
 
 def fixed_ip_create(context, values):
@@ -361,9 +362,9 @@ def fixed_ip_get_all(context):
     return IMPL.fixed_ip_get_all(context)
 
 
-def fixed_ip_get_all_by_host(context, host):
-    """Get all defined fixed ips used by a host."""
-    return IMPL.fixed_ip_get_all_by_host(context, host)
+def fixed_ip_get_all_by_instance_host(context, host):
+    """Get all allocated fixed ips filtered by instance host."""
+    return IMPL.fixed_ip_get_all_instance_by_host(context, host)
 
 
 def fixed_ip_get_by_address(context, address):
@@ -376,6 +377,11 @@ def fixed_ip_get_by_instance(context, instance_id):
     return IMPL.fixed_ip_get_by_instance(context, instance_id)
 
 
+def fixed_ip_get_by_network_host(context, network_id, host):
+    """Get fixed ip for a host in a network."""
+    return IMPL.fixed_ip_get_by_network_host(context, network_id, host)
+
+
 def fixed_ip_get_by_virtual_interface(context, vif_id):
     """Get fixed ips by virtual interface or raise if none exist."""
     return IMPL.fixed_ip_get_by_virtual_interface(context, vif_id)
@@ -989,10 +995,16 @@ def block_device_mapping_create(context, values):
 
 
 def block_device_mapping_update(context, bdm_id, values):
-    """Create an entry of block device mapping"""
+    """Update an entry of block device mapping"""
     return IMPL.block_device_mapping_update(context, bdm_id, values)
 
 
+def block_device_mapping_update_or_create(context, values):
+    """Update an entry of block device mapping.
+    If not existed, create a new entry"""
+    return IMPL.block_device_mapping_update_or_create(context, values)
+
+
 def block_device_mapping_get_all_by_instance(context, instance_id):
     """Get all block device mapping belonging to a instance"""
     return IMPL.block_device_mapping_get_all_by_instance(context, instance_id)
@@ -1299,9 +1311,9 @@ def instance_type_get_all(context, inactive=False):
     return IMPL.instance_type_get_all(context, inactive)
 
 
-def instance_type_get_by_id(context, id):
+def instance_type_get(context, id):
     """Get instance type by id."""
-    return IMPL.instance_type_get_by_id(context, id)
+    return IMPL.instance_type_get(context, id)
 
 
 def instance_type_get_by_name(context, name):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index ffd009513..ba03cabbc 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -18,7 +18,6 @@
 """
 Implementation of SQLAlchemy backend.
 """
-import traceback
 import warnings
 
 from nova import db
@@ -33,7 +32,6 @@ from sqlalchemy import or_
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import joinedload
 from sqlalchemy.orm import joinedload_all
-from sqlalchemy.sql import exists
 from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import literal_column
 
@@ -118,8 +116,23 @@ def require_context(f):
     return wrapper
 
 
+def require_instance_exists(f):
+    """Decorator to require the specified instance to exist.
+
+    Requres the wrapped function to use context and instance_id as
+    their first two arguments.
+    """
+
+    def wrapper(context, instance_id, *args, **kwargs):
+        db.api.instance_get(context, instance_id)
+        return f(context, instance_id, *args, **kwargs)
+    wrapper.__name__ = f.__name__
+    return wrapper
+
+
 ###################
 
+
 @require_admin_context
 def service_destroy(context, service_id):
     session = get_session()
@@ -657,7 +670,7 @@ def fixed_ip_associate(context, address, instance_id):
 
 
 @require_admin_context
-def fixed_ip_associate_pool(context, network_id, instance_id):
+def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None):
     session = get_session()
     with session.begin():
         network_or_none = or_(models.FixedIp.network_id == network_id,
@@ -667,6 +680,7 @@ def fixed_ip_associate_pool(context, network_id, instance_id):
                                filter_by(reserved=False).\
                                filter_by(deleted=False).\
                                filter_by(instance=None).\
+                               filter_by(host=None).\
                                with_lockmode('update').\
                                first()
         # NOTE(vish): if with_lockmode isn't supported, as in sqlite,
@@ -677,9 +691,12 @@ def fixed_ip_associate_pool(context, network_id, instance_id):
             fixed_ip_ref.network = network_get(context,
                                            network_id,
                                            session=session)
-        fixed_ip_ref.instance = instance_get(context,
-                                             instance_id,
-                                             session=session)
+        if instance_id:
+            fixed_ip_ref.instance = instance_get(context,
+                                                 instance_id,
+                                                 session=session)
+        if host:
+            fixed_ip_ref.host = host
         session.add(fixed_ip_ref)
     return fixed_ip_ref['address']
 
@@ -735,7 +752,7 @@ def fixed_ip_get_all(context, session=None):
 
 
 @require_admin_context
-def fixed_ip_get_all_by_host(context, host=None):
+def fixed_ip_get_all_by_instance_host(context, host=None):
     session = get_session()
 
     result = session.query(models.FixedIp).\
@@ -785,6 +802,20 @@ def fixed_ip_get_by_instance(context, instance_id):
 
 
 @require_context
+def fixed_ip_get_by_network_host(context, network_id, host):
+    session = get_session()
+    rv = session.query(models.FixedIp).\
+                 filter_by(network_id=network_id).\
+                 filter_by(host=host).\
+                 filter_by(deleted=False).\
+                 first()
+    if not rv:
+        raise exception.FixedIpNotFoundForNetworkHost(network_id=network_id,
+                                                      host=host)
+    return rv
+
+
+@require_context
 def fixed_ip_get_by_virtual_interface(context, vif_id):
     session = get_session()
     rv = session.query(models.FixedIp).\
@@ -921,6 +952,7 @@ def virtual_interface_get_by_fixed_ip(context, fixed_ip_id):
 
 
 @require_context
+@require_instance_exists
 def virtual_interface_get_by_instance(context, instance_id):
     """Gets all virtual interfaces for instance.
 
@@ -1317,7 +1349,11 @@ def instance_update(context, instance_id, values):
         instance_metadata_update_or_create(context, instance_id,
                                            values.pop('metadata'))
     with session.begin():
-        instance_ref = instance_get(context, instance_id, session=session)
+        if utils.is_uuid_like(instance_id):
+            instance_ref = instance_get_by_uuid(context, instance_id,
+                                                session=session)
+        else:
+            instance_ref = instance_get(context, instance_id, session=session)
         instance_ref.update(values)
         instance_ref.save(session=session)
         return instance_ref
@@ -1464,8 +1500,6 @@ def network_associate(context, project_id, force=False):
     called by project_get_networks under certain conditions
     and network manager add_network_to_project()
 
-    only associates projects with networks that have configured hosts
-
     only associate if the project doesn't already have a network
     or if force is True
 
@@ -1481,7 +1515,6 @@ def network_associate(context, project_id, force=False):
         def network_query(project_filter):
             return session.query(models.Network).\
                            filter_by(deleted=False).\
-                           filter(models.Network.host != None).\
                            filter_by(project_id=project_filter).\
                            with_lockmode('update').\
                            first()
@@ -1688,9 +1721,16 @@ def network_get_all_by_instance(_context, instance_id):
 def network_get_all_by_host(context, host):
     session = get_session()
     with session.begin():
+        # NOTE(vish): return networks that have host set
+        #             or that have a fixed ip with host set
+        host_filter = or_(models.Network.host == host,
+                          models.FixedIp.host == host)
+
         return session.query(models.Network).\
                        filter_by(deleted=False).\
-                       filter_by(host=host).\
+                       join(models.Network.fixed_ips).\
+                       filter(host_filter).\
+                       filter_by(deleted=False).\
                        all()
 
 
@@ -1722,6 +1762,7 @@ def network_update(context, network_id, values):
         network_ref = network_get(context, network_id, session=session)
         network_ref.update(values)
         network_ref.save(session=session)
+        return network_ref
 
 
 ###################
@@ -2208,6 +2249,23 @@ def block_device_mapping_update(context, bdm_id, values):
 
 
 @require_context
+def block_device_mapping_update_or_create(context, values):
+    session = get_session()
+    with session.begin():
+        result = session.query(models.BlockDeviceMapping).\
+                 filter_by(instance_id=values['instance_id']).\
+                 filter_by(device_name=values['device_name']).\
+                 filter_by(deleted=False).\
+                 first()
+        if not result:
+            bdm_ref = models.BlockDeviceMapping()
+            bdm_ref.update(values)
+            bdm_ref.save(session=session)
+        else:
+            result.update(values)
+
+
+@require_context
 def block_device_mapping_get_all_by_instance(context, instance_id):
     session = get_session()
     result = session.query(models.BlockDeviceMapping).\
@@ -2765,13 +2823,13 @@ def migration_get(context, id, session=None):
 
 
 @require_admin_context
-def migration_get_by_instance_and_status(context, instance_id, status):
+def migration_get_by_instance_and_status(context, instance_uuid, status):
     session = get_session()
     result = session.query(models.Migration).\
-                     filter_by(instance_id=instance_id).\
+                     filter_by(instance_uuid=instance_uuid).\
                      filter_by(status=status).first()
     if not result:
-        raise exception.MigrationNotFoundByStatus(instance_id=instance_id,
+        raise exception.MigrationNotFoundByStatus(instance_id=instance_uuid,
                                                   status=status)
     return result
 
@@ -2952,7 +3010,7 @@ def instance_type_get_all(context, inactive=False):
 
 
 @require_context
-def instance_type_get_by_id(context, id):
+def instance_type_get(context, id):
     """Returns a dict describing specific instance_type"""
     session = get_session()
     inst_type = session.query(models.InstanceTypes).\
@@ -3071,14 +3129,6 @@ def zone_get_all(context):
 ####################
 
 
-def require_instance_exists(func):
-    def new_func(context, instance_id, *args, **kwargs):
-        db.api.instance_get(context, instance_id)
-        return func(context, instance_id, *args, **kwargs)
-    new_func.__name__ = func.__name__
-    return new_func
-
-
 @require_context
 @require_instance_exists
 def instance_metadata_get(context, instance_id):
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/032_add_root_device_name.py b/nova/db/sqlalchemy/migrate_repo/versions/032_add_root_device_name.py
new file mode 100644
index 000000000..6b98b9890
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/032_add_root_device_name.py
@@ -0,0 +1,47 @@
+# Copyright 2011 OpenStack LLC.
+# Copyright 2011 Isaku Yamahata
+#
+#    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 sqlalchemy import Column, Integer, MetaData, Table, String
+
+meta = MetaData()
+
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# New Column
+#
+root_device_name = Column(
+    'root_device_name',
+    String(length=255, convert_unicode=False, assert_unicode=None,
+           unicode_error=None, _warn_on_bytestring=False),
+    nullable=True)
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    instances.create_column(root_device_name)
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    meta.bind = migrate_engine
+    instances.drop_column('root_device_name')
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/033_ha_network.py b/nova/db/sqlalchemy/migrate_repo/versions/033_ha_network.py
new file mode 100644
index 000000000..3a5f7eba8
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/033_ha_network.py
@@ -0,0 +1,44 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 OpenStack, LLC.
+# 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 sqlalchemy import Column, Table, MetaData, Boolean, String
+
+meta = MetaData()
+
+fixed_ips_host = Column('host', String(255))
+
+networks_multi_host = Column('multi_host', Boolean, default=False)
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    fixed_ips = Table('fixed_ips', meta, autoload=True)
+    fixed_ips.create_column(fixed_ips_host)
+
+    networks = Table('networks', meta, autoload=True)
+    networks.create_column(networks_multi_host)
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    fixed_ips = Table('fixed_ips', meta, autoload=True)
+    fixed_ips.drop_column(fixed_ips_host)
+
+    networks = Table('networks', meta, autoload=True)
+    networks.drop_column(networks_multi_host)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/034_change_instance_id_in_migrations.py b/nova/db/sqlalchemy/migrate_repo/versions/034_change_instance_id_in_migrations.py
new file mode 100644
index 000000000..b002ba064
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/034_change_instance_id_in_migrations.py
@@ -0,0 +1,43 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# 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 sqlalchemy import *
+
+from sqlalchemy import Column, Integer, String, MetaData, Table
+
+meta = MetaData()
+
+
+#
+# Tables to alter
+#
+#
+
+instance_id = Column('instance_id', Integer())
+instance_uuid = Column('instance_uuid', String(255))
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+    migrations = Table('migrations', meta, autoload=True)
+    migrations.create_column(instance_uuid)
+    migrations.c.instance_id.drop()
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+    migrations = Table('migrations', meta, autoload=True)
+    migrations.c.instance_uuid.drop()
+    migrations.create_column(instance_id)
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index d29d3d6f1..c1150f7ca 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -31,6 +31,7 @@ from nova.db.sqlalchemy.session import get_session
 from nova import auth
 from nova import exception
 from nova import flags
+from nova import ipv6
 from nova import utils
 
 
@@ -236,6 +237,8 @@ class Instance(BASE, NovaBase):
     vm_mode = Column(String(255))
     uuid = Column(String(36))
 
+    root_device_name = Column(String(255))
+
     # TODO(vish): see Ewan's email about state improvements, probably
     #             should be in a driver base class or some such
     # vmstate_state = running, halted, suspended, paused
@@ -526,7 +529,8 @@ class Migration(BASE, NovaBase):
     dest_host = Column(String(255))
     old_flavor_id = Column(Integer())
     new_flavor_id = Column(Integer())
-    instance_id = Column(Integer, ForeignKey('instances.id'), nullable=True)
+    instance_uuid = Column(String(255), ForeignKey('instances.uuid'),
+            nullable=True)
     #TODO(_cerberus_): enum
     status = Column(String(255))
 
@@ -543,6 +547,7 @@ class Network(BASE, NovaBase):
     injected = Column(Boolean, default=False)
     cidr = Column(String(255), unique=True)
     cidr_v6 = Column(String(255), unique=True)
+    multi_host = Column(Boolean, default=False)
 
     gateway_v6 = Column(String(255))
     netmask_v6 = Column(String(255))
@@ -575,6 +580,18 @@ class VirtualInterface(BASE, NovaBase):
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=False)
     instance = relationship(Instance, backref=backref('virtual_interfaces'))
 
+    @property
+    def fixed_ipv6(self):
+        cidr_v6 = self.network.cidr_v6
+        if cidr_v6 is None:
+            ipv6_address = None
+        else:
+            project_id = self.instance.project_id
+            mac = self.address
+            ipv6_address = ipv6.to_global(cidr_v6, mac, project_id)
+
+        return ipv6_address
+
 
 # TODO(vish): can these both come from the same baseclass?
 class FixedIp(BASE, NovaBase):
@@ -601,6 +618,7 @@ class FixedIp(BASE, NovaBase):
     # leased means dhcp bridge has leased the ip
     leased = Column(Boolean, default=False)
     reserved = Column(Boolean, default=False)
+    host = Column(String(255))
 
 
 class FloatingIp(BASE, NovaBase):
diff --git a/nova/exception.py b/nova/exception.py
index ad6c005f8..38e705417 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -78,8 +78,8 @@ def wrap_db_error(f):
         except Exception, e:
             LOG.exception(_('DB exception wrapped.'))
             raise DBError(e)
-    return _wrap
     _wrap.func_name = f.func_name
+    return _wrap
 
 
 def wrap_exception(notifier=None, publisher_id=None, event_type=None,
@@ -408,6 +408,11 @@ class FixedIpNotFoundForInstance(FixedIpNotFound):
     message = _("Instance %(instance_id)s has zero fixed ips.")
 
 
+class FixedIpNotFoundForNetworkHost(FixedIpNotFound):
+    message = _("Network host %(host)s has zero fixed ips "
+                "in network %(network_id)s.")
+
+
 class FixedIpNotFoundForSpecificInstance(FixedIpNotFound):
     message = _("Instance %(instance_id)s doesn't have fixed ip '%(ip)s'.")
 
diff --git a/nova/image/fake.py b/nova/image/fake.py
index c4b3d5fd6..28e912534 100644
--- a/nova/image/fake.py
+++ b/nova/image/fake.py
@@ -137,7 +137,11 @@ class _FakeImageService(service.BaseImageService):
         try:
             image_id = metadata['id']
         except KeyError:
-            image_id = random.randint(0, 2 ** 31 - 1)
+            while True:
+                image_id = random.randint(0, 2 ** 31 - 1)
+                if not self.images.get(str(image_id)):
+                    break
+
         image_id = str(image_id)
 
         if self.images.get(image_id):
@@ -176,3 +180,8 @@ _fakeImageService = _FakeImageService()
 
 def FakeImageService():
     return _fakeImageService
+
+
+def FakeImageService_reset():
+    global _fakeImageService
+    _fakeImageService = _FakeImageService()
diff --git a/nova/image/glance.py b/nova/image/glance.py
index 55d948a32..5c2dc957b 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -89,6 +89,10 @@ class GlanceImageService(service.BaseImageService):
         # `get_images` here because we need `is_public` and `properties`
         # included so we can filter by user
         filtered = []
+        filters = filters or {}
+        if 'is_public' not in filters:
+            # NOTE(vish): don't filter out private images
+            filters['is_public'] = 'none'
         image_metas = self.client.get_images_detailed(filters=filters,
                                                       marker=marker,
                                                       limit=limit)
@@ -101,6 +105,10 @@ class GlanceImageService(service.BaseImageService):
     def detail(self, context, filters=None, marker=None, limit=None):
         """Calls out to Glance for a list of detailed image information."""
         filtered = []
+        filters = filters or {}
+        if 'is_public' not in filters:
+            # NOTE(vish): don't filter out private images
+            filters['is_public'] = 'none'
         image_metas = self.client.get_images_detailed(filters=filters,
                                                       marker=marker,
                                                       limit=limit)
diff --git a/nova/image/s3.py b/nova/image/s3.py
index 9e95bd698..c313c7a13 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -102,18 +102,7 @@ class S3ImageService(service.BaseImageService):
         key.get_contents_to_filename(local_filename)
         return local_filename
 
-    def _s3_create(self, context, metadata):
-        """Gets a manifext from s3 and makes an image."""
-
-        image_path = tempfile.mkdtemp(dir=FLAGS.image_decryption_dir)
-
-        image_location = metadata['properties']['image_location']
-        bucket_name = image_location.split('/')[0]
-        manifest_path = image_location[len(bucket_name) + 1:]
-        bucket = self._conn(context).get_bucket(bucket_name)
-        key = bucket.get_key(manifest_path)
-        manifest = key.get_contents_as_string()
-
+    def _s3_parse_manifest(self, context, metadata, manifest):
         manifest = ElementTree.fromstring(manifest)
         image_format = 'ami'
         image_type = 'machine'
@@ -141,6 +130,28 @@ class S3ImageService(service.BaseImageService):
         except Exception:
             arch = 'x86_64'
 
+        # NOTE(yamahata):
+        # EC2 ec2-budlne-image --block-device-mapping accepts
+        # <virtual name>=<device name> where
+        # virtual name = {ami, root, swap, ephemeral<N>}
+        #                where N is no negative integer
+        # device name = the device name seen by guest kernel.
+        # They are converted into
+        # block_device_mapping/mapping/{virtual, device}
+        #
+        # Do NOT confuse this with ec2-register's block device mapping
+        # argument.
+        mappings = []
+        try:
+            block_device_mapping = manifest.findall('machine_configuration/'
+                                                    'block_device_mapping/'
+                                                    'mapping')
+            for bdm in block_device_mapping:
+                mappings.append({'virtual': bdm.find('virtual').text,
+                                 'device': bdm.find('device').text})
+        except Exception:
+            mappings = []
+
         properties = metadata['properties']
         properties['project_id'] = context.project_id
         properties['architecture'] = arch
@@ -151,13 +162,31 @@ class S3ImageService(service.BaseImageService):
         if ramdisk_id:
             properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)
 
+        if mappings:
+            properties['mappings'] = mappings
+
         metadata.update({'disk_format': image_format,
                          'container_format': image_format,
                          'status': 'queued',
-                         'is_public': True,
+                         'is_public': False,
                          'properties': properties})
         metadata['properties']['image_state'] = 'pending'
         image = self.service.create(context, metadata)
+        return manifest, image
+
+    def _s3_create(self, context, metadata):
+        """Gets a manifext from s3 and makes an image."""
+
+        image_path = tempfile.mkdtemp(dir=FLAGS.image_decryption_dir)
+
+        image_location = metadata['properties']['image_location']
+        bucket_name = image_location.split('/')[0]
+        manifest_path = image_location[len(bucket_name) + 1:]
+        bucket = self._conn(context).get_bucket(bucket_name)
+        key = bucket.get_key(manifest_path)
+        manifest = key.get_contents_as_string()
+
+        manifest, image = self._s3_parse_manifest(context, metadata, manifest)
         image_id = image['id']
 
         def delayed_create():
diff --git a/nova/network/api.py b/nova/network/api.py
index 70b1099f0..c2360f0d0 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -18,7 +18,6 @@
 
 """Handles all requests relating to instances (guest vms)."""
 
-from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
@@ -61,6 +60,9 @@ class API(base.Base):
                             affect_auto_assigned=False):
         """Removes floating ip with address from a project."""
         floating_ip = self.db.floating_ip_get_by_address(context, address)
+        if floating_ip['fixed_ip']:
+            raise exception.ApiError(_('Floating ip is in use.  '
+                             'Disassociate it before releasing.'))
         if not affect_auto_assigned and floating_ip.get('auto_assigned'):
             return
         # NOTE(vish): We don't know which network host should get the ip
@@ -105,7 +107,11 @@ class API(base.Base):
                                        '(%(project)s)') %
                                         {'address': floating_ip['address'],
                                         'project': context.project_id})
-        host = fixed_ip['network']['host']
+        # NOTE(vish): if we are multi_host, send to the instances host
+        if fixed_ip['network']['multi_host']:
+            host = fixed_ip['instance']['host']
+        else:
+            host = fixed_ip['network']['host']
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.network_topic, host),
                  {'method': 'associate_floating_ip',
@@ -120,7 +126,11 @@ class API(base.Base):
             return
         if not floating_ip.get('fixed_ip'):
             raise exception.ApiError('Address is not associated.')
-        host = floating_ip['fixed_ip']['network']['host']
+        # NOTE(vish): if we are multi_host, send to the instances host
+        if floating_ip['fixed_ip']['network']['multi_host']:
+            host = floating_ip['fixed_ip']['instance']['host']
+        else:
+            host = floating_ip['fixed_ip']['network']['host']
         rpc.call(context,
                  self.db.queue_get_for(context, FLAGS.network_topic, host),
                  {'method': 'disassociate_floating_ip',
@@ -134,7 +144,9 @@ class API(base.Base):
         args = kwargs
         args['instance_id'] = instance['id']
         args['project_id'] = instance['project_id']
+        args['host'] = instance['host']
         args['instance_type_id'] = instance['instance_type_id']
+
         return rpc.call(context, FLAGS.network_topic,
                         {'method': 'allocate_for_instance',
                          'args': args})
@@ -173,7 +185,8 @@ class API(base.Base):
     def get_instance_nw_info(self, context, instance):
         """Returns all network info related to an instance."""
         args = {'instance_id': instance['id'],
-                'instance_type_id': instance['instance_type_id']}
+                'instance_type_id': instance['instance_type_id'],
+                'host': instance['host']}
         return rpc.call(context, FLAGS.network_topic,
                         {'method': 'get_instance_nw_info',
                          'args': args})
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 283a5aca1..a8ce1c16a 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -497,7 +497,7 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         suffix = net_attrs['cidr'].rpartition('/')[2]
         out, err = _execute('sudo', 'ip', 'addr', 'add',
                             '%s/%s' %
-                            (net_attrs['gateway'], suffix),
+                            (net_attrs['dhcp_server'], suffix),
                             'brd',
                             net_attrs['broadcast'],
                             'dev',
@@ -551,21 +551,27 @@ def ensure_bridge(bridge, interface, net_attrs=None):
                                              bridge)
 
 
-def get_dhcp_leases(context, network_id):
+def get_dhcp_leases(context, network_ref):
     """Return a network's hosts config in dnsmasq leasefile format."""
     hosts = []
-    for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
-                                                            network_id):
-        hosts.append(_host_lease(fixed_ip_ref))
+    for fixed_ref in db.network_get_associated_fixed_ips(context,
+                                                         network_ref['id']):
+        host = fixed_ref['instance']['host']
+        if network_ref['multi_host'] and FLAGS.host != host:
+            continue
+        hosts.append(_host_lease(fixed_ref))
     return '\n'.join(hosts)
 
 
-def get_dhcp_hosts(context, network_id):
+def get_dhcp_hosts(context, network_ref):
     """Get network's hosts config in dhcp-host format."""
     hosts = []
-    for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
-                                                            network_id):
-        hosts.append(_host_dhcp(fixed_ip_ref))
+    for fixed_ref in db.network_get_associated_fixed_ips(context,
+                                                         network_ref['id']):
+        host = fixed_ref['instance']['host']
+        if network_ref['multi_host'] and FLAGS.host != host:
+            continue
+        hosts.append(_host_dhcp(fixed_ref))
     return '\n'.join(hosts)
 
 
@@ -573,18 +579,16 @@ def get_dhcp_hosts(context, network_id):
 #           configuration options (like dchp-range, vlan, ...)
 #           aren't reloaded.
 @utils.synchronized('dnsmasq_start')
-def update_dhcp(context, network_id):
+def update_dhcp(context, network_ref):
     """(Re)starts a dnsmasq server for a given network.
 
     If a dnsmasq instance is already running then send a HUP
     signal causing it to reload, otherwise spawn a new instance.
 
     """
-    network_ref = db.network_get(context, network_id)
-
     conffile = _dhcp_file(network_ref['bridge'], 'conf')
     with open(conffile, 'w') as f:
-        f.write(get_dhcp_hosts(context, network_id))
+        f.write(get_dhcp_hosts(context, network_ref))
 
     # Make sure dnsmasq can actually read it (it setuid()s to "nobody")
     os.chmod(conffile, 0644)
@@ -612,9 +616,7 @@ def update_dhcp(context, network_id):
 
 
 @utils.synchronized('radvd_start')
-def update_ra(context, network_id):
-    network_ref = db.network_get(context, network_id)
-
+def update_ra(context, network_ref):
     conffile = _ra_file(network_ref['bridge'], 'conf')
     with open(conffile, 'w') as f:
         conf_str = """
@@ -650,9 +652,6 @@ interface %s
             LOG.debug(_('Pid %d is stale, relaunching radvd'), pid)
     command = _ra_cmd(network_ref)
     _execute(*command)
-    db.network_update(context, network_id,
-                      {'gateway_v6':
-                       utils.get_my_linklocal(network_ref['bridge'])})
 
 
 def _host_lease(fixed_ip_ref):
@@ -701,10 +700,11 @@ def _dnsmasq_cmd(net):
     cmd = ['sudo', '-E', 'dnsmasq',
            '--strict-order',
            '--bind-interfaces',
+           '--interface=%s' % net['bridge'],
            '--conf-file=%s' % FLAGS.dnsmasq_config_file,
            '--domain=%s' % FLAGS.dhcp_domain,
            '--pid-file=%s' % _dhcp_file(net['bridge'], 'pid'),
-           '--listen-address=%s' % net['gateway'],
+           '--listen-address=%s' % net['dhcp_server'],
            '--except-interface=lo',
            '--dhcp-range=%s,static,120s' % net['dhcp_start'],
            '--dhcp-lease-max=%s' % len(netaddr.IPNetwork(net['cidr'])),
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 24736f53d..75c3f668d 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -28,7 +28,6 @@ topologies.  All of the network commands are issued to a subclass of
 :flat_network_bridge:  Bridge device for simple network instances
 :flat_interface:  FlatDhcp will bridge into this interface if set
 :flat_network_dns:  Dns for simple network
-:flat_network_dhcp_start:  Dhcp start for FlatDhcp
 :vlan_start:  First VLAN for private networks
 :vpn_ip:  Public IP for the cloudpipe VPN servers
 :vpn_start:  First Vpn port for private networks
@@ -49,7 +48,6 @@ import datetime
 import math
 import netaddr
 import socket
-import pickle
 from eventlet import greenpool
 
 from nova import context
@@ -78,8 +76,6 @@ flags.DEFINE_bool('flat_injected', True,
                   'Whether to attempt to inject network setup into guest')
 flags.DEFINE_string('flat_interface', None,
                     'FlatDhcp will bridge into this interface if set')
-flags.DEFINE_string('flat_network_dhcp_start', '10.0.0.2',
-                    'Dhcp start for FlatDhcp')
 flags.DEFINE_integer('vlan_start', 100, 'First VLAN for private networks')
 flags.DEFINE_string('vlan_interface', None,
                     'vlans will bridge into this interface if set')
@@ -87,6 +83,8 @@ flags.DEFINE_integer('num_networks', 1, 'Number of networks to support')
 flags.DEFINE_string('vpn_ip', '$my_ip',
                     'Public IP for the cloudpipe VPN servers')
 flags.DEFINE_integer('vpn_start', 1000, 'First Vpn port for private networks')
+flags.DEFINE_bool('multi_host', False,
+                  'Default value for multi_host in networks')
 flags.DEFINE_integer('network_size', 256,
                         'Number of addresses in each private subnet')
 flags.DEFINE_string('floating_range', '4.4.4.0/24',
@@ -104,7 +102,8 @@ flags.DEFINE_integer('fixed_ip_disassociate_timeout', 600,
                      'Seconds after which a deallocated ip is disassociated')
 flags.DEFINE_integer('create_unique_mac_address_attempts', 5,
                      'Number of attempts to create unique mac address')
-
+flags.DEFINE_bool('auto_assign_floating_ip', False,
+                  'Autoassigning floating ip to VM')
 flags.DEFINE_bool('use_ipv6', False,
                   'use the ipv6')
 flags.DEFINE_string('network_host', socket.gethostname(),
@@ -124,16 +123,26 @@ class RPCAllocateFixedIP(object):
     used since they share code to RPC.call allocate_fixed_ip on the
     correct network host to configure dnsmasq
     """
-    def _allocate_fixed_ips(self, context, instance_id, networks, **kwargs):
+    def _allocate_fixed_ips(self, context, instance_id, host, networks,
+                            **kwargs):
         """Calls allocate_fixed_ip once for each network."""
         green_pool = greenpool.GreenPool()
 
         vpn = kwargs.pop('vpn')
         for network in networks:
-            if network['host'] != self.host:
+            # NOTE(vish): if we are not multi_host pass to the network host
+            if not network['multi_host']:
+                host = network['host']
+            # NOTE(vish): if there is no network host, set one
+            if host == None:
+                host = rpc.call(context, FLAGS.network_topic,
+                                {'method': 'set_network_host',
+                                 'args': {'network_ref': network}})
+            if host != self.host:
                 # need to call allocate_fixed_ip to correct network host
-                topic = self.db.queue_get_for(context, FLAGS.network_topic,
-                                                           network['host'])
+                topic = self.db.queue_get_for(context,
+                                              FLAGS.network_topic,
+                                              host)
                 args = {}
                 args['instance_id'] = instance_id
                 args['network_id'] = network['id']
@@ -149,12 +158,13 @@ class RPCAllocateFixedIP(object):
         # wait for all of the allocates (if any) to finish
         green_pool.waitall()
 
-    def _rpc_allocate_fixed_ip(self, context, instance_id, network_id):
+    def _rpc_allocate_fixed_ip(self, context, instance_id, network_id,
+                               **kwargs):
         """Sits in between _allocate_fixed_ips and allocate_fixed_ip to
         perform network lookup on the far side of rpc.
         """
         network = self.db.network_get(context, network_id)
-        self.allocate_fixed_ip(context, instance_id, network)
+        self.allocate_fixed_ip(context, instance_id, network, **kwargs)
 
 
 class FloatingIP(object):
@@ -193,7 +203,7 @@ class FloatingIP(object):
         # which is currently the NetworkManager version
         # do this first so fixed ip is already allocated
         ips = super(FloatingIP, self).allocate_for_instance(context, **kwargs)
-        if hasattr(FLAGS, 'auto_assign_floating_ip'):
+        if FLAGS.auto_assign_floating_ip:
             # allocate a floating ip (public_ip is just the address string)
             public_ip = self.allocate_floating_ip(context, project_id)
             # set auto_assigned column to true for the floating ip
@@ -300,15 +310,36 @@ class NetworkManager(manager.SchedulerDependentManager):
         super(NetworkManager, self).__init__(service_name='network',
                                                 *args, **kwargs)
 
+    @utils.synchronized('get_dhcp')
+    def _get_dhcp_ip(self, context, network_ref, host=None):
+        """Get the proper dhcp address to listen on."""
+        # NOTE(vish): this is for compatibility
+        if not network_ref['multi_host']:
+            return network_ref['gateway']
+
+        if not host:
+            host = self.host
+        network_id = network_ref['id']
+        try:
+            fip = self.db.fixed_ip_get_by_network_host(context,
+                                                       network_id,
+                                                       host)
+            return fip['address']
+        except exception.FixedIpNotFoundForNetworkHost:
+            elevated = context.elevated()
+            return self.db.fixed_ip_associate_pool(elevated,
+                                                   network_id,
+                                                   host=host)
+
     def init_host(self):
         """Do any initialization that needs to be run if this is a
         standalone service.
         """
-        # Set up this host for networks in which it's already
-        # the designated network host.
+        # NOTE(vish): Set up networks for which this host already has
+        #             an ip address.
         ctxt = context.get_admin_context()
         for network in self.db.network_get_all_by_host(ctxt, self.host):
-            self._on_set_network_host(ctxt, network['id'])
+            self._setup_network(ctxt, network)
 
     def periodic_tasks(self, context=None):
         """Tasks to be run at a periodic interval."""
@@ -323,33 +354,14 @@ class NetworkManager(manager.SchedulerDependentManager):
             if num:
                 LOG.debug(_('Dissassociated %s stale fixed ip(s)'), num)
 
-        # setup any new networks which have been created
-        self.set_network_hosts(context)
-
-    def set_network_host(self, context, network_id):
+    def set_network_host(self, context, network_ref):
         """Safely sets the host of the network."""
         LOG.debug(_('setting network host'), context=context)
         host = self.db.network_set_host(context,
-                                        network_id,
+                                        network_ref['id'],
                                         self.host)
-        if host == self.host:
-            self._on_set_network_host(context, network_id)
         return host
 
-    def set_network_hosts(self, context):
-        """Set the network hosts for any networks which are unset."""
-        try:
-            networks = self.db.network_get_all(context)
-        except exception.NoNetworksFound:
-            # we don't care if no networks are found
-            pass
-
-        for network in networks:
-            host = network['host']
-            if not host:
-                # return so worker will only grab 1 (to help scale flatter)
-                return self.set_network_host(context, network['id'])
-
     def _get_networks_for_instance(self, context, instance_id, project_id):
         """Determine & return which networks an instance should connect to."""
         # TODO(tr3buchet) maybe this needs to be updated in the future if
@@ -361,9 +373,9 @@ class NetworkManager(manager.SchedulerDependentManager):
             # we don't care if no networks are found
             pass
 
-        # return only networks which are not vlan networks and have host set
+        # return only networks which are not vlan networks
         return [network for network in networks if
-                not network['vlan'] and network['host']]
+                not network['vlan']]
 
     def allocate_for_instance(self, context, **kwargs):
         """Handles allocating the various network resources for an instance.
@@ -371,6 +383,7 @@ class NetworkManager(manager.SchedulerDependentManager):
         rpc.called by network_api
         """
         instance_id = kwargs.pop('instance_id')
+        host = kwargs.pop('host')
         project_id = kwargs.pop('project_id')
         type_id = kwargs.pop('instance_type_id')
         vpn = kwargs.pop('vpn')
@@ -379,9 +392,11 @@ class NetworkManager(manager.SchedulerDependentManager):
                                                             context=context)
         networks = self._get_networks_for_instance(admin_context, instance_id,
                                                                   project_id)
+        LOG.warn(networks)
         self._allocate_mac_addresses(context, instance_id, networks)
-        self._allocate_fixed_ips(admin_context, instance_id, networks, vpn=vpn)
-        return self.get_instance_nw_info(context, instance_id, type_id)
+        self._allocate_fixed_ips(admin_context, instance_id, host, networks,
+                                 vpn=vpn)
+        return self.get_instance_nw_info(context, instance_id, type_id, host)
 
     def deallocate_for_instance(self, context, **kwargs):
         """Handles deallocating various network resources for an instance.
@@ -401,7 +416,8 @@ class NetworkManager(manager.SchedulerDependentManager):
         # deallocate vifs (mac addresses)
         self.db.virtual_interface_delete_by_instance(context, instance_id)
 
-    def get_instance_nw_info(self, context, instance_id, instance_type_id):
+    def get_instance_nw_info(self, context, instance_id,
+                             instance_type_id, host):
         """Creates network info list for instance.
 
         called by allocate_for_instance and netowrk_api
@@ -413,8 +429,7 @@ class NetworkManager(manager.SchedulerDependentManager):
         # TODO(tr3buchet) should handle floating IPs as well?
         fixed_ips = self.db.fixed_ip_get_by_instance(context, instance_id)
         vifs = self.db.virtual_interface_get_by_instance(context, instance_id)
-        flavor = self.db.instance_type_get_by_id(context,
-                                                 instance_type_id)
+        flavor = self.db.instance_type_get(context, instance_type_id)
         network_info = []
         # a vif has an address, instance_id, and network_id
         # it is also joined to the instance and network given by those IDs
@@ -445,9 +460,16 @@ class NetworkManager(manager.SchedulerDependentManager):
                 'cidr': network['cidr'],
                 'cidr_v6': network['cidr_v6'],
                 'injected': network['injected']}
+            if network['multi_host']:
+                dhcp_server = self._get_dhcp_ip(context, network, host)
+            else:
+                dhcp_server = self._get_dhcp_ip(context,
+                                                network,
+                                                network['host'])
             info = {
                 'label': network['label'],
                 'gateway': network['gateway'],
+                'dhcp_server': dhcp_server,
                 'broadcast': network['broadcast'],
                 'mac': vif['address'],
                 'rxtx_cap': flavor['rxtx_cap'],
@@ -487,10 +509,10 @@ class NetworkManager(manager.SchedulerDependentManager):
                random.randint(0x00, 0xff)]
         return ':'.join(map(lambda x: "%02x" % x, mac))
 
-    def add_fixed_ip_to_instance(self, context, instance_id, network_id):
+    def add_fixed_ip_to_instance(self, context, instance_id, host, network_id):
         """Adds a fixed ip to an instance from specified network."""
         networks = [self.db.network_get(context, network_id)]
-        self._allocate_fixed_ips(context, instance_id, networks)
+        self._allocate_fixed_ips(context, instance_id, host, networks)
 
     def remove_fixed_ip_from_instance(self, context, instance_id, address):
         """Removes a fixed ip from an instance from specified network."""
@@ -517,6 +539,7 @@ class NetworkManager(manager.SchedulerDependentManager):
         values = {'allocated': True,
                   'virtual_interface_id': vif['id']}
         self.db.fixed_ip_update(context, address, values)
+        self._setup_network(context, network)
         return address
 
     def deallocate_fixed_ip(self, context, address, **kwargs):
@@ -562,10 +585,10 @@ class NetworkManager(manager.SchedulerDependentManager):
             #             means there will stale entries in the conf file
             #             the code below will update the file if necessary
             if FLAGS.update_dhcp_on_disassociate:
-                network = self.db.fixed_ip_get_network(context, address)
-                self.driver.update_dhcp(context, network['id'])
+                network_ref = self.db.fixed_ip_get_network(context, address)
+                self._setup_network(context, network_ref)
 
-    def create_networks(self, context, label, cidr, num_networks,
+    def create_networks(self, context, label, cidr, multi_host, num_networks,
                         network_size, cidr_v6, gateway_v6, bridge,
                         bridge_interface, **kwargs):
         """Create networks based on parameters."""
@@ -584,6 +607,7 @@ class NetworkManager(manager.SchedulerDependentManager):
             net['bridge_interface'] = bridge_interface
             net['dns'] = FLAGS.flat_network_dns
             net['cidr'] = cidr
+            net['multi_host'] = multi_host
             net['netmask'] = str(project_net.netmask)
             net['gateway'] = str(project_net[1])
             net['broadcast'] = str(project_net.broadcast)
@@ -659,12 +683,13 @@ class NetworkManager(manager.SchedulerDependentManager):
                                               'address': address,
                                               'reserved': reserved})
 
-    def _allocate_fixed_ips(self, context, instance_id, networks, **kwargs):
+    def _allocate_fixed_ips(self, context, instance_id, host, networks,
+                            **kwargs):
         """Calls allocate_fixed_ip once for each network."""
         raise NotImplementedError()
 
-    def _on_set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a network."""
+    def _setup_network(self, context, network_ref):
+        """Sets up network on this host."""
         raise NotImplementedError()
 
     def setup_compute_network(self, context, instance_id):
@@ -706,7 +731,8 @@ class FlatManager(NetworkManager):
 
     timeout_fixed_ips = False
 
-    def _allocate_fixed_ips(self, context, instance_id, networks, **kwargs):
+    def _allocate_fixed_ips(self, context, instance_id, host, networks,
+                            **kwargs):
         """Calls allocate_fixed_ip once for each network."""
         for network in networks:
             self.allocate_fixed_ip(context, instance_id, network)
@@ -724,12 +750,12 @@ class FlatManager(NetworkManager):
         """
         pass
 
-    def _on_set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a network."""
+    def _setup_network(self, context, network_ref):
+        """Setup Network on this host."""
         net = {}
         net['injected'] = FLAGS.flat_injected
         net['dns'] = FLAGS.flat_network_dns
-        self.db.network_update(context, network_id, net)
+        self.db.network_update(context, network_ref['id'], net)
 
 
 class FlatDHCPManager(FloatingIP, RPCAllocateFixedIP, NetworkManager):
@@ -760,30 +786,23 @@ class FlatDHCPManager(FloatingIP, RPCAllocateFixedIP, NetworkManager):
         """
         networks = db.network_get_all_by_instance(context, instance_id)
         for network in networks:
-            self.driver.ensure_bridge(network['bridge'],
-                                      network['bridge_interface'])
-
-    def allocate_fixed_ip(self, context, instance_id, network, **kwargs):
-        """Allocate flat_network fixed_ip, then setup dhcp for this network."""
-        address = super(FlatDHCPManager, self).allocate_fixed_ip(context,
-                                                                 instance_id,
-                                                                 network)
-        if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network['id'])
-
-    def _on_set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a project."""
-        net = {}
-        net['dhcp_start'] = FLAGS.flat_network_dhcp_start
-        self.db.network_update(context, network_id, net)
-        network = db.network_get(context, network_id)
-        self.driver.ensure_bridge(network['bridge'],
-                                  network['bridge_interface'],
-                                  network)
+            if not network['multi_host']:
+                self.driver.ensure_bridge(network['bridge'],
+                                          network['bridge_interface'])
+
+    def _setup_network(self, context, network_ref):
+        """Sets up network on this host."""
+        network_ref['dhcp_server'] = self._get_dhcp_ip(context, network_ref)
+        self.driver.ensure_bridge(network_ref['bridge'],
+                                  network_ref['bridge_interface'],
+                                  network_ref)
         if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network_id)
+            self.driver.update_dhcp(context, network_ref)
             if(FLAGS.use_ipv6):
-                self.driver.update_ra(context, network_id)
+                self.driver.update_ra(context, network_ref)
+                gateway = utils.get_my_linklocal(network_ref['bridge'])
+                self.db.network_update(context, network_ref['id'],
+                                       {'gateway_v6': gateway})
 
 
 class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
@@ -832,8 +851,8 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
         values = {'allocated': True,
                   'virtual_interface_id': vif['id']}
         self.db.fixed_ip_update(context, address, values)
-        if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network['id'])
+        self._setup_network(context, network)
+        return address
 
     def add_network_to_project(self, context, project_id):
         """Force adds another network to a project."""
@@ -845,17 +864,15 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
         """
         networks = self.db.network_get_all_by_instance(context, instance_id)
         for network in networks:
-            self.driver.ensure_vlan_bridge(network['vlan'],
-                                           network['bridge'],
-                                           network['bridge_interface'])
+            if not network['multi_host']:
+                self.driver.ensure_vlan_bridge(network['vlan'],
+                                               network['bridge'],
+                                               network['bridge_interface'])
 
     def _get_networks_for_instance(self, context, instance_id, project_id):
         """Determine which networks an instance should connect to."""
         # get networks associated with project
-        networks = self.db.project_get_networks(context, project_id)
-
-        # return only networks which have host set
-        return [network for network in networks if network['host']]
+        return self.db.project_get_networks(context, project_id)
 
     def create_networks(self, context, **kwargs):
         """Create networks based on parameters."""
@@ -874,32 +891,35 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
 
         NetworkManager.create_networks(self, context, vpn=True, **kwargs)
 
-    def _on_set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a network."""
-        network = self.db.network_get(context, network_id)
-        if not network['vpn_public_address']:
+    def _setup_network(self, context, network_ref):
+        """Sets up network on this host."""
+        network_ref['dhcp_server'] = self._get_dhcp_ip(context, network_ref)
+        if not network_ref['vpn_public_address']:
             net = {}
             address = FLAGS.vpn_ip
             net['vpn_public_address'] = address
-            db.network_update(context, network_id, net)
+            network_ref = db.network_update(context, network_ref['id'], net)
         else:
-            address = network['vpn_public_address']
-        self.driver.ensure_vlan_bridge(network['vlan'],
-                                       network['bridge'],
-                                       network['bridge_interface'],
-                                       network)
+            address = network_ref['vpn_public_address']
+        self.driver.ensure_vlan_bridge(network_ref['vlan'],
+                                       network_ref['bridge'],
+                                       network_ref['bridge_interface'],
+                                       network_ref)
 
         # NOTE(vish): only ensure this forward if the address hasn't been set
         #             manually.
         if address == FLAGS.vpn_ip and hasattr(self.driver,
                                                "ensure_vlan_forward"):
             self.driver.ensure_vlan_forward(FLAGS.vpn_ip,
-                                            network['vpn_public_port'],
-                                            network['vpn_private_address'])
+                                            network_ref['vpn_public_port'],
+                                            network_ref['vpn_private_address'])
         if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network_id)
+            self.driver.update_dhcp(context, network_ref)
             if(FLAGS.use_ipv6):
-                self.driver.update_ra(context, network_id)
+                self.driver.update_ra(context, network_ref)
+                gateway = utils.get_my_linklocal(network_ref['bridge'])
+                self.db.network_update(context, network_ref['id'],
+                                       {'gateway_v6': gateway})
 
     @property
     def _bottom_reserved_ips(self):
diff --git a/nova/test.py b/nova/test.py
index 6fb6b5a82..9790b0aa1 100644
--- a/nova/test.py
+++ b/nova/test.py
@@ -31,6 +31,7 @@ import unittest
 
 import mox
 import nose.plugins.skip
+import nova.image.fake
 import shutil
 import stubout
 from eventlet import greenthread
@@ -119,6 +120,9 @@ class TestCase(unittest.TestCase):
                 if hasattr(fake.FakeConnection, '_instance'):
                     del fake.FakeConnection._instance
 
+            if FLAGS.image_service == 'nova.image.fake.FakeImageService':
+                nova.image.fake.FakeImageService_reset()
+
             # Reset any overriden flags
             self.reset_flags()
 
@@ -248,3 +252,15 @@ class TestCase(unittest.TestCase):
         for d1, d2 in zip(L1, L2):
             self.assertDictMatch(d1, d2, approx_equal=approx_equal,
                                  tolerance=tolerance)
+
+    def assertSubDictMatch(self, sub_dict, super_dict):
+        """Assert a sub_dict is subset of super_dict."""
+        self.assertTrue(set(sub_dict.keys()).issubset(set(super_dict.keys())))
+        for k, sub_value in sub_dict.items():
+            super_value = super_dict[k]
+            if isinstance(sub_value, dict):
+                self.assertSubDictMatch(sub_value, super_value)
+            elif 'DONTCARE' in (sub_value, super_value):
+                continue
+            else:
+                self.assertEqual(sub_value, super_value)
diff --git a/nova/tests/__init__.py b/nova/tests/__init__.py
index e4ed75d37..7df6c06eb 100644
--- a/nova/tests/__init__.py
+++ b/nova/tests/__init__.py
@@ -59,6 +59,7 @@ def setup():
     network.create_networks(ctxt,
                             label='test',
                             cidr=FLAGS.fixed_range,
+                            multi_host=FLAGS.multi_host,
                             num_networks=FLAGS.num_networks,
                             network_size=FLAGS.network_size,
                             cidr_v6=FLAGS.fixed_range_v6,
@@ -68,7 +69,7 @@ def setup():
                             vpn_start=FLAGS.vpn_start,
                             vlan_start=FLAGS.vlan_start)
     for net in db.network_get_all(ctxt):
-        network.set_network_host(ctxt, net['id'])
+        network.set_network_host(ctxt, net)
 
     cleandb = os.path.join(FLAGS.state_path, FLAGS.sqlite_clean_db)
     shutil.copyfile(testdb, cleandb)
diff --git a/nova/tests/api/openstack/test_faults.py b/nova/tests/api/openstack/test_faults.py
index 4d86ffb26..927009e77 100644
--- a/nova/tests/api/openstack/test_faults.py
+++ b/nova/tests/api/openstack/test_faults.py
@@ -139,3 +139,8 @@ class TestFaults(test.TestCase):
         self.assertEqual(resp.content_type, "application/xml")
         self.assertEqual(resp.status_int, 404)
         self.assertTrue('whut?' in resp.body)
+
+    def test_fault_has_status_int(self):
+        """Ensure the status_int is set correctly on faults"""
+        fault = faults.Fault(webob.exc.HTTPBadRequest(explanation='what?'))
+        self.assertEqual(fault.status_int, 400)
diff --git a/nova/tests/api/openstack/test_flavors.py b/nova/tests/api/openstack/test_flavors.py
index 689647cc6..4ac35b26b 100644
--- a/nova/tests/api/openstack/test_flavors.py
+++ b/nova/tests/api/openstack/test_flavors.py
@@ -18,12 +18,14 @@
 import json
 import stubout
 import webob
+import xml.dom.minidom as minidom
 
+from nova.api.openstack import flavors
 import nova.db.api
-from nova import context
 from nova import exception
 from nova import test
 from nova.tests.api.openstack import fakes
+from nova import wsgi
 
 
 def stub_flavor(flavorid, name, memory_mb="256", local_gb="10"):
@@ -64,7 +66,6 @@ class FlavorsTest(test.TestCase):
                        return_instance_types)
         self.stubs.Set(nova.db.api, "instance_type_get_by_flavor_id",
                        return_instance_type_by_flavor_id)
-        self.context = context.get_admin_context()
 
     def tearDown(self):
         self.stubs.UnsetAll()
@@ -146,61 +147,65 @@ class FlavorsTest(test.TestCase):
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavor"]
+        flavor = json.loads(res.body)
         expected = {
-            "id": "12",
-            "name": "flavor 12",
-            "ram": "256",
-            "disk": "10",
-            "links": [
-                {
-                    "rel": "self",
-                    "href": "http://localhost/v1.1/flavors/12",
-                },
-                {
-                    "rel": "bookmark",
-                    "href": "http://localhost/flavors/12",
-                },
-            ],
-        }
-        self.assertEqual(flavor, expected)
-
-    def test_get_flavor_list_v1_1(self):
-        req = webob.Request.blank('/v1.1/flavors')
-        req.environ['api.version'] = '1.1'
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavors"]
-        expected = [
-            {
-                "id": "1",
-                "name": "flavor 1",
-                "links": [
-                    {
-                        "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/1",
-                    },
-                    {
-                        "rel": "bookmark",
-                        "href": "http://localhost/flavors/1",
-                    },
-                ],
-            },
-            {
-                "id": "2",
-                "name": "flavor 2",
+            "flavor": {
+                "id": "12",
+                "name": "flavor 12",
+                "ram": "256",
+                "disk": "10",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/2",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/2",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-        ]
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_flavor_list_v1_1(self):
+        req = webob.Request.blank('/v1.1/flavors')
+        req.environ['api.version'] = '1.1'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
         self.assertEqual(flavor, expected)
 
     def test_get_flavor_list_detail_v1_1(self):
@@ -208,52 +213,273 @@ class FlavorsTest(test.TestCase):
         req.environ['api.version'] = '1.1'
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 200)
-        flavor = json.loads(res.body)["flavors"]
-        expected = [
-            {
-                "id": "1",
-                "name": "flavor 1",
+        flavor = json.loads(res.body)
+        expected = {
+            "flavors": [
+                {
+                    "id": "1",
+                    "name": "flavor 1",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/1",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/1",
+                        },
+                    ],
+                },
+                {
+                    "id": "2",
+                    "name": "flavor 2",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/2",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/2",
+                        },
+                    ],
+                },
+            ],
+        }
+        self.assertEqual(flavor, expected)
+
+    def test_get_empty_flavor_list_v1_1(self):
+        def _return_empty(self):
+            return {}
+        self.stubs.Set(nova.db.api, "instance_type_get_all", _return_empty)
+
+        req = webob.Request.blank('/v1.1/flavors')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        flavors = json.loads(res.body)["flavors"]
+        expected = []
+        self.assertEqual(flavors, expected)
+
+
+class FlavorsXMLSerializationTest(test.TestCase):
+
+    def test_show(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavor": {
+                "id": "12",
+                "name": "asdf",
                 "ram": "256",
                 "disk": "10",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/1",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/1",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-            {
-                "id": "2",
-                "name": "flavor 2",
-                "ram": "256",
-                "disk": "10",
+        }
+
+        output = serializer.serialize(input, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                id="12"
+                name="asdf"
+                ram="256"
+                disk="10">
+            <atom:link href="http://localhost/v1.1/flavors/12" rel="self"/>
+            <atom:link href="http://localhost/flavors/12" rel="bookmark"/>
+        </flavor>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_show_handles_integers(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavor": {
+                "id": 12,
+                "name": "asdf",
+                "ram": 256,
+                "disk": 10,
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1/flavors/2",
+                        "href": "http://localhost/v1.1/flavors/12",
                     },
                     {
                         "rel": "bookmark",
-                        "href": "http://localhost/flavors/2",
+                        "href": "http://localhost/flavors/12",
                     },
                 ],
             },
-        ]
-        self.assertEqual(flavor, expected)
+        }
 
-    def test_get_empty_flavor_list_v1_1(self):
-        def _return_empty(self):
-            return {}
-        self.stubs.Set(nova.db.api, "instance_type_get_all",
-                       _return_empty)
+        output = serializer.serialize(input, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
 
-        req = webob.Request.blank('/v1.1/flavors')
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        flavors = json.loads(res.body)["flavors"]
-        expected = []
-        self.assertEqual(flavors, expected)
+        expected = minidom.parseString("""
+        <flavor xmlns="http://docs.openstack.org/compute/api/v1.1"
+                xmlns:atom="http://www.w3.org/2005/Atom"
+                id="12"
+                name="asdf"
+                ram="256"
+                disk="10">
+            <atom:link href="http://localhost/v1.1/flavors/12" rel="self"/>
+            <atom:link href="http://localhost/flavors/12" rel="bookmark"/>
+        </flavor>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_detail(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [
+                {
+                    "id": "23",
+                    "name": "flavor 23",
+                    "ram": "512",
+                    "disk": "20",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/23",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/23",
+                        },
+                    ],
+                },        {
+                    "id": "13",
+                    "name": "flavor 13",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/13",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/13",
+                        },
+                    ],
+                },
+            ],
+        }
+
+        output = serializer.serialize(input, 'detail')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom">
+            <flavor id="23"
+                    name="flavor 23"
+                    ram="512"
+                    disk="20">
+                <atom:link href="http://localhost/v1.1/flavors/23" rel="self"/>
+                <atom:link href="http://localhost/flavors/23" rel="bookmark"/>
+            </flavor>
+            <flavor id="13"
+                    name="flavor 13"
+                    ram="256"
+                    disk="10">
+                <atom:link href="http://localhost/v1.1/flavors/13" rel="self"/>
+                <atom:link href="http://localhost/flavors/13" rel="bookmark"/>
+            </flavor>
+        </flavors>
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [
+                {
+                    "id": "23",
+                    "name": "flavor 23",
+                    "ram": "512",
+                    "disk": "20",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/23",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/23",
+                        },
+                    ],
+                },        {
+                    "id": "13",
+                    "name": "flavor 13",
+                    "ram": "256",
+                    "disk": "10",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://localhost/v1.1/flavors/13",
+                        },
+                        {
+                            "rel": "bookmark",
+                            "href": "http://localhost/flavors/13",
+                        },
+                    ],
+                },
+            ],
+        }
+
+        output = serializer.serialize(input, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom">
+            <flavor id="23" name="flavor 23">
+                <atom:link href="http://localhost/v1.1/flavors/23" rel="self"/>
+                <atom:link href="http://localhost/flavors/23" rel="bookmark"/>
+            </flavor>
+            <flavor id="13" name="flavor 13">
+                <atom:link href="http://localhost/v1.1/flavors/13" rel="self"/>
+                <atom:link href="http://localhost/flavors/13" rel="bookmark"/>
+            </flavor>
+        </flavors>
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_empty(self):
+        serializer = flavors.FlavorXMLSerializer()
+
+        input = {
+            "flavors": [],
+        }
+
+        output = serializer.serialize(input, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <flavors xmlns="http://docs.openstack.org/compute/api/v1.1"
+                 xmlns:atom="http://www.w3.org/2005/Atom" />
+        """.replace("  ", "") % locals())
+
+        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index c1bdd6906..17f2fb755 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -568,10 +568,16 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
             test_image = {
                 "id": image["id"],
                 "name": image["name"],
-                "links": [{
-                    "rel": "self",
-                    "href": href,
-                }],
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": href,
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": bookmark,
+                    },
+                ],
             }
             self.assertTrue(test_image in response_list)
 
@@ -797,154 +803,206 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         self.assertDictListMatch(expected, response_list)
 
     def test_image_filter_with_name(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'name': 'testname'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?name=testname')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?name=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_with_status(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?status=ACTIVE')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?status=ACTIVE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_with_property(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'property-test': '3'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?property-test=3')
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?property-test=3')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_server(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        # 'server' should be converted to 'property-instance_ref'
+        filters = {'property-instance_ref': 'http://localhost:8774/servers/12'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?server='
+                                      'http://localhost:8774/servers/12')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_changes_since(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'changes-since': '2011-01-24T17:08Z'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?changes-since='
+                                      '2011-01-24T17:08Z')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_filter_with_type(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'property-image_type': 'BASE'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?type=BASE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_filter_not_supported(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.index(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images?status=ACTIVE&UNSUPPORTEDFILTER=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images?status=ACTIVE&'
+                                      'UNSUPPORTEDFILTER=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
-        controller.index(request)
-        mocker.VerifyAll()
+        controller.detail(request)
+        self.mox.VerifyAll()
 
     def test_image_no_filters(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {}
         image_service.index(
             context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
+        self.mox.ReplayAll()
         request = webob.Request.blank(
             '/v1.1/images')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.index(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_name(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'name': 'testname'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?name=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?name=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_status(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?status=ACTIVE')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?status=ACTIVE')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_with_property(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'property-test': '3'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?property-test=3')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?property-test=3')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_server(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        # 'server' should be converted to 'property-instance_ref'
+        filters = {'property-instance_ref': 'http://localhost:8774/servers/12'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?server='
+                                      'http://localhost:8774/servers/12')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_changes_since(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'changes-since': '2011-01-24T17:08Z'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?changes-since='
+                                      '2011-01-24T17:08Z')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
+
+    def test_image_detail_filter_with_type(self):
+        image_service = self.mox.CreateMockAnything()
+        context = object()
+        filters = {'property-image_type': 'BASE'}
+        image_service.index(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?type=BASE')
+        request.environ['nova.context'] = context
+        controller = images.ControllerV11(image_service=image_service)
+        controller.index(request)
+        self.mox.VerifyAll()
 
     def test_image_detail_filter_not_supported(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {'status': 'ACTIVE'}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail?status=ACTIVE&UNSUPPORTEDFILTER=testname')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail?status=ACTIVE&'
+                                      'UNSUPPORTEDFILTER=testname')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_image_detail_no_filters(self):
-        mocker = mox.Mox()
-        image_service = mocker.CreateMockAnything()
+        image_service = self.mox.CreateMockAnything()
         context = object()
         filters = {}
-        image_service.detail(
-            context, filters=filters).AndReturn([])
-        mocker.ReplayAll()
-        request = webob.Request.blank(
-            '/v1.1/images/detail')
+        image_service.detail(context, filters=filters).AndReturn([])
+        self.mox.ReplayAll()
+        request = webob.Request.blank('/v1.1/images/detail')
         request.environ['nova.context'] = context
         controller = images.ControllerV11(image_service=image_service)
         controller.detail(request)
-        mocker.VerifyAll()
+        self.mox.VerifyAll()
 
     def test_get_image_found(self):
         req = webob.Request.blank('/v1.0/images/123')
diff --git a/nova/tests/api/openstack/test_limits.py b/nova/tests/api/openstack/test_limits.py
index 38c959fae..8a3fe681a 100644
--- a/nova/tests/api/openstack/test_limits.py
+++ b/nova/tests/api/openstack/test_limits.py
@@ -24,11 +24,12 @@ import stubout
 import time
 import unittest
 import webob
-
-from xml.dom.minidom import parseString
+from xml.dom import minidom
 
 import nova.context
 from nova.api.openstack import limits
+from nova.api.openstack import views
+from nova import test
 
 
 TEST_LIMITS = [
@@ -166,7 +167,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
         request = self._get_index_request("application/xml")
         response = request.get_response(self.controller)
 
-        expected = parseString("""
+        expected = minidom.parseString("""
             <limits
                 xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
                 <rate/>
@@ -174,7 +175,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
             </limits>
         """.replace("  ", ""))
 
-        body = parseString(response.body.replace("  ", ""))
+        body = minidom.parseString(response.body.replace("  ", ""))
 
         self.assertEqual(expected.toxml(), body.toxml())
 
@@ -184,7 +185,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
         request = self._populate_limits(request)
         response = request.get_response(self.controller)
 
-        expected = parseString("""
+        expected = minidom.parseString("""
             <limits
                 xmlns="http://docs.rackspacecloud.com/servers/api/v1.0">
                 <rate>
@@ -196,7 +197,7 @@ class LimitsControllerV10Test(BaseLimitTestSuite):
                 <absolute/>
             </limits>
         """.replace("  ", ""))
-        body = parseString(response.body.replace("  ", ""))
+        body = minidom.parseString(response.body.replace("  ", ""))
 
         self.assertEqual(expected.toxml(), body.toxml())
 
@@ -210,6 +211,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
         """Run before each test."""
         BaseLimitTestSuite.setUp(self)
         self.controller = limits.create_resource('1.1')
+        self.maxDiff = None
 
     def _get_index_request(self, accept_header="application/json"):
         """Helper to set routing arguments."""
@@ -266,14 +268,14 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
                             },
                             {
                                 "verb": "POST",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "HOUR",
                                 "value": 5,
                                 "remaining": 5,
@@ -286,7 +288,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 5,
                                 "remaining": 5,
@@ -328,7 +330,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
@@ -341,7 +343,7 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
                         "limit": [
                             {
                                 "verb": "GET",
-                                "next-available": 0,
+                                "next-available": "1970-01-01T00:00:00Z",
                                 "unit": "MINUTE",
                                 "value": 10,
                                 "remaining": 10,
@@ -400,6 +402,10 @@ class LimitsControllerV11Test(BaseLimitTestSuite):
         self._test_index_absolute_limits_json(expected)
 
 
+class TestLimiter(limits.Limiter):
+    pass
+
+
 class LimitMiddlewareTest(BaseLimitTestSuite):
     """
     Tests for the `limits.RateLimitingMiddleware` class.
@@ -413,10 +419,14 @@ class LimitMiddlewareTest(BaseLimitTestSuite):
     def setUp(self):
         """Prepare middleware for use through fake WSGI app."""
         BaseLimitTestSuite.setUp(self)
-        _limits = [
-            limits.Limit("GET", "*", ".*", 1, 60),
-        ]
-        self.app = limits.RateLimitingMiddleware(self._empty_app, _limits)
+        _limits = '(GET, *, .*, 1, MINUTE)'
+        self.app = limits.RateLimitingMiddleware(self._empty_app, _limits,
+                                                 "%s.TestLimiter" %
+                                                 self.__class__.__module__)
+
+    def test_limit_class(self):
+        """Test that middleware selected correct limiter class."""
+        assert isinstance(self.app._limiter, TestLimiter)
 
     def test_good_request(self):
         """Test successful GET request through middleware."""
@@ -450,7 +460,7 @@ class LimitMiddlewareTest(BaseLimitTestSuite):
         response = request.get_response(self.app)
         self.assertEqual(response.status_int, 403)
 
-        root = parseString(response.body).childNodes[0]
+        root = minidom.parseString(response.body).childNodes[0]
         expected = "Only 1 GET request(s) can be made to * every minute."
 
         details = root.getElementsByTagName("details")
@@ -492,6 +502,72 @@ class LimitTest(BaseLimitTestSuite):
         self.assertEqual(4, limit.last_request)
 
 
+class ParseLimitsTest(BaseLimitTestSuite):
+    """
+    Tests for the default limits parser in the in-memory
+    `limits.Limiter` class.
+    """
+
+    def test_invalid(self):
+        """Test that parse_limits() handles invalid input correctly."""
+        self.assertRaises(ValueError, limits.Limiter.parse_limits,
+                          ';;;;;')
+
+    def test_bad_rule(self):
+        """Test that parse_limits() handles bad rules correctly."""
+        self.assertRaises(ValueError, limits.Limiter.parse_limits,
+                          'GET, *, .*, 20, minute')
+
+    def test_missing_arg(self):
+        """Test that parse_limits() handles missing args correctly."""
+        self.assertRaises(ValueError, limits.Limiter.parse_limits,
+                          '(GET, *, .*, 20)')
+
+    def test_bad_value(self):
+        """Test that parse_limits() handles bad values correctly."""
+        self.assertRaises(ValueError, limits.Limiter.parse_limits,
+                          '(GET, *, .*, foo, minute)')
+
+    def test_bad_unit(self):
+        """Test that parse_limits() handles bad units correctly."""
+        self.assertRaises(ValueError, limits.Limiter.parse_limits,
+                          '(GET, *, .*, 20, lightyears)')
+
+    def test_multiple_rules(self):
+        """Test that parse_limits() handles multiple rules correctly."""
+        try:
+            l = limits.Limiter.parse_limits('(get, *, .*, 20, minute);'
+                                            '(PUT, /foo*, /foo.*, 10, hour);'
+                                            '(POST, /bar*, /bar.*, 5, second);'
+                                            '(Say, /derp*, /derp.*, 1, day)')
+        except ValueError, e:
+            assert False, str(e)
+
+        # Make sure the number of returned limits are correct
+        self.assertEqual(len(l), 4)
+
+        # Check all the verbs...
+        expected = ['GET', 'PUT', 'POST', 'SAY']
+        self.assertEqual([t.verb for t in l], expected)
+
+        # ...the URIs...
+        expected = ['*', '/foo*', '/bar*', '/derp*']
+        self.assertEqual([t.uri for t in l], expected)
+
+        # ...the regexes...
+        expected = ['.*', '/foo.*', '/bar.*', '/derp.*']
+        self.assertEqual([t.regex for t in l], expected)
+
+        # ...the values...
+        expected = [20, 10, 5, 1]
+        self.assertEqual([t.value for t in l], expected)
+
+        # ...and the units...
+        expected = [limits.PER_MINUTE, limits.PER_HOUR,
+                    limits.PER_SECOND, limits.PER_DAY]
+        self.assertEqual([t.unit for t in l], expected)
+
+
 class LimiterTest(BaseLimitTestSuite):
     """
     Tests for the in-memory `limits.Limiter` class.
@@ -500,7 +576,8 @@ class LimiterTest(BaseLimitTestSuite):
     def setUp(self):
         """Run before each test."""
         BaseLimitTestSuite.setUp(self)
-        self.limiter = limits.Limiter(TEST_LIMITS)
+        userlimits = {'user:user3': ''}
+        self.limiter = limits.Limiter(TEST_LIMITS, **userlimits)
 
     def _check(self, num, verb, url, username=None):
         """Check and yield results from checks."""
@@ -605,6 +682,12 @@ class LimiterTest(BaseLimitTestSuite):
         results = list(self._check(10, "PUT", "/anything"))
         self.assertEqual(expected, results)
 
+    def test_user_limit(self):
+        """
+        Test user-specific limits.
+        """
+        self.assertEqual(self.limiter.levels['user3'], [])
+
     def test_multiple_users(self):
         """
         Tests involving multiple users.
@@ -619,6 +702,11 @@ class LimiterTest(BaseLimitTestSuite):
         results = list(self._check(15, "PUT", "/anything", "user2"))
         self.assertEqual(expected, results)
 
+        # User3
+        expected = [None] * 20
+        results = list(self._check(20, "PUT", "/anything", "user3"))
+        self.assertEqual(expected, results)
+
         self.time += 1.0
 
         # User1 again
@@ -818,3 +906,195 @@ class WsgiLimiterProxyTest(BaseLimitTestSuite):
             "made to /delayed every minute.")
 
         self.assertEqual((delay, error), expected)
+
+
+class LimitsViewBuilderV11Test(test.TestCase):
+
+    def setUp(self):
+        self.view_builder = views.limits.ViewBuilderV11()
+        self.rate_limits = [
+            {
+                "URI": "*",
+                "regex": ".*",
+                "value": 10,
+                "verb": "POST",
+                "remaining": 2,
+                "unit": "MINUTE",
+                "resetTime": 1311272226
+            },
+            {
+                "URI": "*/servers",
+                "regex": "^/servers",
+                "value": 50,
+                "verb": "POST",
+                "remaining": 10,
+                "unit": "DAY",
+                "resetTime": 1311272226
+            },
+        ]
+        self.absolute_limits = {
+            "metadata_items": 1,
+            "injected_files": 5,
+            "injected_file_content_bytes": 5,
+        }
+
+    def tearDown(self):
+        pass
+
+    def test_build_limits(self):
+        expected_limits = {
+            "limits": {
+                "rate": [
+                    {
+                        "uri": "*",
+                        "regex": ".*",
+                        "limit": [
+                            {
+                                "value": 10,
+                                "verb": "POST",
+                                "remaining": 2,
+                                "unit": "MINUTE",
+                                "next-available": "2011-07-21T18:17:06Z"
+                            },
+                        ]
+                    },
+                    {
+                        "uri": "*/servers",
+                        "regex": "^/servers",
+                        "limit": [
+                            {
+                                "value": 50,
+                                "verb": "POST",
+                                "remaining": 10,
+                                "unit": "DAY",
+                                "next-available": "2011-07-21T18:17:06Z"
+                            },
+                        ]
+                    },
+                ],
+                "absolute": {
+                    "maxServerMeta": 1,
+                    "maxImageMeta": 1,
+                    "maxPersonality": 5,
+                    "maxPersonalitySize": 5
+                }
+            }
+        }
+
+        output = self.view_builder.build(self.rate_limits,
+                                         self.absolute_limits)
+        self.assertDictMatch(output, expected_limits)
+
+    def test_build_limits_empty_limits(self):
+        expected_limits = {
+            "limits": {
+                "rate": [],
+                "absolute": {}
+            }
+        }
+
+        abs_limits = {}
+        rate_limits = []
+        output = self.view_builder.build(rate_limits, abs_limits)
+        self.assertDictMatch(output, expected_limits)
+
+
+class LimitsXMLSerializationTest(test.TestCase):
+
+    def setUp(self):
+        self.maxDiff = None
+
+    def tearDown(self):
+        pass
+
+    def test_index(self):
+        serializer = limits.LimitsXMLSerializer()
+
+        fixture = {
+            "limits": {
+                "rate": [
+                    {
+                        "uri": "*",
+                        "regex": ".*",
+                        "limit": [
+                            {
+                                "value": 10,
+                                "verb": "POST",
+                                "remaining": 2,
+                                "unit": "MINUTE",
+                                "next-available": "2011-12-15T22:42:45Z"
+                            },
+                        ]
+                    },
+                    {
+                        "uri": "*/servers",
+                        "regex": "^/servers",
+                        "limit": [
+                            {
+                                "value": 50,
+                                "verb": "POST",
+                                "remaining": 10,
+                                "unit": "DAY",
+                                "next-available": "2011-12-15T22:42:45Z"
+                            },
+                        ]
+                    },
+                ],
+                "absolute": {
+                    "maxServerMeta": 1,
+                    "maxImageMeta": 1,
+                    "maxPersonality": 5,
+                    "maxPersonalitySize": 10240
+                }
+            }
+        }
+
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <limits xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <rates>
+                <rate uri="*" regex=".*">
+                    <limit value="10" verb="POST" remaining="2"
+                        unit="MINUTE"
+                        next-available="2011-12-15T22:42:45Z"/>
+                </rate>
+                <rate uri="*/servers" regex="^/servers">
+                    <limit value="50" verb="POST" remaining="10"
+                        unit="DAY"
+                        next-available="2011-12-15T22:42:45Z"/>
+                </rate>
+            </rates>
+            <absolute>
+                <limit name="maxServerMeta" value="1"/>
+                <limit name="maxPersonality" value="5"/>
+                <limit name="maxImageMeta" value="1"/>
+                <limit name="maxPersonalitySize" value="10240"/>
+            </absolute>
+        </limits>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_no_limits(self):
+        serializer = limits.LimitsXMLSerializer()
+
+        fixture = {
+            "limits": {
+                "rate": [],
+                "absolute": {}
+            }
+        }
+
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+        <limits xmlns="http://docs.openstack.org/compute/api/v1.1">
+            <rates />
+            <absolute />
+        </limits>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 775f66ad0..1c66c1aa6 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -65,6 +65,18 @@ def return_server_by_uuid(context, uuid):
     return stub_instance(id, uuid=uuid)
 
 
+def return_virtual_interface_by_instance(interfaces):
+    def _return_virtual_interface_by_instance(context, instance_id):
+        return interfaces
+    return _return_virtual_interface_by_instance
+
+
+def return_virtual_interface_instance_nonexistant(interfaces):
+    def _return_virtual_interface_by_instance(context, instance_id):
+        raise exception.InstanceNotFound(instance_id=instance_id)
+    return _return_virtual_interface_by_instance
+
+
 def return_server_with_addresses(private, public):
     def _return_server(context, id):
         return stub_instance(id, private_address=private,
@@ -72,6 +84,12 @@ def return_server_with_addresses(private, public):
     return _return_server
 
 
+def return_server_with_interfaces(interfaces):
+    def _return_server(context, id):
+        return stub_instance(id, interfaces=interfaces)
+    return _return_server
+
+
 def return_server_with_power_state(power_state):
     def _return_server(context, id):
         return stub_instance(id, power_state=power_state)
@@ -124,10 +142,13 @@ def instance_addresses(context, instance_id):
 
 def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
                   host=None, power_state=0, reservation_id="",
-                  uuid=FAKE_UUID):
+                  uuid=FAKE_UUID, interfaces=None):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
+    if interfaces is None:
+        interfaces = []
+
     inst_type = instance_types.get_instance_type_by_flavor_id(1)
 
     if public_addresses is None:
@@ -171,7 +192,8 @@ def stub_instance(id, user_id=1, private_address=None, public_addresses=None,
         "display_description": "",
         "locked": False,
         "metadata": metadata,
-        "uuid": uuid}
+        "uuid": uuid,
+        "virtual_interfaces": interfaces}
 
     instance["fixed_ips"] = {
         "address": private_address,
@@ -411,23 +433,203 @@ class ServersTest(test.TestCase):
         self.assertEquals(ip.getAttribute('addr'), private)
 
     def test_get_server_by_id_with_addresses_v1_1(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
+        FLAGS.use_ipv6 = True
+        interfaces = [
+            {
+                'network': {'label': 'network_1'},
+                'fixed_ips': [
+                    {'address': '192.168.0.3'},
+                    {'address': '192.168.0.4'},
+                ],
+            },
+            {
+                'network': {'label': 'network_2'},
+                'fixed_ips': [
+                    {'address': '172.19.0.1'},
+                    {'address': '172.19.0.2'},
+                ],
+                'fixed_ipv6': '2001:4860::12',
+            },
+        ]
+        new_return_server = return_server_with_interfaces(interfaces)
         self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
         req = webob.Request.blank('/v1.1/servers/1')
         res = req.get_response(fakes.wsgi_app())
+
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server1')
         addresses = res_dict['server']['addresses']
-        # RM(4047): Figure otu what is up with the 1.1 api and multi-nic
-        #self.assertEqual(len(addresses["public"]), len(public))
-        #self.assertEqual(addresses["public"][0],
-        #    {"version": 4, "addr": public[0]})
-        #self.assertEqual(len(addresses["private"]), 1)
-        #self.assertEqual(addresses["private"][0],
-        #    {"version": 4, "addr": private})
+        expected = {
+            'network_1': [
+                {'addr': '192.168.0.3', 'version': 4},
+                {'addr': '192.168.0.4', 'version': 4},
+            ],
+            'network_2': [
+                {'addr': '172.19.0.1', 'version': 4},
+                {'addr': '172.19.0.2', 'version': 4},
+                {'addr': '2001:4860::12', 'version': 6},
+            ],
+        }
+
+        self.assertEqual(addresses, expected)
+
+    def test_get_server_by_id_with_addresses_v1_1_ipv6_disabled(self):
+        FLAGS.use_ipv6 = False
+        interfaces = [
+            {
+                'network': {'label': 'network_1'},
+                'fixed_ips': [
+                    {'address': '192.168.0.3'},
+                    {'address': '192.168.0.4'},
+                ],
+            },
+            {
+                'network': {'label': 'network_2'},
+                'fixed_ips': [
+                    {'address': '172.19.0.1'},
+                    {'address': '172.19.0.2'},
+                ],
+                'fixed_ipv6': '2001:4860::12',
+            },
+        ]
+        new_return_server = return_server_with_interfaces(interfaces)
+        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        req = webob.Request.blank('/v1.1/servers/1')
+        res = req.get_response(fakes.wsgi_app())
+
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server1')
+        addresses = res_dict['server']['addresses']
+        expected = {
+            'network_1': [
+                {'addr': '192.168.0.3', 'version': 4},
+                {'addr': '192.168.0.4', 'version': 4},
+            ],
+            'network_2': [
+                {'addr': '172.19.0.1', 'version': 4},
+                {'addr': '172.19.0.2', 'version': 4},
+            ],
+        }
+
+        self.assertEqual(addresses, expected)
+
+    def test_get_server_addresses_v1_1(self):
+        FLAGS.use_ipv6 = True
+        interfaces = [
+            {
+                'network': {'label': 'network_1'},
+                'fixed_ips': [
+                    {'address': '192.168.0.3'},
+                    {'address': '192.168.0.4'},
+                ],
+            },
+            {
+                'network': {'label': 'network_2'},
+                'fixed_ips': [
+                    {
+                        'address': '172.19.0.1',
+                        'floating_ips': [
+                            {'address': '1.2.3.4'},
+                        ],
+                    },
+                    {'address': '172.19.0.2'},
+                ],
+                'fixed_ipv6': '2001:4860::12',
+            },
+        ]
+
+        _return_vifs = return_virtual_interface_by_instance(interfaces)
+        self.stubs.Set(nova.db.api,
+                       'virtual_interface_get_by_instance',
+                       _return_vifs)
+
+        req = webob.Request.blank('/v1.1/servers/1/ips')
+        res = req.get_response(fakes.wsgi_app())
+        res_dict = json.loads(res.body)
+
+        expected = {
+            'addresses': {
+                'network_1': [
+                    {'version': 4, 'addr': '192.168.0.3'},
+                    {'version': 4, 'addr': '192.168.0.4'},
+                ],
+                'network_2': [
+                    {'version': 4, 'addr': '172.19.0.1'},
+                    {'version': 4, 'addr': '1.2.3.4'},
+                    {'version': 4, 'addr': '172.19.0.2'},
+                    {'version': 6, 'addr': '2001:4860::12'},
+                ],
+            },
+        }
+
+        self.assertEqual(res_dict, expected)
+
+    def test_get_server_addresses_single_network_v1_1(self):
+        FLAGS.use_ipv6 = True
+        interfaces = [
+            {
+                'network': {'label': 'network_1'},
+                'fixed_ips': [
+                    {'address': '192.168.0.3'},
+                    {'address': '192.168.0.4'},
+                ],
+            },
+            {
+                'network': {'label': 'network_2'},
+                'fixed_ips': [
+                    {
+                        'address': '172.19.0.1',
+                        'floating_ips': [
+                            {'address': '1.2.3.4'},
+                        ],
+                    },
+                    {'address': '172.19.0.2'},
+                ],
+                'fixed_ipv6': '2001:4860::12',
+            },
+        ]
+        _return_vifs = return_virtual_interface_by_instance(interfaces)
+        self.stubs.Set(nova.db.api,
+                       'virtual_interface_get_by_instance',
+                       _return_vifs)
+
+        req = webob.Request.blank('/v1.1/servers/1/ips/network_2')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        expected = {
+            'network_2': [
+                {'version': 4, 'addr': '172.19.0.1'},
+                {'version': 4, 'addr': '1.2.3.4'},
+                {'version': 4, 'addr': '172.19.0.2'},
+                {'version': 6, 'addr': '2001:4860::12'},
+            ],
+        }
+        self.assertEqual(res_dict, expected)
+
+    def test_get_server_addresses_nonexistant_network_v1_1(self):
+        _return_vifs = return_virtual_interface_by_instance([])
+        self.stubs.Set(nova.db.api,
+                       'virtual_interface_get_by_instance',
+                       _return_vifs)
+
+        req = webob.Request.blank('/v1.1/servers/1/ips/network_0')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
+
+    def test_get_server_addresses_nonexistant_server_v1_1(self):
+        _return_vifs = return_virtual_interface_instance_nonexistant([])
+        self.stubs.Set(nova.db.api,
+                       'virtual_interface_get_by_instance',
+                       _return_vifs)
+
+        req = webob.Request.blank('/v1.1/servers/600/ips')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 404)
 
     def test_get_server_list(self):
         req = webob.Request.blank('/v1.0/servers')
@@ -787,13 +989,45 @@ class ServersTest(test.TestCase):
 
         res = req.get_response(fakes.wsgi_app())
 
+        self.assertEqual(res.status_int, 200)
         server = json.loads(res.body)['server']
         self.assertEqual(16, len(server['adminPass']))
         self.assertEqual('server_test', server['name'])
         self.assertEqual(1, server['id'])
         self.assertEqual(flavor_ref, server['flavorRef'])
         self.assertEqual(image_href, server['imageRef'])
-        self.assertEqual(res.status_int, 200)
+
+    def test_create_instance_v1_1_invalid_flavor_href(self):
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/asdf'
+        body = dict(server=dict(
+            name='server_test', imageRef=image_href, flavorRef=flavor_ref,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_create_instance_v1_1_bad_flavor_href(self):
+        self._setup_for_create_instance()
+
+        image_href = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/v1.1/flavors/17'
+        body = dict(server=dict(
+            name='server_test', imageRef=image_href, flavorRef=flavor_ref,
+            metadata={'hello': 'world', 'open': 'stack'},
+            personality={}))
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
 
     def test_create_instance_v1_1_bad_href(self):
         self._setup_for_create_instance()
@@ -901,7 +1135,7 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
-    def test_update_no_body(self):
+    def test_update_server_no_body(self):
         req = webob.Request.blank('/v1.0/servers/1')
         req.method = 'PUT'
         res = req.get_response(fakes.wsgi_app())
@@ -967,6 +1201,21 @@ class ServersTest(test.TestCase):
         self.assertEqual(mock_method.instance_id, '1')
         self.assertEqual(mock_method.password, 'bacon')
 
+    def test_update_server_no_body_v1_1(self):
+        req = webob.Request.blank('/v1.0/servers/1')
+        req.method = 'PUT'
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_update_server_name_v1_1(self):
+        req = webob.Request.blank('/v1.1/servers/1')
+        req.method = 'PUT'
+        req.content_type = 'application/json'
+        req.body = json.dumps({'server': {'name': 'new-name'}})
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
+        self.assertEqual(res.body, '')
+
     def test_update_server_adminPass_ignored_v1_1(self):
         inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
@@ -985,6 +1234,7 @@ class ServersTest(test.TestCase):
         req.body = self.body
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 204)
+        self.assertEqual(res.body, '')
 
     def test_create_backup_schedules(self):
         req = webob.Request.blank('/v1.0/servers/1/backup_schedule')
@@ -1540,7 +1790,7 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.compute.api.API, 'resize', resize_mock)
 
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 400)
+        self.assertEqual(res.status_int, 500)
 
     def test_resized_server_has_correct_status(self):
         req = self.webreq('/1', 'GET')
diff --git a/nova/tests/api/openstack/test_versions.py b/nova/tests/api/openstack/test_versions.py
index fd8d50904..0eae18a62 100644
--- a/nova/tests/api/openstack/test_versions.py
+++ b/nova/tests/api/openstack/test_versions.py
@@ -21,6 +21,7 @@ import webob
 from nova import context
 from nova import test
 from nova.tests.api.openstack import fakes
+from nova.api.openstack import versions
 from nova.api.openstack import views
 
 
@@ -43,19 +44,21 @@ class VersionsTest(test.TestCase):
             {
                 "id": "v1.1",
                 "status": "CURRENT",
+                "updated": "2011-07-18T11:30:00Z",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.1",
+                        "href": "http://localhost/v1.1/",
                     }],
             },
             {
                 "id": "v1.0",
                 "status": "DEPRECATED",
+                "updated": "2010-10-09T11:30:00Z",
                 "links": [
                     {
                         "rel": "self",
-                        "href": "http://localhost/v1.0",
+                        "href": "http://localhost/v1.0/",
                     }],
             },
         ]
@@ -69,15 +72,12 @@ class VersionsTest(test.TestCase):
         self.assertEqual(res.content_type, "application/xml")
 
         expected = """<versions>
-            <version id="v1.1" status="CURRENT">
-                <links>
-                    <link href="http://localhost/v1.1" rel="self"/>
-                </links>
+            <version id="v1.1" status="CURRENT" updated="2011-07-18T11:30:00Z">
+                <atom:link href="http://localhost/v1.1/" rel="self"/>
             </version>
-            <version id="v1.0" status="DEPRECATED">
-                <links>
-                    <link href="http://localhost/v1.0" rel="self"/>
-                </links>
+            <version id="v1.0" status="DEPRECATED"
+                 updated="2010-10-09T11:30:00Z">
+                <atom:link href="http://localhost/v1.0/" rel="self"/>
             </version>
         </versions>""".replace("  ", "").replace("\n", "")
 
@@ -85,21 +85,64 @@ class VersionsTest(test.TestCase):
 
         self.assertEqual(expected, actual)
 
+    def test_get_version_list_atom(self):
+        req = webob.Request.blank('/')
+        req.accept = "application/atom+xml"
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(res.content_type, "application/atom+xml")
+
+        expected = """
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <title type="text">Available API Versions</title>
+            <updated>2011-07-18T11:30:00Z</updated>
+            <id>http://localhost/</id>
+            <author>
+                <name>Rackspace</name>
+                <uri>http://www.rackspace.com/</uri>
+            </author>
+            <link href="http://localhost/" rel="self"/>
+            <entry>
+                <id>http://localhost/v1.1/</id>
+                <title type="text">Version v1.1</title>
+                <updated>2011-07-18T11:30:00Z</updated>
+                <link href="http://localhost/v1.1/" rel="self"/>
+                <content type="text">
+                    Version v1.1 CURRENT (2011-07-18T11:30:00Z)
+                </content>
+            </entry>
+            <entry>
+                <id>http://localhost/v1.0/</id>
+                <title type="text">Version v1.0</title>
+                <updated>2010-10-09T11:30:00Z</updated>
+                <link href="http://localhost/v1.0/" rel="self"/>
+                <content type="text">
+                    Version v1.0 DEPRECATED (2010-10-09T11:30:00Z)
+                </content>
+            </entry>
+        </feed>
+        """.replace("  ", "").replace("\n", "")
+
+        actual = res.body.replace("  ", "").replace("\n", "")
+
+        self.assertEqual(expected, actual)
+
     def test_view_builder(self):
         base_url = "http://example.org/"
 
         version_data = {
             "id": "3.2.1",
             "status": "CURRENT",
-        }
+            "updated": "2011-07-18T11:30:00Z"}
 
         expected = {
             "id": "3.2.1",
             "status": "CURRENT",
+            "updated": "2011-07-18T11:30:00Z",
             "links": [
                 {
                     "rel": "self",
-                    "href": "http://example.org/3.2.1",
+                    "href": "http://example.org/3.2.1/",
                 },
             ],
         }
@@ -113,9 +156,99 @@ class VersionsTest(test.TestCase):
         base_url = "http://example.org/app/"
         version_number = "v1.4.6"
 
-        expected = "http://example.org/app/v1.4.6"
+        expected = "http://example.org/app/v1.4.6/"
 
         builder = views.versions.ViewBuilder(base_url)
         actual = builder.generate_href(version_number)
 
         self.assertEqual(actual, expected)
+
+    def test_xml_serializer(self):
+        versions_data = {
+            'versions': [
+                {
+                    "id": "2.7.1",
+                    "updated": "2011-07-18T11:30:00Z",
+                    "status": "DEPRECATED",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://test/2.7.1",
+                        }
+                    ],
+                },
+            ]
+        }
+
+        expected = """
+            <versions>
+                <version id="2.7.1" status="DEPRECATED"
+                 updated="2011-07-18T11:30:00Z">
+                    <atom:link href="http://test/2.7.1" rel="self"/>
+                </version>
+            </versions>""".replace("  ", "").replace("\n", "")
+
+        serializer = versions.VersionsXMLSerializer()
+        response = serializer.default(versions_data)
+        response = response.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, response)
+
+    def test_atom_serializer(self):
+        versions_data = {
+            'versions': [
+                {
+                    "id": "2.9.8",
+                    "updated": "2011-07-20T11:40:00Z",
+                    "status": "CURRENT",
+                    "links": [
+                        {
+                            "rel": "self",
+                            "href": "http://test/2.9.8",
+                        }
+                    ],
+                },
+            ]
+        }
+
+        expected = """
+            <feed xmlns="http://www.w3.org/2005/Atom">
+                <title type="text">
+                    Available API Versions
+                </title>
+                <updated>
+                    2011-07-20T11:40:00Z
+                </updated>
+                <id>
+                    http://test/
+                </id>
+                <author>
+                    <name>
+                        Rackspace
+                    </name>
+                    <uri>
+                        http://www.rackspace.com/
+                    </uri>
+                </author>
+                <link href="http://test/" rel="self"/>
+                <entry>
+                    <id>
+                        http://test/2.9.8
+                    </id>
+                    <title type="text">
+                        Version 2.9.8
+                    </title>
+                    <updated>
+                        2011-07-20T11:40:00Z
+                    </updated>
+                    <link href="http://test/2.9.8" rel="self"/>
+                    <content type="text">
+                        Version 2.9.8 CURRENT (2011-07-20T11:40:00Z)
+                    </content>
+                </entry>
+            </feed>""".replace("  ", "").replace("\n", "")
+
+        serializer = versions.VersionsAtomSerializer()
+        response = serializer.default(versions_data)
+        print response
+        response = response.replace("  ", "").replace("\n", "")
+        self.assertEqual(expected, response)
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index 7762df41c..19028a451 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -230,7 +230,7 @@ def stub_out_db_network_api(stubs):
                         continue
                     fixed_ip_fields['virtual_interface'] = FakeModel(vif[0])
 
-    def fake_instance_type_get_by_id(context, id):
+    def fake_instance_type_get(context, id):
         if flavor_fields['id'] == id:
             return FakeModel(flavor_fields)
 
@@ -323,7 +323,7 @@ def stub_out_db_network_api(stubs):
              fake_fixed_ip_get_by_address,
              fake_fixed_ip_get_network,
              fake_fixed_ip_update,
-             fake_instance_type_get_by_id,
+             fake_instance_type_get,
              fake_virtual_interface_create,
              fake_virtual_interface_delete_by_instance,
              fake_virtual_interface_get_by_instance,
@@ -415,7 +415,7 @@ def stub_out_db_instance_api(stubs, injected=True):
     def fake_instance_type_get_by_name(context, name):
         return INSTANCE_TYPES[name]
 
-    def fake_instance_type_get_by_id(context, id):
+    def fake_instance_type_get(context, id):
         for name, inst_type in INSTANCE_TYPES.iteritems():
             if str(inst_type['id']) == str(id):
                 return inst_type
@@ -448,7 +448,7 @@ def stub_out_db_instance_api(stubs, injected=True):
              fake_network_get_all_by_instance,
              fake_instance_type_get_all,
              fake_instance_type_get_by_name,
-             fake_instance_type_get_by_id,
+             fake_instance_type_get,
              fake_instance_get_fixed_addresses,
              fake_instance_get_fixed_addresses_v6,
              fake_network_get_all_by_instance,
diff --git a/nova/tests/image/test_s3.py b/nova/tests/image/test_s3.py
new file mode 100644
index 000000000..231e109f8
--- /dev/null
+++ b/nova/tests/image/test_s3.py
@@ -0,0 +1,122 @@
+# 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 context
+from nova import flags
+from nova import test
+from nova.image import s3
+
+FLAGS = flags.FLAGS
+
+
+ami_manifest_xml = """<?xml version="1.0" ?>
+<manifest>
+        <version>2011-06-17</version>
+        <bundler>
+                <name>test-s3</name>
+                <version>0</version>
+                <release>0</release>
+        </bundler>
+        <machine_configuration>
+                <architecture>x86_64</architecture>
+                <block_device_mapping>
+                        <mapping>
+                                <virtual>ami</virtual>
+                                <device>sda1</device>
+                        </mapping>
+                        <mapping>
+                                <virtual>root</virtual>
+                                <device>/dev/sda1</device>
+                        </mapping>
+                        <mapping>
+                                <virtual>ephemeral0</virtual>
+                                <device>sda2</device>
+                        </mapping>
+                        <mapping>
+                                <virtual>swap</virtual>
+                                <device>sda3</device>
+                        </mapping>
+                </block_device_mapping>
+        </machine_configuration>
+</manifest>
+"""
+
+
+class TestS3ImageService(test.TestCase):
+    def setUp(self):
+        super(TestS3ImageService, self).setUp()
+        self.orig_image_service = FLAGS.image_service
+        FLAGS.image_service = 'nova.image.fake.FakeImageService'
+        self.image_service = s3.S3ImageService()
+        self.context = context.RequestContext(None, None)
+
+    def tearDown(self):
+        super(TestS3ImageService, self).tearDown()
+        FLAGS.image_service = self.orig_image_service
+
+    def _assertEqualList(self, list0, list1, keys):
+        self.assertEqual(len(list0), len(list1))
+        key = keys[0]
+        for x in list0:
+            self.assertEqual(len(x), len(keys))
+            self.assertTrue(key in x)
+            for y in list1:
+                self.assertTrue(key in y)
+                if x[key] == y[key]:
+                    for k in keys:
+                        self.assertEqual(x[k], y[k])
+
+    def test_s3_create(self):
+        metadata = {'properties': {
+            'root_device_name': '/dev/sda1',
+            'block_device_mapping': [
+                {'device_name': '/dev/sda1',
+                 'snapshot_id': 'snap-12345678',
+                 'delete_on_termination': True},
+                {'device_name': '/dev/sda2',
+                 'virutal_name': 'ephemeral0'},
+                {'device_name': '/dev/sdb0',
+                 'no_device': True}]}}
+        _manifest, image = self.image_service._s3_parse_manifest(
+            self.context, metadata, ami_manifest_xml)
+        image_id = image['id']
+
+        ret_image = self.image_service.show(self.context, image_id)
+        self.assertTrue('properties' in ret_image)
+        properties = ret_image['properties']
+
+        self.assertTrue('mappings' in properties)
+        mappings = properties['mappings']
+        expected_mappings = [
+            {"device": "sda1", "virtual": "ami"},
+            {"device": "/dev/sda1", "virtual": "root"},
+            {"device": "sda2", "virtual": "ephemeral0"},
+            {"device": "sda3", "virtual": "swap"}]
+        self._assertEqualList(mappings, expected_mappings,
+            ['device', 'virtual'])
+
+        self.assertTrue('block_device_mapping', properties)
+        block_device_mapping = properties['block_device_mapping']
+        expected_bdm = [
+            {'device_name': '/dev/sda1',
+             'snapshot_id': 'snap-12345678',
+             'delete_on_termination': True},
+            {'device_name': '/dev/sda2',
+             'virutal_name': 'ephemeral0'},
+            {'device_name': '/dev/sdb0',
+             'no_device': True}]
+        self.assertEqual(block_device_mapping, expected_bdm)
diff --git a/nova/tests/integrated/api/client.py b/nova/tests/integrated/api/client.py
index 59cc3b564..035a35aab 100644
--- a/nova/tests/integrated/api/client.py
+++ b/nova/tests/integrated/api/client.py
@@ -172,6 +172,17 @@ class TestOpenStackClient(object):
         response = self.api_request(relative_uri, **kwargs)
         return self._decode_json(response)
 
+    def api_put(self, relative_uri, body, **kwargs):
+        kwargs['method'] = 'PUT'
+        if body:
+            headers = kwargs.setdefault('headers', {})
+            headers['Content-Type'] = 'application/json'
+            kwargs['body'] = json.dumps(body)
+
+        kwargs.setdefault('check_response_status', [200, 202, 204])
+        response = self.api_request(relative_uri, **kwargs)
+        return self._decode_json(response)
+
     def api_delete(self, relative_uri, **kwargs):
         kwargs['method'] = 'DELETE'
         kwargs.setdefault('check_response_status', [200, 202, 204])
@@ -187,6 +198,9 @@ class TestOpenStackClient(object):
     def post_server(self, server):
         return self.api_post('/servers', server)['server']
 
+    def put_server(self, server_id, server):
+        return self.api_put('/servers/%s' % server_id, server)
+
     def post_server_action(self, server_id, data):
         return self.api_post('/servers/%s/action' % server_id, data)
 
diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py
index fcb517cf5..4e8e85c7b 100644
--- a/nova/tests/integrated/test_servers.py
+++ b/nova/tests/integrated/test_servers.py
@@ -285,6 +285,25 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
         # Cleanup
         self._delete_server(created_server_id)
 
+    def test_rename_server(self):
+        """Test building and renaming a server."""
+
+        # Create a server
+        server = self._build_minimal_create_server_request()
+        created_server = self.api.post_server({'server': server})
+        LOG.debug("created_server: %s" % created_server)
+        server_id = created_server['id']
+        self.assertTrue(server_id)
+
+        # Rename the server to 'new-name'
+        self.api.put_server(server_id, {'server': {'name': 'new-name'}})
+
+        # Check the name of the server
+        created_server = self.api.get_server(server_id)
+        self.assertEqual(created_server['name'], 'new-name')
+
+        # Cleanup
+        self._delete_server(server_id)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index 20b20fcbf..26ac5ff24 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -92,7 +92,9 @@ class XmlConversionTestCase(test.TestCase):
         conv = ec2utils._try_convert
         self.assertEqual(conv('None'), None)
         self.assertEqual(conv('True'), True)
+        self.assertEqual(conv('true'), True)
         self.assertEqual(conv('False'), False)
+        self.assertEqual(conv('false'), False)
         self.assertEqual(conv('0'), 0)
         self.assertEqual(conv('42'), 42)
         self.assertEqual(conv('3.14'), 3.14)
@@ -107,6 +109,8 @@ class Ec2utilsTestCase(test.TestCase):
     def test_ec2_id_to_id(self):
         self.assertEqual(ec2utils.ec2_id_to_id('i-0000001e'), 30)
         self.assertEqual(ec2utils.ec2_id_to_id('ami-1d'), 29)
+        self.assertEqual(ec2utils.ec2_id_to_id('snap-0000001c'), 28)
+        self.assertEqual(ec2utils.ec2_id_to_id('vol-0000001b'), 27)
 
     def test_bad_ec2_id(self):
         self.assertRaises(exception.InvalidEc2Id,
@@ -116,6 +120,72 @@ class Ec2utilsTestCase(test.TestCase):
     def test_id_to_ec2_id(self):
         self.assertEqual(ec2utils.id_to_ec2_id(30), 'i-0000001e')
         self.assertEqual(ec2utils.id_to_ec2_id(29, 'ami-%08x'), 'ami-0000001d')
+        self.assertEqual(ec2utils.id_to_ec2_snap_id(28), 'snap-0000001c')
+        self.assertEqual(ec2utils.id_to_ec2_vol_id(27), 'vol-0000001b')
+
+    def test_dict_from_dotted_str(self):
+        in_str = [('BlockDeviceMapping.1.DeviceName', '/dev/sda1'),
+                  ('BlockDeviceMapping.1.Ebs.SnapshotId', 'snap-0000001c'),
+                  ('BlockDeviceMapping.1.Ebs.VolumeSize', '80'),
+                  ('BlockDeviceMapping.1.Ebs.DeleteOnTermination', 'false'),
+                  ('BlockDeviceMapping.2.DeviceName', '/dev/sdc'),
+                  ('BlockDeviceMapping.2.VirtualName', 'ephemeral0')]
+        expected_dict = {
+            'block_device_mapping': {
+            '1': {'device_name': '/dev/sda1',
+                  'ebs': {'snapshot_id': 'snap-0000001c',
+                          'volume_size': 80,
+                          'delete_on_termination': False}},
+            '2': {'device_name': '/dev/sdc',
+                  'virtual_name': 'ephemeral0'}}}
+        out_dict = ec2utils.dict_from_dotted_str(in_str)
+
+        self.assertDictMatch(out_dict, expected_dict)
+
+    def test_properties_root_defice_name(self):
+        mappings = [{"device": "/dev/sda1", "virtual": "root"}]
+        properties0 = {'mappings': mappings}
+        properties1 = {'root_device_name': '/dev/sdb', 'mappings': mappings}
+
+        root_device_name = ec2utils.properties_root_device_name(properties0)
+        self.assertEqual(root_device_name, '/dev/sda1')
+
+        root_device_name = ec2utils.properties_root_device_name(properties1)
+        self.assertEqual(root_device_name, '/dev/sdb')
+
+    def test_mapping_prepend_dev(self):
+        mappings = [
+            {'virtual': 'ami',
+             'device': 'sda1'},
+            {'virtual': 'root',
+             'device': '/dev/sda1'},
+
+            {'virtual': 'swap',
+             'device': 'sdb1'},
+            {'virtual': 'swap',
+             'device': '/dev/sdb2'},
+
+            {'virtual': 'ephemeral0',
+            'device': 'sdc1'},
+            {'virtual': 'ephemeral1',
+             'device': '/dev/sdc1'}]
+        expected_result = [
+            {'virtual': 'ami',
+             'device': 'sda1'},
+            {'virtual': 'root',
+             'device': '/dev/sda1'},
+
+            {'virtual': 'swap',
+             'device': '/dev/sdb1'},
+            {'virtual': 'swap',
+             'device': '/dev/sdb2'},
+
+            {'virtual': 'ephemeral0',
+             'device': '/dev/sdc1'},
+            {'virtual': 'ephemeral1',
+             'device': '/dev/sdc1'}]
+        self.assertDictListMatch(ec2utils.mappings_prepend_dev(mappings),
+                                 expected_result)
 
 
 class ApiEc2TestCase(test.TestCase):
diff --git a/nova/tests/test_bdm.py b/nova/tests/test_bdm.py
new file mode 100644
index 000000000..b258f6a75
--- /dev/null
+++ b/nova/tests/test_bdm.py
@@ -0,0 +1,233 @@
+# 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 Mapping Code.
+"""
+
+from nova.api.ec2 import cloud
+from nova import test
+
+
+class BlockDeviceMappingEc2CloudTestCase(test.TestCase):
+    """Test Case for Block Device Mapping"""
+
+    def setUp(self):
+        super(BlockDeviceMappingEc2CloudTestCase, self).setUp()
+
+    def tearDown(self):
+        super(BlockDeviceMappingEc2CloudTestCase, self).tearDown()
+
+    def _assertApply(self, action, bdm_list):
+        for bdm, expected_result in bdm_list:
+            self.assertDictMatch(action(bdm), expected_result)
+
+    def test_parse_block_device_mapping(self):
+        bdm_list = [
+            ({'device_name': '/dev/fake0',
+              'ebs': {'snapshot_id': 'snap-12345678',
+                      'volume_size': 1}},
+            {'device_name': '/dev/fake0',
+             'snapshot_id': 0x12345678,
+             'volume_size': 1,
+             'delete_on_termination': True}),
+
+            ({'device_name': '/dev/fake1',
+              'ebs': {'snapshot_id': 'snap-23456789',
+                      'delete_on_termination': False}},
+             {'device_name': '/dev/fake1',
+              'snapshot_id': 0x23456789,
+              'delete_on_termination': False}),
+
+            ({'device_name': '/dev/fake2',
+              'ebs': {'snapshot_id': 'vol-87654321',
+                      'volume_size': 2}},
+            {'device_name': '/dev/fake2',
+             'volume_id': 0x87654321,
+             'volume_size': 2,
+             'delete_on_termination': True}),
+
+            ({'device_name': '/dev/fake3',
+              'ebs': {'snapshot_id': 'vol-98765432',
+                      'delete_on_termination': False}},
+             {'device_name': '/dev/fake3',
+              'volume_id': 0x98765432,
+              'delete_on_termination': False}),
+
+            ({'device_name': '/dev/fake4',
+              'ebs': {'no_device': True}},
+             {'device_name': '/dev/fake4',
+              'no_device': True}),
+
+            ({'device_name': '/dev/fake5',
+             'virtual_name': 'ephemeral0'},
+            {'device_name': '/dev/fake5',
+             'virtual_name': 'ephemeral0'}),
+
+            ({'device_name': '/dev/fake6',
+             'virtual_name': 'swap'},
+            {'device_name': '/dev/fake6',
+             'virtual_name': 'swap'}),
+            ]
+        self._assertApply(cloud._parse_block_device_mapping, bdm_list)
+
+    def test_format_block_device_mapping(self):
+        bdm_list = [
+            ({'device_name': '/dev/fake0',
+              'snapshot_id': 0x12345678,
+              'volume_size': 1,
+              'delete_on_termination': True},
+             {'deviceName': '/dev/fake0',
+              'ebs': {'snapshotId': 'snap-12345678',
+                      'volumeSize': 1,
+                      'deleteOnTermination': True}}),
+
+            ({'device_name': '/dev/fake1',
+              'snapshot_id': 0x23456789},
+             {'deviceName': '/dev/fake1',
+              'ebs': {'snapshotId': 'snap-23456789'}}),
+
+            ({'device_name': '/dev/fake2',
+              'snapshot_id': 0x23456789,
+              'delete_on_termination': False},
+             {'deviceName': '/dev/fake2',
+              'ebs': {'snapshotId': 'snap-23456789',
+                      'deleteOnTermination': False}}),
+
+            ({'device_name': '/dev/fake3',
+              'volume_id': 0x12345678,
+              'volume_size': 1,
+              'delete_on_termination': True},
+             {'deviceName': '/dev/fake3',
+              'ebs': {'snapshotId': 'vol-12345678',
+                      'volumeSize': 1,
+                      'deleteOnTermination': True}}),
+
+            ({'device_name': '/dev/fake4',
+              'volume_id': 0x23456789},
+             {'deviceName': '/dev/fake4',
+              'ebs': {'snapshotId': 'vol-23456789'}}),
+
+            ({'device_name': '/dev/fake5',
+              'volume_id': 0x23456789,
+              'delete_on_termination': False},
+             {'deviceName': '/dev/fake5',
+              'ebs': {'snapshotId': 'vol-23456789',
+                      'deleteOnTermination': False}}),
+            ]
+        self._assertApply(cloud._format_block_device_mapping, bdm_list)
+
+    def test_format_mapping(self):
+        properties = {
+            'mappings': [
+                {'virtual': 'ami',
+                 'device': 'sda1'},
+                {'virtual': 'root',
+                 'device': '/dev/sda1'},
+
+                {'virtual': 'swap',
+                 'device': 'sdb1'},
+                {'virtual': 'swap',
+                 'device': 'sdb2'},
+                {'virtual': 'swap',
+                 'device': 'sdb3'},
+                {'virtual': 'swap',
+                 'device': 'sdb4'},
+
+                {'virtual': 'ephemeral0',
+                 'device': 'sdc1'},
+                {'virtual': 'ephemeral1',
+                 'device': 'sdc2'},
+                {'virtual': 'ephemeral2',
+                 'device': 'sdc3'},
+                ],
+
+            'block_device_mapping': [
+                # root
+                {'device_name': '/dev/sda1',
+                 'snapshot_id': 0x12345678,
+                 'delete_on_termination': False},
+
+
+                # overwrite swap
+                {'device_name': '/dev/sdb2',
+                 'snapshot_id': 0x23456789,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdb3',
+                 'snapshot_id': 0x3456789A},
+                {'device_name': '/dev/sdb4',
+                 'no_device': True},
+
+                # overwrite ephemeral
+                {'device_name': '/dev/sdc2',
+                 'snapshot_id': 0x3456789A,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdc3',
+                 'snapshot_id': 0x456789AB},
+                {'device_name': '/dev/sdc4',
+                 'no_device': True},
+
+                # volume
+                {'device_name': '/dev/sdd1',
+                 'snapshot_id': 0x87654321,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdd2',
+                 'snapshot_id': 0x98765432},
+                {'device_name': '/dev/sdd3',
+                 'snapshot_id': 0xA9875463},
+                {'device_name': '/dev/sdd4',
+                 'no_device': True}]}
+
+        expected_result = {
+            'blockDeviceMapping': [
+                # root
+                {'deviceName': '/dev/sda1',
+                 'ebs': {'snapshotId': 'snap-12345678',
+                         'deleteOnTermination': False}},
+
+                # swap
+                {'deviceName': '/dev/sdb1',
+                 'virtualName': 'swap'},
+                {'deviceName': '/dev/sdb2',
+                 'ebs': {'snapshotId': 'snap-23456789',
+                         'deleteOnTermination': False}},
+                {'deviceName': '/dev/sdb3',
+                 'ebs': {'snapshotId': 'snap-3456789a'}},
+
+                # ephemeral
+                {'deviceName': '/dev/sdc1',
+                 'virtualName': 'ephemeral0'},
+                {'deviceName': '/dev/sdc2',
+                 'ebs': {'snapshotId': 'snap-3456789a',
+                         'deleteOnTermination': False}},
+                {'deviceName': '/dev/sdc3',
+                 'ebs': {'snapshotId': 'snap-456789ab'}},
+
+                # volume
+                {'deviceName': '/dev/sdd1',
+                 'ebs': {'snapshotId': 'snap-87654321',
+                         'deleteOnTermination': False}},
+                {'deviceName': '/dev/sdd2',
+                 'ebs': {'snapshotId': 'snap-98765432'}},
+                {'deviceName': '/dev/sdd3',
+                 'ebs': {'snapshotId': 'snap-a9875463'}}]}
+
+        result = {}
+        cloud._format_mappings(properties, result)
+        print result
+        self.assertEqual(result['blockDeviceMapping'].sort(),
+                         expected_result['blockDeviceMapping'].sort())
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index d71a03aff..8cdc73a66 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -15,6 +15,7 @@
 #    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 mox
 
 from base64 import b64decode
 from M2Crypto import BIO
@@ -29,6 +30,7 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import network
 from nova import rpc
 from nova import test
 from nova import utils
@@ -45,7 +47,8 @@ LOG = logging.getLogger('nova.tests.cloud')
 class CloudTestCase(test.TestCase):
     def setUp(self):
         super(CloudTestCase, self).setUp()
-        self.flags(connection_type='fake')
+        self.flags(connection_type='fake',
+                   stub_network=True)
 
         self.conn = rpc.Connection.instance()
 
@@ -131,6 +134,33 @@ class CloudTestCase(test.TestCase):
                           allocate,
                           self.context)
 
+    def test_release_address(self):
+        address = "10.10.10.10"
+        allocate = self.cloud.allocate_address
+        db.floating_ip_create(self.context,
+                              {'address': address,
+                               'host': self.network.host})
+        result = self.cloud.release_address(self.context, address)
+        self.assertEqual(result['releaseResponse'], ['Address released.'])
+
+    def test_release_address_still_associated(self):
+        address = "10.10.10.10"
+        fixed_ip = {'instance': {'id': 1}}
+        floating_ip = {'id': 0,
+                       'address': address,
+                       'fixed_ip_id': 0,
+                       'fixed_ip': fixed_ip,
+                       'project_id': None,
+                       'auto_assigned': False}
+        network_api = network.api.API()
+        self.mox.StubOutWithMock(network_api.db, 'floating_ip_get_by_address')
+        network_api.db.floating_ip_get_by_address(mox.IgnoreArg(),
+                                mox.IgnoreArg()).AndReturn(floating_ip)
+        self.mox.ReplayAll()
+        release = self.cloud.release_address
+        # ApiError: Floating ip is in use.  Disassociate it before releasing.
+        self.assertRaises(exception.ApiError, release, self.context, address)
+
     @test.skip_test("Skipping this pending future merge")
     def test_associate_disassociate_address(self):
         """Verifies associate runs cleanly without raising an exception"""
@@ -290,7 +320,7 @@ class CloudTestCase(test.TestCase):
         vol2 = db.volume_create(self.context, {})
         result = self.cloud.describe_volumes(self.context)
         self.assertEqual(len(result['volumeSet']), 2)
-        volume_id = ec2utils.id_to_ec2_id(vol2['id'], 'vol-%08x')
+        volume_id = ec2utils.id_to_ec2_vol_id(vol2['id'])
         result = self.cloud.describe_volumes(self.context,
                                              volume_id=[volume_id])
         self.assertEqual(len(result['volumeSet']), 1)
@@ -306,7 +336,7 @@ class CloudTestCase(test.TestCase):
         snap = db.snapshot_create(self.context, {'volume_id': vol['id'],
                                                  'volume_size': vol['size'],
                                                  'status': "available"})
-        snapshot_id = ec2utils.id_to_ec2_id(snap['id'], 'snap-%08x')
+        snapshot_id = ec2utils.id_to_ec2_snap_id(snap['id'])
 
         result = self.cloud.create_volume(self.context,
                                           snapshot_id=snapshot_id)
@@ -345,7 +375,7 @@ class CloudTestCase(test.TestCase):
         snap2 = db.snapshot_create(self.context, {'volume_id': vol['id']})
         result = self.cloud.describe_snapshots(self.context)
         self.assertEqual(len(result['snapshotSet']), 2)
-        snapshot_id = ec2utils.id_to_ec2_id(snap2['id'], 'snap-%08x')
+        snapshot_id = ec2utils.id_to_ec2_snap_id(snap2['id'])
         result = self.cloud.describe_snapshots(self.context,
                                                snapshot_id=[snapshot_id])
         self.assertEqual(len(result['snapshotSet']), 1)
@@ -359,7 +389,7 @@ class CloudTestCase(test.TestCase):
     def test_create_snapshot(self):
         """Makes sure create_snapshot works."""
         vol = db.volume_create(self.context, {'status': "available"})
-        volume_id = ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x')
+        volume_id = ec2utils.id_to_ec2_vol_id(vol['id'])
 
         result = self.cloud.create_snapshot(self.context,
                                             volume_id=volume_id)
@@ -376,7 +406,7 @@ class CloudTestCase(test.TestCase):
         vol = db.volume_create(self.context, {'status': "available"})
         snap = db.snapshot_create(self.context, {'volume_id': vol['id'],
                                                   'status': "available"})
-        snapshot_id = ec2utils.id_to_ec2_id(snap['id'], 'snap-%08x')
+        snapshot_id = ec2utils.id_to_ec2_snap_id(snap['id'])
 
         result = self.cloud.delete_snapshot(self.context,
                                             snapshot_id=snapshot_id)
@@ -415,6 +445,185 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, comp1['id'])
         db.service_destroy(self.context, comp2['id'])
 
+    def _block_device_mapping_create(self, instance_id, mappings):
+        volumes = []
+        for bdm in mappings:
+            db.block_device_mapping_create(self.context, bdm)
+            if 'volume_id' in bdm:
+                values = {'id': bdm['volume_id']}
+                for bdm_key, vol_key in [('snapshot_id', 'snapshot_id'),
+                                         ('snapshot_size', 'volume_size'),
+                                         ('delete_on_termination',
+                                          'delete_on_termination')]:
+                    if bdm_key in bdm:
+                        values[vol_key] = bdm[bdm_key]
+                vol = db.volume_create(self.context, values)
+                db.volume_attached(self.context, vol['id'],
+                                   instance_id, bdm['device_name'])
+                volumes.append(vol)
+        return volumes
+
+    def _setUpBlockDeviceMapping(self):
+        inst1 = db.instance_create(self.context,
+                                  {'image_ref': 1,
+                                   'root_device_name': '/dev/sdb1'})
+        inst2 = db.instance_create(self.context,
+                                  {'image_ref': 2,
+                                   'root_device_name': '/dev/sdc1'})
+
+        instance_id = inst1['id']
+        mappings0 = [
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb1',
+             'snapshot_id': '1',
+             'volume_id': '2'},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb2',
+             'volume_id': '3',
+             'volume_size': 1},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb3',
+             'delete_on_termination': True,
+             'snapshot_id': '4',
+             'volume_id': '5'},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb4',
+             'delete_on_termination': False,
+             'snapshot_id': '6',
+             'volume_id': '7'},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb5',
+             'snapshot_id': '8',
+             'volume_id': '9',
+             'volume_size': 0},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb6',
+             'snapshot_id': '10',
+             'volume_id': '11',
+             'volume_size': 1},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb7',
+             'no_device': True},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb8',
+             'virtual_name': 'swap'},
+            {'instance_id': instance_id,
+             'device_name': '/dev/sdb9',
+             'virtual_name': 'ephemeral3'}]
+
+        volumes = self._block_device_mapping_create(instance_id, mappings0)
+        return (inst1, inst2, volumes)
+
+    def _tearDownBlockDeviceMapping(self, inst1, inst2, volumes):
+        for vol in volumes:
+            db.volume_destroy(self.context, vol['id'])
+        for id in (inst1['id'], inst2['id']):
+            for bdm in db.block_device_mapping_get_all_by_instance(
+                self.context, id):
+                db.block_device_mapping_destroy(self.context, bdm['id'])
+        db.instance_destroy(self.context, inst2['id'])
+        db.instance_destroy(self.context, inst1['id'])
+
+    _expected_instance_bdm1 = {
+        'instanceId': 'i-00000001',
+        'rootDeviceName': '/dev/sdb1',
+        'rootDeviceType': 'ebs'}
+
+    _expected_block_device_mapping0 = [
+        {'deviceName': '/dev/sdb1',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': False,
+                 'volumeId': 2,
+                 }},
+        {'deviceName': '/dev/sdb2',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': False,
+                 'volumeId': 3,
+                 }},
+        {'deviceName': '/dev/sdb3',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': True,
+                 'volumeId': 5,
+                 }},
+        {'deviceName': '/dev/sdb4',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': False,
+                 'volumeId': 7,
+                 }},
+        {'deviceName': '/dev/sdb5',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': False,
+                 'volumeId': 9,
+                 }},
+        {'deviceName': '/dev/sdb6',
+         'ebs': {'status': 'in-use',
+                 'deleteOnTermination': False,
+                 'volumeId': 11, }}]
+        # NOTE(yamahata): swap/ephemeral device case isn't supported yet.
+
+    _expected_instance_bdm2 = {
+        'instanceId': 'i-00000002',
+        'rootDeviceName': '/dev/sdc1',
+        'rootDeviceType': 'instance-store'}
+
+    def test_format_instance_bdm(self):
+        (inst1, inst2, volumes) = self._setUpBlockDeviceMapping()
+
+        result = {}
+        self.cloud._format_instance_bdm(self.context, inst1['id'], '/dev/sdb1',
+                                        result)
+        self.assertSubDictMatch(
+            {'rootDeviceType': self._expected_instance_bdm1['rootDeviceType']},
+            result)
+        self._assertEqualBlockDeviceMapping(
+            self._expected_block_device_mapping0, result['blockDeviceMapping'])
+
+        result = {}
+        self.cloud._format_instance_bdm(self.context, inst2['id'], '/dev/sdc1',
+                                        result)
+        self.assertSubDictMatch(
+            {'rootDeviceType': self._expected_instance_bdm2['rootDeviceType']},
+            result)
+
+        self._tearDownBlockDeviceMapping(inst1, inst2, volumes)
+
+    def _assertInstance(self, instance_id):
+        ec2_instance_id = ec2utils.id_to_ec2_id(instance_id)
+        result = self.cloud.describe_instances(self.context,
+                                               instance_id=[ec2_instance_id])
+        result = result['reservationSet'][0]
+        self.assertEqual(len(result['instancesSet']), 1)
+        result = result['instancesSet'][0]
+        self.assertEqual(result['instanceId'], ec2_instance_id)
+        return result
+
+    def _assertEqualBlockDeviceMapping(self, expected, result):
+        self.assertEqual(len(expected), len(result))
+        for x in expected:
+            found = False
+            for y in result:
+                if x['deviceName'] == y['deviceName']:
+                    self.assertSubDictMatch(x, y)
+                    found = True
+                    break
+            self.assertTrue(found)
+
+    def test_describe_instances_bdm(self):
+        """Make sure describe_instances works with root_device_name and
+        block device mappings
+        """
+        (inst1, inst2, volumes) = self._setUpBlockDeviceMapping()
+
+        result = self._assertInstance(inst1['id'])
+        self.assertSubDictMatch(self._expected_instance_bdm1, result)
+        self._assertEqualBlockDeviceMapping(
+            self._expected_block_device_mapping0, result['blockDeviceMapping'])
+
+        result = self._assertInstance(inst2['id'])
+        self.assertSubDictMatch(self._expected_instance_bdm2, result)
+
+        self._tearDownBlockDeviceMapping(inst1, inst2, volumes)
+
     def test_describe_images(self):
         describe_images = self.cloud.describe_images
 
@@ -445,6 +654,161 @@ class CloudTestCase(test.TestCase):
         self.assertRaises(exception.ImageNotFound, describe_images,
                           self.context, ['ami-fake'])
 
+    def assertDictListUnorderedMatch(self, L1, L2, key):
+        self.assertEqual(len(L1), len(L2))
+        for d1 in L1:
+            self.assertTrue(key in d1)
+            for d2 in L2:
+                self.assertTrue(key in d2)
+                if d1[key] == d2[key]:
+                    self.assertDictMatch(d1, d2)
+
+    def _setUpImageSet(self, create_volumes_and_snapshots=False):
+        mappings1 = [
+            {'device': '/dev/sda1', 'virtual': 'root'},
+
+            {'device': 'sdb0', 'virtual': 'ephemeral0'},
+            {'device': 'sdb1', 'virtual': 'ephemeral1'},
+            {'device': 'sdb2', 'virtual': 'ephemeral2'},
+            {'device': 'sdb3', 'virtual': 'ephemeral3'},
+            {'device': 'sdb4', 'virtual': 'ephemeral4'},
+
+            {'device': 'sdc0', 'virtual': 'swap'},
+            {'device': 'sdc1', 'virtual': 'swap'},
+            {'device': 'sdc2', 'virtual': 'swap'},
+            {'device': 'sdc3', 'virtual': 'swap'},
+            {'device': 'sdc4', 'virtual': 'swap'}]
+        block_device_mapping1 = [
+            {'device_name': '/dev/sdb1', 'snapshot_id': 01234567},
+            {'device_name': '/dev/sdb2', 'volume_id': 01234567},
+            {'device_name': '/dev/sdb3', 'virtual_name': 'ephemeral5'},
+            {'device_name': '/dev/sdb4', 'no_device': True},
+
+            {'device_name': '/dev/sdc1', 'snapshot_id': 12345678},
+            {'device_name': '/dev/sdc2', 'volume_id': 12345678},
+            {'device_name': '/dev/sdc3', 'virtual_name': 'ephemeral6'},
+            {'device_name': '/dev/sdc4', 'no_device': True}]
+        image1 = {
+            'id': 1,
+            'properties': {
+                'kernel_id': 1,
+                'type': 'machine',
+                'image_state': 'available',
+                'mappings': mappings1,
+                'block_device_mapping': block_device_mapping1,
+                }
+            }
+
+        mappings2 = [{'device': '/dev/sda1', 'virtual': 'root'}]
+        block_device_mapping2 = [{'device_name': '/dev/sdb1',
+                                  'snapshot_id': 01234567}]
+        image2 = {
+            'id': 2,
+            'properties': {
+                'kernel_id': 2,
+                'type': 'machine',
+                'root_device_name': '/dev/sdb1',
+                'mappings': mappings2,
+                'block_device_mapping': block_device_mapping2}}
+
+        def fake_show(meh, context, image_id):
+            for i in [image1, image2]:
+                if i['id'] == image_id:
+                    return i
+            raise exception.ImageNotFound(image_id=image_id)
+
+        def fake_detail(meh, context):
+            return [image1, image2]
+
+        self.stubs.Set(fake._FakeImageService, 'show', fake_show)
+        self.stubs.Set(fake._FakeImageService, 'detail', fake_detail)
+
+        volumes = []
+        snapshots = []
+        if create_volumes_and_snapshots:
+            for bdm in block_device_mapping1:
+                if 'volume_id' in bdm:
+                    vol = self._volume_create(bdm['volume_id'])
+                    volumes.append(vol['id'])
+                if 'snapshot_id' in bdm:
+                    snap = db.snapshot_create(self.context,
+                                              {'id': bdm['snapshot_id'],
+                                               'volume_id': 76543210,
+                                               'status': "available",
+                                               'volume_size': 1})
+                    snapshots.append(snap['id'])
+        return (volumes, snapshots)
+
+    def _assertImageSet(self, result, root_device_type, root_device_name):
+        self.assertEqual(1, len(result['imagesSet']))
+        result = result['imagesSet'][0]
+        self.assertTrue('rootDeviceType' in result)
+        self.assertEqual(result['rootDeviceType'], root_device_type)
+        self.assertTrue('rootDeviceName' in result)
+        self.assertEqual(result['rootDeviceName'], root_device_name)
+        self.assertTrue('blockDeviceMapping' in result)
+
+        return result
+
+    _expected_root_device_name1 = '/dev/sda1'
+    # NOTE(yamahata): noDevice doesn't make sense when returning mapping
+    #                 It makes sense only when user overriding existing
+    #                 mapping.
+    _expected_bdms1 = [
+        {'deviceName': '/dev/sdb0', 'virtualName': 'ephemeral0'},
+        {'deviceName': '/dev/sdb1', 'ebs': {'snapshotId':
+                                            'snap-00053977'}},
+        {'deviceName': '/dev/sdb2', 'ebs': {'snapshotId':
+                                            'vol-00053977'}},
+        {'deviceName': '/dev/sdb3', 'virtualName': 'ephemeral5'},
+        # {'deviceName': '/dev/sdb4', 'noDevice': True},
+
+        {'deviceName': '/dev/sdc0', 'virtualName': 'swap'},
+        {'deviceName': '/dev/sdc1', 'ebs': {'snapshotId':
+                                            'snap-00bc614e'}},
+        {'deviceName': '/dev/sdc2', 'ebs': {'snapshotId':
+                                            'vol-00bc614e'}},
+        {'deviceName': '/dev/sdc3', 'virtualName': 'ephemeral6'},
+        # {'deviceName': '/dev/sdc4', 'noDevice': True}
+        ]
+
+    _expected_root_device_name2 = '/dev/sdb1'
+    _expected_bdms2 = [{'deviceName': '/dev/sdb1',
+                       'ebs': {'snapshotId': 'snap-00053977'}}]
+
+    # NOTE(yamahata):
+    # InstanceBlockDeviceMappingItemType
+    # rootDeviceType
+    # rootDeviceName
+    # blockDeviceMapping
+    #  deviceName
+    #  virtualName
+    #  ebs
+    #    snapshotId
+    #    volumeSize
+    #    deleteOnTermination
+    #  noDevice
+    def test_describe_image_mapping(self):
+        """test for rootDeviceName and blockDeiceMapping"""
+        describe_images = self.cloud.describe_images
+        self._setUpImageSet()
+
+        result = describe_images(self.context, ['ami-00000001'])
+        result = self._assertImageSet(result, 'instance-store',
+                                      self._expected_root_device_name1)
+
+        self.assertDictListUnorderedMatch(result['blockDeviceMapping'],
+                                          self._expected_bdms1, 'deviceName')
+
+        result = describe_images(self.context, ['ami-00000002'])
+        result = self._assertImageSet(result, 'ebs',
+                                      self._expected_root_device_name2)
+
+        self.assertDictListUnorderedMatch(result['blockDeviceMapping'],
+                                          self._expected_bdms2, 'deviceName')
+
+        self.stubs.UnsetAll()
+
     def test_describe_image_attribute(self):
         describe_image_attribute = self.cloud.describe_image_attribute
 
@@ -459,6 +823,32 @@ class CloudTestCase(test.TestCase):
                                           'launchPermission')
         self.assertEqual([{'group': 'all'}], result['launchPermission'])
 
+    def test_describe_image_attribute_root_device_name(self):
+        describe_image_attribute = self.cloud.describe_image_attribute
+        self._setUpImageSet()
+
+        result = describe_image_attribute(self.context, 'ami-00000001',
+                                          'rootDeviceName')
+        self.assertEqual(result['rootDeviceName'],
+                         self._expected_root_device_name1)
+        result = describe_image_attribute(self.context, 'ami-00000002',
+                                          'rootDeviceName')
+        self.assertEqual(result['rootDeviceName'],
+                         self._expected_root_device_name2)
+
+    def test_describe_image_attribute_block_device_mapping(self):
+        describe_image_attribute = self.cloud.describe_image_attribute
+        self._setUpImageSet()
+
+        result = describe_image_attribute(self.context, 'ami-00000001',
+                                          'blockDeviceMapping')
+        self.assertDictListUnorderedMatch(result['blockDeviceMapping'],
+                                          self._expected_bdms1, 'deviceName')
+        result = describe_image_attribute(self.context, 'ami-00000002',
+                                          'blockDeviceMapping')
+        self.assertDictListUnorderedMatch(result['blockDeviceMapping'],
+                                          self._expected_bdms2, 'deviceName')
+
     def test_modify_image_attribute(self):
         modify_image_attribute = self.cloud.modify_image_attribute
 
@@ -699,7 +1089,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_display_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_vol_id(vol['id']),
                                  display_name='c00l v0lum3')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual('c00l v0lum3', vol['display_name'])
@@ -708,7 +1098,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_wont_update_private_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_vol_id(vol['id']),
                                  mountpoint='/not/here')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual(None, vol['mountpoint'])
@@ -786,11 +1176,13 @@ class CloudTestCase(test.TestCase):
 
         self._restart_compute_service()
 
-    def _volume_create(self):
+    def _volume_create(self, volume_id=None):
         kwargs = {'status': 'available',
                   'host': self.volume.host,
                   'size': 1,
                   'attach_status': 'detached', }
+        if volume_id:
+            kwargs['id'] = volume_id
         return db.volume_create(self.context, kwargs)
 
     def _assert_volume_attached(self, vol, instance_id, mountpoint):
@@ -819,10 +1211,10 @@ class CloudTestCase(test.TestCase):
                   'max_count': 1,
                   'block_device_mapping': [{'device_name': '/dev/vdb',
                                             'volume_id': vol1['id'],
-                                            'delete_on_termination': False, },
+                                            'delete_on_termination': False},
                                            {'device_name': '/dev/vdc',
                                             'volume_id': vol2['id'],
-                                            'delete_on_termination': True, },
+                                            'delete_on_termination': True},
                                            ]}
         ec2_instance_id = self._run_instance_wait(**kwargs)
         instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
@@ -954,7 +1346,7 @@ class CloudTestCase(test.TestCase):
     def test_run_with_snapshot(self):
         """Makes sure run/stop/start instance with snapshot works."""
         vol = self._volume_create()
-        ec2_volume_id = ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x')
+        ec2_volume_id = ec2utils.id_to_ec2_vol_id(vol['id'])
 
         ec2_snapshot1_id = self._create_snapshot(ec2_volume_id)
         snapshot1_id = ec2utils.ec2_id_to_id(ec2_snapshot1_id)
@@ -1013,3 +1405,33 @@ class CloudTestCase(test.TestCase):
             self.cloud.delete_snapshot(self.context, snapshot_id)
             greenthread.sleep(0.3)
         db.volume_destroy(self.context, vol['id'])
+
+    def test_create_image(self):
+        """Make sure that CreateImage works"""
+        # enforce periodic tasks run in short time to avoid wait for 60s.
+        self._restart_compute_service(periodic_interval=0.3)
+
+        (volumes, snapshots) = self._setUpImageSet(
+            create_volumes_and_snapshots=True)
+
+        kwargs = {'image_id': 'ami-1',
+                  'instance_type': FLAGS.default_instance_type,
+                  'max_count': 1}
+        ec2_instance_id = self._run_instance_wait(**kwargs)
+
+        # TODO(yamahata): s3._s3_create() can't be tested easily by unit test
+        #                 as there is no unit test for s3.create()
+        ## result = self.cloud.create_image(self.context, ec2_instance_id,
+        ##                                  no_reboot=True)
+        ## ec2_image_id = result['imageId']
+        ## created_image = self.cloud.describe_images(self.context,
+        ##                                            [ec2_image_id])
+
+        self.cloud.terminate_instances(self.context, [ec2_instance_id])
+        for vol in volumes:
+            db.volume_destroy(self.context, vol)
+        for snap in snapshots:
+            db.snapshot_destroy(self.context, snap)
+        # TODO(yamahata): clean up snapshot created by CreateImage.
+
+        self._restart_compute_service()
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 04bb194d5..5d59b628a 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -424,11 +424,12 @@ class ComputeTestCase(test.TestCase):
         self.stubs.Set(self.compute.network_api, 'get_instance_nw_info', fake)
         context = self.context.elevated()
         instance_id = self._create_instance()
-        self.compute.prep_resize(context, instance_id, 1)
+        instance_ref = db.instance_get(context, instance_id)
+        self.compute.prep_resize(context, instance_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
+                instance_ref['uuid'], 'pre-migrating')
         try:
-            self.compute.finish_resize(context, instance_id,
+            self.compute.finish_resize(context, instance_ref['uuid'],
                     int(migration_ref['id']), {})
         except KeyError, e:
             # Only catch key errors. We want other reasons for the test to
@@ -441,14 +442,15 @@ class ComputeTestCase(test.TestCase):
         """Ensure notifications on instance migrate/resize"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+        inst_ref = db.instance_get(context, instance_id)
 
         self.compute.run_instance(self.context, instance_id)
         test_notifier.NOTIFICATIONS = []
 
         db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id, 1)
+        self.compute.prep_resize(context, inst_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
+                inst_ref['uuid'], 'pre-migrating')
 
         self.assertEquals(len(test_notifier.NOTIFICATIONS), 1)
         msg = test_notifier.NOTIFICATIONS[0]
@@ -471,13 +473,15 @@ class ComputeTestCase(test.TestCase):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
         context = self.context.elevated()
+        inst_ref = db.instance_get(context, instance_id)
 
         self.compute.run_instance(self.context, instance_id)
-        db.instance_update(self.context, instance_id, {'host': 'foo'})
-        self.compute.prep_resize(context, instance_id, 1)
+        db.instance_update(self.context, inst_ref['uuid'],
+                           {'host': 'foo'})
+        self.compute.prep_resize(context, inst_ref['uuid'], 1)
         migration_ref = db.migration_get_by_instance_and_status(context,
-                instance_id, 'pre-migrating')
-        self.compute.resize_instance(context, instance_id,
+                inst_ref['uuid'], 'pre-migrating')
+        self.compute.resize_instance(context, inst_ref['uuid'],
                 migration_ref['id'])
         self.compute.terminate_instance(context, instance_id)
 
@@ -519,6 +523,57 @@ class ComputeTestCase(test.TestCase):
 
         self.compute.terminate_instance(context, instance_id)
 
+    def test_finish_revert_resize(self):
+        """Ensure that the flavor is reverted to the original on revert"""
+        context = self.context.elevated()
+        instance_id = self._create_instance()
+
+        def fake(*args, **kwargs):
+            pass
+
+        self.stubs.Set(self.compute.driver, 'finish_resize', fake)
+        self.stubs.Set(self.compute.driver, 'revert_resize', fake)
+        self.stubs.Set(self.compute.network_api, 'get_instance_nw_info', fake)
+
+        self.compute.run_instance(self.context, instance_id)
+
+        # Confirm the instance size before the resize starts
+        inst_ref = db.instance_get(context, instance_id)
+        instance_type_ref = db.instance_type_get(context,
+                inst_ref['instance_type_id'])
+        self.assertEqual(instance_type_ref['flavorid'], 1)
+
+        db.instance_update(self.context, instance_id, {'host': 'foo'})
+
+        self.compute.prep_resize(context, inst_ref['uuid'], 3)
+
+        migration_ref = db.migration_get_by_instance_and_status(context,
+                inst_ref['uuid'], 'pre-migrating')
+
+        self.compute.resize_instance(context, inst_ref['uuid'],
+                migration_ref['id'])
+        self.compute.finish_resize(context, inst_ref['uuid'],
+                    int(migration_ref['id']), {})
+
+        # Prove that the instance size is now the new size
+        inst_ref = db.instance_get(context, instance_id)
+        instance_type_ref = db.instance_type_get(context,
+                inst_ref['instance_type_id'])
+        self.assertEqual(instance_type_ref['flavorid'], 3)
+
+        # Finally, revert and confirm the old flavor has been applied
+        self.compute.revert_resize(context, inst_ref['uuid'],
+                migration_ref['id'])
+        self.compute.finish_revert_resize(context, inst_ref['uuid'],
+                migration_ref['id'])
+
+        inst_ref = db.instance_get(context, instance_id)
+        instance_type_ref = db.instance_type_get(context,
+                inst_ref['instance_type_id'])
+        self.assertEqual(instance_type_ref['flavorid'], 1)
+
+        self.compute.terminate_instance(context, instance_id)
+
     def test_get_by_flavor_id(self):
         type = instance_types.get_instance_type_by_flavor_id(1)
         self.assertEqual(type['name'], 'm1.tiny')
@@ -818,3 +873,114 @@ class ComputeTestCase(test.TestCase):
         LOG.info(_("After force-killing instances: %s"), instances)
         self.assertEqual(len(instances), 1)
         self.assertEqual(power_state.SHUTOFF, instances[0]['state'])
+
+    @staticmethod
+    def _parse_db_block_device_mapping(bdm_ref):
+        attr_list = ('delete_on_termination', 'device_name', 'no_device',
+                     'virtual_name', 'volume_id', 'volume_size', 'snapshot_id')
+        bdm = {}
+        for attr in attr_list:
+            val = bdm_ref.get(attr, None)
+            if val:
+                bdm[attr] = val
+
+        return bdm
+
+    def test_update_block_device_mapping(self):
+        instance_id = self._create_instance()
+        mappings = [
+                {'virtual': 'ami', 'device': 'sda1'},
+                {'virtual': 'root', 'device': '/dev/sda1'},
+
+                {'virtual': 'swap', 'device': 'sdb1'},
+                {'virtual': 'swap', 'device': 'sdb2'},
+                {'virtual': 'swap', 'device': 'sdb3'},
+                {'virtual': 'swap', 'device': 'sdb4'},
+
+                {'virtual': 'ephemeral0', 'device': 'sdc1'},
+                {'virtual': 'ephemeral1', 'device': 'sdc2'},
+                {'virtual': 'ephemeral2', 'device': 'sdc3'}]
+        block_device_mapping = [
+                # root
+                {'device_name': '/dev/sda1',
+                 'snapshot_id': 0x12345678,
+                 'delete_on_termination': False},
+
+
+                # overwrite swap
+                {'device_name': '/dev/sdb2',
+                 'snapshot_id': 0x23456789,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdb3',
+                 'snapshot_id': 0x3456789A},
+                {'device_name': '/dev/sdb4',
+                 'no_device': True},
+
+                # overwrite ephemeral
+                {'device_name': '/dev/sdc2',
+                 'snapshot_id': 0x456789AB,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdc3',
+                 'snapshot_id': 0x56789ABC},
+                {'device_name': '/dev/sdc4',
+                 'no_device': True},
+
+                # volume
+                {'device_name': '/dev/sdd1',
+                 'snapshot_id': 0x87654321,
+                 'delete_on_termination': False},
+                {'device_name': '/dev/sdd2',
+                 'snapshot_id': 0x98765432},
+                {'device_name': '/dev/sdd3',
+                 'snapshot_id': 0xA9875463},
+                {'device_name': '/dev/sdd4',
+                 'no_device': True}]
+
+        self.compute_api._update_image_block_device_mapping(
+            self.context, 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': 'ephemeral0', 'device_name': '/dev/sdc1'},
+            {'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)
+        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'},
+            {'snapshot_id': 0x23456789, 'device_name': '/dev/sdb2'},
+            {'snapshot_id': 0x3456789A, 'device_name': '/dev/sdb3'},
+            {'no_device': True, 'device_name': '/dev/sdb4'},
+
+            {'virtual_name': 'ephemeral0', 'device_name': '/dev/sdc1'},
+            {'snapshot_id': 0x456789AB, 'device_name': '/dev/sdc2'},
+            {'snapshot_id': 0x56789ABC, 'device_name': '/dev/sdc3'},
+            {'no_device': True, 'device_name': '/dev/sdc4'},
+
+            {'snapshot_id': 0x87654321, 'device_name': '/dev/sdd1'},
+            {'snapshot_id': 0x98765432, 'device_name': '/dev/sdd2'},
+            {'snapshot_id': 0xA9875463, 'device_name': '/dev/sdd3'},
+            {'no_device': True, 'device_name': '/dev/sdd4'}]
+        bdms.sort()
+        expected_result.sort()
+        self.assertDictListMatch(bdms, expected_result)
+
+        for bdm in db.block_device_mapping_get_all_by_instance(
+            self.context, instance_id):
+            db.block_device_mapping_destroy(self.context, bdm['id'])
+        self.compute.terminate_instance(self.context, instance_id)
diff --git a/nova/tests/test_instance_types_extra_specs.py b/nova/tests/test_instance_types_extra_specs.py
index c26cf82ff..393ed1e36 100644
--- a/nova/tests/test_instance_types_extra_specs.py
+++ b/nova/tests/test_instance_types_extra_specs.py
@@ -105,8 +105,8 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                               self.instance_type_id)
         self.assertEquals(expected_specs, actual_specs)
 
-    def test_instance_type_get_by_id_with_extra_specs(self):
-        instance_type = db.api.instance_type_get_by_id(
+    def test_instance_type_get_with_extra_specs(self):
+        instance_type = db.api.instance_type_get(
                             context.get_admin_context(),
                             self.instance_type_id)
         self.assertEquals(instance_type['extra_specs'],
@@ -115,7 +115,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                                xpu_arch="fermi",
                                xpus="2",
                                xpu_model="Tesla 2050"))
-        instance_type = db.api.instance_type_get_by_id(
+        instance_type = db.api.instance_type_get(
                             context.get_admin_context(),
                             5)
         self.assertEquals(instance_type['extra_specs'], {})
@@ -136,7 +136,7 @@ class InstanceTypeExtraSpecsTestCase(test.TestCase):
                             "m1.small")
         self.assertEquals(instance_type['extra_specs'], {})
 
-    def test_instance_type_get_by_id_with_extra_specs(self):
+    def test_instance_type_get_with_extra_specs(self):
         instance_type = db.api.instance_type_get_by_flavor_id(
                             context.get_admin_context(),
                             105)
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index f99e1713d..6e2ec7ed6 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -58,6 +58,7 @@ def _create_network_info(count=1, ipv6=None):
                'cidr': fake_ip,
                'cidr_v6': fake_ip}
     mapping = {'mac': fake,
+               'dhcp_server': fake,
                'gateway': fake,
                'gateway6': fake,
                'ips': [{'ip': fake_ip}, {'ip': fake_ip}]}
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b09021e13..d30c5e9e5 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -45,6 +45,7 @@ class FakeModel(dict):
 networks = [{'id': 0,
              'label': 'test0',
              'injected': False,
+             'multi_host': False,
              'cidr': '192.168.0.0/24',
              'cidr_v6': '2001:db8::/64',
              'gateway_v6': '2001:db8::1',
@@ -62,6 +63,7 @@ networks = [{'id': 0,
             {'id': 1,
              'label': 'test1',
              'injected': False,
+             'multi_host': False,
              'cidr': '192.168.1.0/24',
              'cidr_v6': '2001:db9::/64',
              'gateway_v6': '2001:db9::1',
@@ -122,34 +124,20 @@ class FlatNetworkTestCase(test.TestCase):
         self.network = network_manager.FlatManager(host=HOST)
         self.network.db = db
 
-    def test_set_network_hosts(self):
-        self.mox.StubOutWithMock(db, 'network_get_all')
-        self.mox.StubOutWithMock(db, 'network_set_host')
-        self.mox.StubOutWithMock(db, 'network_update')
-
-        db.network_get_all(mox.IgnoreArg()).AndReturn([networks[0]])
-        db.network_set_host(mox.IgnoreArg(),
-                            networks[0]['id'],
-                            mox.IgnoreArg()).AndReturn(HOST)
-        db.network_update(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg())
-        self.mox.ReplayAll()
-
-        self.network.set_network_hosts(None)
-
     def test_get_instance_nw_info(self):
         self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
         self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
-        self.mox.StubOutWithMock(db, 'instance_type_get_by_id')
+        self.mox.StubOutWithMock(db, 'instance_type_get')
 
         db.fixed_ip_get_by_instance(mox.IgnoreArg(),
                                     mox.IgnoreArg()).AndReturn(fixed_ips)
         db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                              mox.IgnoreArg()).AndReturn(vifs)
-        db.instance_type_get_by_id(mox.IgnoreArg(),
+        db.instance_type_get(mox.IgnoreArg(),
                                    mox.IgnoreArg()).AndReturn(flavor)
         self.mox.ReplayAll()
 
-        nw_info = self.network.get_instance_nw_info(None, 0, 0)
+        nw_info = self.network.get_instance_nw_info(None, 0, 0, None)
 
         self.assertTrue(nw_info)
 
@@ -164,6 +152,7 @@ class FlatNetworkTestCase(test.TestCase):
             self.assertDictMatch(nw[0], check)
 
             check = {'broadcast': '192.168.%s.255' % i,
+                     'dhcp_server': '192.168.%s.1' % i,
                      'dns': 'DONTCARE',
                      'gateway': '192.168.%s.1' % i,
                      'gateway6': '2001:db%s::1' % i8,
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index 62cc4b325..c0f89601f 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -27,8 +27,10 @@ from nova import exception
 from nova import db
 from nova import flags
 from nova import log as logging
+from nova import rpc
 from nova import test
 from nova import utils
+from nova import volume
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.volume')
@@ -43,6 +45,11 @@ class VolumeTestCase(test.TestCase):
         self.flags(connection_type='fake')
         self.volume = utils.import_object(FLAGS.volume_manager)
         self.context = context.get_admin_context()
+        self.instance_id = db.instance_create(self.context, {})['id']
+
+    def tearDown(self):
+        db.instance_destroy(self.context, self.instance_id)
+        super(VolumeTestCase, self).tearDown()
 
     @staticmethod
     def _create_volume(size='0', snapshot_id=None):
@@ -223,6 +230,30 @@ class VolumeTestCase(test.TestCase):
                           snapshot_id)
         self.volume.delete_volume(self.context, volume_id)
 
+    def test_create_snapshot_force(self):
+        """Test snapshot in use can be created forcibly."""
+
+        def fake_cast(ctxt, topic, msg):
+            pass
+        self.stubs.Set(rpc, 'cast', fake_cast)
+
+        volume_id = self._create_volume()
+        self.volume.create_volume(self.context, volume_id)
+        db.volume_attached(self.context, volume_id, self.instance_id,
+                           '/dev/sda1')
+
+        volume_api = volume.api.API()
+        self.assertRaises(exception.ApiError,
+                          volume_api.create_snapshot,
+                          self.context, volume_id,
+                          'fake_name', 'fake_description')
+        snapshot_ref = volume_api.create_snapshot_force(self.context,
+                                                        volume_id,
+                                                        'fake_name',
+                                                        'fake_description')
+        db.snapshot_destroy(self.context, snapshot_ref['id'])
+        db.volume_destroy(self.context, volume_id)
+
 
 class DriverTestCase(test.TestCase):
     """Base Test class for Drivers."""
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 977bb7dfe..342dea98f 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -881,9 +881,12 @@ class LibvirtConnection(driver.ComputeDriver):
             address = mapping['ips'][0]['ip']
             netmask = mapping['ips'][0]['netmask']
             address_v6 = None
+            gateway_v6 = None
+            netmask_v6 = None
             if FLAGS.use_ipv6:
                 address_v6 = mapping['ip6s'][0]['ip']
                 netmask_v6 = mapping['ip6s'][0]['netmask']
+                gateway_v6 = mapping['gateway6']
             net_info = {'name': 'eth%d' % ifc_num,
                    'address': address,
                    'netmask': netmask,
@@ -891,7 +894,7 @@ class LibvirtConnection(driver.ComputeDriver):
                    'broadcast': mapping['broadcast'],
                    'dns': mapping['dns'],
                    'address_v6': address_v6,
-                   'gateway6': mapping['gateway6'],
+                   'gateway6': gateway_v6,
                    'netmask_v6': netmask_v6}
             nets.append(net_info)
 
@@ -928,7 +931,6 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def _get_nic_for_xml(self, network, mapping):
         # Assume that the gateway also acts as the dhcp server.
-        dhcp_server = mapping['gateway']
         gateway6 = mapping.get('gateway6')
         mac_id = mapping['mac'].replace(':', '')
 
@@ -951,7 +953,7 @@ class LibvirtConnection(driver.ComputeDriver):
             'bridge_name': network['bridge'],
             'mac_address': mapping['mac'],
             'ip_address': mapping['ips'][0]['ip'],
-            'dhcp_server': dhcp_server,
+            'dhcp_server': mapping['dhcp_server'],
             'extra_params': extra_params,
         }
 
@@ -1014,10 +1016,9 @@ class LibvirtConnection(driver.ComputeDriver):
                     'ebs_root': ebs_root,
                     'volumes': block_device_mapping}
 
-        if FLAGS.vnc_enabled:
-            if FLAGS.libvirt_type != 'lxc' or FLAGS.libvirt_type != 'uml':
-                xml_info['vncserver_host'] = FLAGS.vncserver_host
-                xml_info['vnc_keymap'] = FLAGS.vnc_keymap
+        if FLAGS.vnc_enabled and FLAGS.libvirt_type not in ('lxc', 'uml'):
+            xml_info['vncserver_host'] = FLAGS.vncserver_host
+            xml_info['vnc_keymap'] = FLAGS.vnc_keymap
         if not rescue:
             if instance['kernel_id']:
                 xml_info['kernel'] = xml_info['basepath'] + "/kernel"
diff --git a/nova/virt/libvirt/netutils.py b/nova/virt/libvirt/netutils.py
index e5aaf7cec..8d36c0a05 100644
--- a/nova/virt/libvirt/netutils.py
+++ b/nova/virt/libvirt/netutils.py
@@ -59,7 +59,7 @@ def get_network_info(instance):
     vifs = db.virtual_interface_get_by_instance(admin_context, instance['id'])
     networks = db.network_get_all_by_instance(admin_context,
                                               instance['id'])
-    flavor = db.instance_type_get_by_id(admin_context,
+    flavor = db.instance_type_get(admin_context,
                                         instance['instance_type_id'])
     network_info = []
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index c332c27b0..7995576a6 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -340,6 +340,7 @@ class VMOps(object):
                     _check_agent_version()
                     _inject_files()
                     _set_admin_password()
+                    self.reset_network(instance, vm_ref)
                     return True
             except Exception, exc:
                 LOG.warn(exc)
@@ -349,9 +350,6 @@ class VMOps(object):
 
         timer.f = _wait_for_boot
 
-        # call to reset network to configure network from xenstore
-        self.reset_network(instance, vm_ref)
-
         return timer.start(interval=0.5, now=True)
 
     def _handle_spawn_error(self, vdis, spawn_error):
diff --git a/nova/volume/api.py b/nova/volume/api.py
index 7d27abff9..cfc274c77 100644
--- a/nova/volume/api.py
+++ b/nova/volume/api.py
@@ -140,9 +140,10 @@ class API(base.Base):
                  {"method": "remove_volume",
                   "args": {'volume_id': volume_id}})
 
-    def create_snapshot(self, context, volume_id, name, description):
+    def _create_snapshot(self, context, volume_id, name, description,
+                         force=False):
         volume = self.get(context, volume_id)
-        if volume['status'] != "available":
+        if ((not force) and (volume['status'] != "available")):
             raise exception.ApiError(_("Volume status must be available"))
 
         options = {
@@ -164,6 +165,14 @@ class API(base.Base):
                            "snapshot_id": snapshot['id']}})
         return snapshot
 
+    def create_snapshot(self, context, volume_id, name, description):
+        return self._create_snapshot(context, volume_id, name, description,
+                                     False)
+
+    def create_snapshot_force(self, context, volume_id, name, description):
+        return self._create_snapshot(context, volume_id, name, description,
+                                     True)
+
     def delete_snapshot(self, context, snapshot_id):
         snapshot = self.get_snapshot(context, snapshot_id)
         if snapshot['status'] != "available":