Fixes euca-describe-instances failing or not showing IPs

Fixes bug 855660

Makes EC2 call network manager to get IP information now, to match the
same change to OS API
Also refactors a bit of OS API's calls... moving some code into 'common'

Fixed tests.  Some tests for OS API v1.0 were not properly testing.

Fixed imports per HACKING in files touched.

Change-Id: I455637a9feb802291dfaf2ef694dabc2607784f9

12 files changed, 443 insertions, 280 deletions

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index a71ab8cf0..a6a10c767 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -238,14 +238,58 @@ class CloudController(object):
             utils.runthis(_("Generating root CA: %s"), "sh", genrootca_sh_path)
             os.chdir(start)
 
+    def _get_floaters_for_fixed_ip(self, context, fixed_ip):
+        """Return all floating IPs given a fixed IP"""
+        return self.network_api.get_floating_ips_by_fixed_address(context,
+                fixed_ip)
+
+    def _get_fixed_ips_for_instance(self, context, instance):
+        """Return a list of all fixed IPs for an instance"""
+
+        ret_ips = []
+        ret_ip6s = []
+        nw_info = self.network_api.get_instance_nw_info(context, instance)
+        for net, info in nw_info:
+            if not info:
+                continue
+            ips = info.get('ips', [])
+            for ip in ips:
+                try:
+                    ret_ips.append(ip['ip'])
+                except KeyError:
+                    pass
+            if FLAGS.use_ipv6:
+                ip6s = info.get('ip6s', [])
+                for ip6 in ip6s:
+                    try:
+                        ret_ip6s.append(ip6['ip'])
+                    except KeyError:
+                        pass
+        return (ret_ips, ret_ip6s)
+
+    def _get_floaters_for_instance(self, context, instance, return_all=True):
+        """Return all floating IPs for an instance"""
+
+        ret_floaters = []
+        fixed_ips = self._get_fixed_ips_for_instance(context, instance)
+        for ip in fixed_ips:
+            floaters = self._get_floaters_for_fixed_ip(context, ip)
+            # Allows a short circuit if we just need any floater.
+            if floaters and not return_all:
+                return floaters
+            ret_floaters.extend(floaters)
+            if floaters and only_one:
+                return ret_floaters
+        return ret_floaters
+
     def _get_mpi_data(self, context, project_id):
         result = {}
         search_opts = {'project_id': project_id}
         for instance in self.compute_api.get_all(context,
                 search_opts=search_opts):
-            if instance['fixed_ips']:
-                line = '%s slots=%d' % (instance['fixed_ips'][0]['address'],
-                                        instance['vcpus'])
+            fixed_ips = self._get_fixed_ips_for_instance(context, instance)[0]
+            if fixed_ips:
+                line = '%s slots=%d' % (fixed_ips[0], instance['vcpus'])
                 key = str(instance['key_name'])
                 if key in result:
                     result[key].append(line)
@@ -331,8 +375,11 @@ class CloudController(object):
         hostname = "%s.%s" % (instance_ref['hostname'], FLAGS.dhcp_domain)
         host = instance_ref['host']
         availability_zone = self._get_availability_zone_by_host(ctxt, host)
-        floating_ip = db.instance_get_floating_address(ctxt,
-                                                       instance_ref['id'])
+
+        floaters = self._get_floaters_for_instance(ctxt, instance_ref,
+                return_all=False)
+        floating_ip = floaters and floaters[0] or ''
+
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
         image_ec2_id = self.image_ec2_id(instance_ref['image_ref'])
         security_groups = db.security_group_get_by_instance(ctxt,
@@ -354,7 +401,7 @@ class CloudController(object):
                 'local-ipv4': address,
                 'placement': {'availability-zone': availability_zone},
                 'public-hostname': hostname,
-                'public-ipv4': floating_ip or '',
+                'public-ipv4': floating_ip,
                 'reservation-id': instance_ref['reservation_id'],
                 'security-groups': security_groups,
                 'mpi': mpi}}
@@ -1257,23 +1304,27 @@ class CloudController(object):
             i['instanceState'] = {
                 'code': instance['power_state'],
                 'name': state_description_from_vm_state(instance['vm_state'])}
-            fixed_addr = None
-            floating_addr = None
-            if instance['fixed_ips']:
-                fixed = instance['fixed_ips'][0]
-                fixed_addr = fixed['address']
-                if fixed['floating_ips']:
-                    floating_addr = fixed['floating_ips'][0]['address']
-                if fixed['network'] and use_v6:
-                    i['dnsNameV6'] = ipv6.to_global(
-                        fixed['network']['cidr_v6'],
-                        fixed['virtual_interface']['address'],
-                        instance['project_id'])
-
-            i['privateDnsName'] = fixed_addr
-            i['privateIpAddress'] = fixed_addr
-            i['publicDnsName'] = floating_addr
-            i['ipAddress'] = floating_addr or fixed_addr
+
+            fixed_ip = None
+            floating_ip = None
+            (fixed_ips, fixed_ip6s) = self._get_fixed_ips_for_instance(context,
+                    instance)
+            if fixed_ips:
+                fixed_ip = fixed_ips[0]
+                # Now look for a floater.
+                for ip in fixed_ips:
+                    floating_ips = self._get_floaters_for_fixed_ip(context, ip)
+                    # NOTE(comstud): Will it float?
+                    if floating_ips:
+                        floating_ip = floating_ips[0]
+                        # Got one, exit out.
+                        break
+            if fixed_ip6s:
+                i['dnsNameV6'] = fixed_ip6s[0]
+            i['privateDnsName'] = fixed_ip
+            i['privateIpAddress'] = fixed_ip
+            i['publicDnsName'] = floating_ip
+            i['ipAddress'] = floating_ip or fixed_ip
             i['dnsName'] = i['publicDnsName'] or i['privateDnsName']
             i['keyName'] = instance['key_name']
 
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index 726ec4612..bf5d415d5 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -19,18 +19,18 @@ import functools
 from lxml import etree
 import re
 import urlparse
-from xml.dom import minidom
-
 import webob
+from xml.dom import minidom
 
-from nova import exception
-from nova import flags
-from nova import log as logging
-from nova import quota
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
 from nova.compute import vm_states
 from nova.compute import task_states
+from nova import exception
+from nova import flags
+from nova import log as logging
+import nova.network
+from nova import quota
 
 
 LOG = logging.getLogger('nova.api.openstack.common')
@@ -272,6 +272,55 @@ def dict_to_query_str(params):
     return param_str.rstrip('&')
 
 
+def get_networks_for_instance(context, instance):
+    """Returns a prepared nw_info list for passing into the view
+    builders
+
+    We end up with a datastructure like:
+    {'public': {'ips': [{'addr': '10.0.0.1', 'version': 4},
+                        {'addr': '2001::1', 'version': 6}],
+                'floating_ips': [{'addr': '172.16.0.1', 'version': 4},
+                                 {'addr': '172.16.2.1', 'version': 4}]},
+     ...}
+    """
+
+    network_api = nova.network.API()
+
+    def _get_floats(ip):
+        return network_api.get_floating_ips_by_fixed_address(context, ip)
+
+    def _emit_addr(ip, version):
+        return {'addr': ip, 'version': version}
+
+    nw_info = network_api.get_instance_nw_info(context, instance)
+
+    networks = {}
+    for net, info in nw_info:
+        if not info:
+            continue
+        try:
+            network = {'ips': []}
+            network['floating_ips'] = []
+            for ip in info['ips']:
+                network['ips'].append(_emit_addr(ip['ip'], 4))
+                floats = [_emit_addr(addr, 4)
+                        for addr in _get_floats(ip['ip'])]
+                network['floating_ips'].extend(floats)
+            if FLAGS.use_ipv6 and 'ip6s' in info:
+                network['ips'].extend([_emit_addr(ip['ip'], 6)
+                        for ip in info['ip6s']])
+        # NOTE(comstud): These exception checks are for lp830817
+        # (Restoring them after a refactoring removed)
+        except TypeError:
+            raise
+            continue
+        except KeyError:
+            raise
+            continue
+        networks[info['label']] = network
+    return networks
+
+
 class MetadataXMLDeserializer(wsgi.XMLDeserializer):
 
     def extract_metadata(self, metadata_node):
diff --git a/nova/api/openstack/ips.py b/nova/api/openstack/ips.py
index 49aa81958..db0b7107b 100644
--- a/nova/api/openstack/ips.py
+++ b/nova/api/openstack/ips.py
@@ -20,11 +20,12 @@ from lxml import etree
 from webob import exc
 
 import nova
-import nova.api.openstack.views.addresses
-from nova import log as logging
-from nova import flags
+from nova.api.openstack import common
+from nova.api.openstack.views import addresses as views_addresses
 from nova.api.openstack import wsgi
 from nova.api.openstack import xmlutil
+from nova import log as logging
+from nova import flags
 
 
 LOG = logging.getLogger('nova.api.openstack.ips')
@@ -36,7 +37,6 @@ class Controller(object):
 
     def __init__(self):
         self.compute_api = nova.compute.API()
-        self.network_api = nova.network.API()
 
     def _get_instance(self, context, server_id):
         try:
@@ -58,16 +58,14 @@ class ControllerV10(Controller):
     def index(self, req, server_id):
         context = req.environ['nova.context']
         instance = self._get_instance(context, server_id)
-        networks = _get_networks_for_instance(context, self.network_api,
-                                              instance)
-        builder = nova.api.openstack.views.addresses.ViewBuilderV10()
+        networks = common.get_networks_for_instance(context, instance)
+        builder = self._get_view_builder(req)
         return {'addresses': builder.build(networks)}
 
     def show(self, req, server_id, id):
         context = req.environ['nova.context']
         instance = self._get_instance(context, server_id)
-        networks = _get_networks_for_instance(context, self.network_api,
-                                              instance)
+        networks = common.get_networks_for_instance(context, instance)
         builder = self._get_view_builder(req)
         if id == 'private':
             view = builder.build_private_parts(networks)
@@ -80,7 +78,7 @@ class ControllerV10(Controller):
         return {id: view}
 
     def _get_view_builder(self, req):
-        return nova.api.openstack.views.addresses.ViewBuilderV10()
+        return views_addresses.ViewBuilderV10()
 
 
 class ControllerV11(Controller):
@@ -88,16 +86,13 @@ class ControllerV11(Controller):
     def index(self, req, server_id):
         context = req.environ['nova.context']
         instance = self._get_instance(context, server_id)
-        networks = _get_networks_for_instance(context, self.network_api,
-                                              instance)
+        networks = common.get_networks_for_instance(context, instance)
         return {'addresses': self._get_view_builder(req).build(networks)}
 
     def show(self, req, server_id, id):
         context = req.environ['nova.context']
         instance = self._get_instance(context, server_id)
-        networks = _get_networks_for_instance(context, self.network_api,
-                                              instance)
-
+        networks = common.get_networks_for_instance(context, instance)
         network = self._get_view_builder(req).build_network(networks, id)
 
         if network is None:
@@ -107,7 +102,7 @@ class ControllerV11(Controller):
         return network
 
     def _get_view_builder(self, req):
-        return nova.api.openstack.views.addresses.ViewBuilderV11()
+        return views_addresses.ViewBuilderV11()
 
 
 class IPXMLSerializer(wsgi.XMLDictSerializer):
@@ -143,45 +138,6 @@ class IPXMLSerializer(wsgi.XMLDictSerializer):
         return self._to_xml(addresses)
 
 
-def _get_networks_for_instance(context, network_api, instance):
-    """Returns a prepared nw_info list for passing into the view
-    builders
-
-    We end up with a datastructure like:
-    {'public': {'ips': [{'addr': '10.0.0.1', 'version': 4},
-                        {'addr': '2001::1', 'version': 6}],
-                'floating_ips': [{'addr': '172.16.0.1', 'version': 4},
-                                 {'addr': '172.16.2.1', 'version': 4}]},
-     ...}
-    """
-    def _get_floats(ip):
-        return network_api.get_floating_ips_by_fixed_address(context, ip)
-
-    def _emit_addr(ip, version):
-        return {'addr': ip, 'version': version}
-
-    if FLAGS.stub_network:
-        return {}
-
-    nw_info = network_api.get_instance_nw_info(context, instance)
-
-    networks = {}
-    for net, info in nw_info:
-        network = {'ips': []}
-        network['floating_ips'] = []
-        if 'ip6s' in info:
-            network['ips'].extend([_emit_addr(ip['ip'],
-                                              6) for ip in info['ip6s']])
-
-        for ip in info['ips']:
-            network['ips'].append(_emit_addr(ip['ip'], 4))
-            floats = [_emit_addr(addr,
-                                 4) for addr in _get_floats(ip['ip'])]
-            network['floating_ips'].extend(floats)
-        networks[info['label']] = network
-    return networks
-
-
 def create_resource(version):
     controller = {
         '1.0': ControllerV10,
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index de081343e..673294e1a 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -24,27 +24,27 @@ from webob import exc
 import webob
 from xml.dom import minidom
 
+import nova.api.openstack
+from nova.api.openstack import common
+from nova.api.openstack import ips
+from nova.api.openstack.views import addresses as views_addresses
+from nova.api.openstack.views import flavors as views_flavors
+from nova.api.openstack.views import images as views_images
+from nova.api.openstack.views import servers as views_servers
+from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 from nova import compute
+from nova.compute import instance_types
 from nova import network
 from nova import db
 from nova import exception
 from nova import flags
 from nova import image
 from nova import log as logging
-from nova import utils
 from nova import quota
-from nova.api.openstack import common
-from nova.api.openstack import ips
-from nova.api.openstack import wsgi
-from nova.compute import instance_types
-from nova.scheduler import api as scheduler_api
-import nova.api.openstack
-import nova.api.openstack.views.addresses
-import nova.api.openstack.views.flavors
-import nova.api.openstack.views.images
-import nova.api.openstack.views.servers
-from nova.api.openstack import xmlutil
 from nova.rpc import common as rpc_common
+from nova.scheduler import api as scheduler_api
+from nova import utils
 
 
 LOG = logging.getLogger('nova.api.openstack.servers')
@@ -117,11 +117,6 @@ class Controller(object):
         """
         return None
 
-    def _get_networks_for_instance(self, req, instance):
-        return ips._get_networks_for_instance(req.environ['nova.context'],
-                                              self.network_api,
-                                              instance)
-
     def _get_block_device_mapping(self, data):
         """Get block_device_mapping from 'server' dictionary.
         Overidden by volumes controller.
@@ -984,17 +979,16 @@ class ControllerV10(Controller):
         return data['server']['flavorId']
 
     def _build_view(self, req, instance, is_detail=False):
-        addresses = nova.api.openstack.views.addresses.ViewBuilderV10()
-        builder = nova.api.openstack.views.servers.ViewBuilderV10(addresses)
-        networks = self._get_networks_for_instance(req, instance)
-        return builder.build(instance, networks, is_detail=is_detail)
+        context = req.environ['nova.context']
+        addresses = views_addresses.ViewBuilderV10()
+        builder = views_servers.ViewBuilderV10(context, addresses)
+        return builder.build(instance, is_detail=is_detail)
 
     def _build_list(self, req, instances, is_detail=False):
-        addresses = nova.api.openstack.views.addresses.ViewBuilderV10()
-        builder = nova.api.openstack.views.servers.ViewBuilderV10(addresses)
-        get_nw = self._get_networks_for_instance
-        inst_data = [(inst, get_nw(req, inst)) for inst in instances]
-        return builder.build_list(inst_data, is_detail=is_detail)
+        context = req.environ['nova.context']
+        addresses = views_addresses.ViewBuilderV10()
+        builder = views_servers.ViewBuilderV10(context, addresses)
+        return builder.build_list(instances, is_detail=is_detail)
 
     def _limit_items(self, items, req):
         return common.limited(items, req)
@@ -1081,18 +1075,15 @@ class ControllerV11(Controller):
         return common.get_id_from_href(flavor_ref)
 
     def _build_view(self, req, instance, is_detail=False):
-        project_id = getattr(req.environ['nova.context'], 'project_id', '')
+        context = req.environ['nova.context']
+        project_id = getattr(context, 'project_id', '')
         base_url = req.application_url
-        flavor_builder = nova.api.openstack.views.flavors.ViewBuilderV11(
-            base_url, project_id)
-        image_builder = nova.api.openstack.views.images.ViewBuilderV11(
-            base_url, project_id)
-        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
-        builder = nova.api.openstack.views.servers.ViewBuilderV11(
-            addresses_builder, flavor_builder, image_builder,
-            base_url, project_id)
-        networks = self._get_networks_for_instance(req, instance)
-        return builder.build(instance, networks, is_detail=is_detail)
+        flavor_builder = views_flavors.ViewBuilderV11(base_url, project_id)
+        image_builder = views_images.ViewBuilderV11(base_url, project_id)
+        addresses_builder = views_addresses.ViewBuilderV11()
+        builder = views_servers.ViewBuilderV11(context, addresses_builder,
+                flavor_builder, image_builder, base_url, project_id)
+        return builder.build(instance, is_detail=is_detail)
 
     def _build_list(self, req, instances, is_detail=False):
         params = req.GET.copy()
@@ -1101,19 +1092,15 @@ class ControllerV11(Controller):
         for key, val in pagination_params.iteritems():
             params[key] = val
 
-        project_id = getattr(req.environ['nova.context'], 'project_id', '')
+        context = req.environ['nova.context']
+        project_id = getattr(context, 'project_id', '')
         base_url = req.application_url
-        flavor_builder = nova.api.openstack.views.flavors.ViewBuilderV11(
-            base_url, project_id)
-        image_builder = nova.api.openstack.views.images.ViewBuilderV11(
-            base_url, project_id)
-        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
-        builder = nova.api.openstack.views.servers.ViewBuilderV11(
-            addresses_builder, flavor_builder, image_builder,
-            base_url, project_id)
-        get_nw = self._get_networks_for_instance
-        inst_data = [(inst, get_nw(req, inst)) for inst in instances]
-        return builder.build_list(inst_data, is_detail=is_detail, **params)
+        flavor_builder = views_flavors.ViewBuilderV11(base_url, project_id)
+        image_builder = views_images.ViewBuilderV11(base_url, project_id)
+        addresses_builder = views_addresses.ViewBuilderV11()
+        builder = views_servers.ViewBuilderV11(context, addresses_builder,
+                flavor_builder, image_builder, base_url, project_id)
+        return builder.build_list(instances, is_detail=is_detail, **params)
 
     def _action_change_password(self, input_dict, req, id):
         context = req.environ['nova.context']
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 127a50c78..646cf12ca 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -19,11 +19,11 @@
 import hashlib
 import os
 
+from nova.api.openstack import common
+from nova.compute import vm_states
 from nova import exception
 from nova import log as logging
 from nova import utils
-from nova.api.openstack import common
-from nova.compute import vm_states
 
 
 LOG = logging.getLogger('nova.api.openstack.views.servers')
@@ -37,16 +37,17 @@ class ViewBuilder(object):
 
     """
 
-    def __init__(self, addresses_builder):
+    def __init__(self, context, addresses_builder):
+        self.context = context
         self.addresses_builder = addresses_builder
 
-    def build(self, inst, networks, is_detail=False):
+    def build(self, inst, is_detail=False):
         """Return a dict that represenst a server."""
         if inst.get('_is_precooked', False):
             server = dict(server=inst)
         else:
             if is_detail:
-                server = self._build_detail(inst, networks)
+                server = self._build_detail(inst)
             else:
                 server = self._build_simple(inst)
 
@@ -59,9 +60,8 @@ class ViewBuilder(object):
         servers = []
         servers_links = []
 
-        for server_obj, networks in server_objs:
-            servers.append(self.build(server_obj, networks,
-                                      is_detail)['server'])
+        for server_obj in server_objs:
+            servers.append(self.build(server_obj, is_detail)['server'])
 
         return dict(servers=servers)
 
@@ -69,7 +69,7 @@ class ViewBuilder(object):
         """Return a simple model of a server."""
         return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
-    def _build_detail(self, inst, networks):
+    def _build_detail(self, inst):
         """Returns a detailed model of a server."""
         vm_state = inst.get('vm_state', vm_states.BUILDING)
         task_state = inst.get('task_state')
@@ -93,6 +93,7 @@ class ViewBuilder(object):
 
         self._build_image(inst_dict, inst)
         self._build_flavor(inst_dict, inst)
+        networks = common.get_networks_for_instance(self.context, inst)
         self._build_addresses(inst_dict, networks)
 
         return dict(server=inst_dict)
@@ -133,16 +134,16 @@ class ViewBuilderV10(ViewBuilder):
 
 class ViewBuilderV11(ViewBuilder):
     """Model an Openstack API V1.0 server response."""
-    def __init__(self, addresses_builder, flavor_builder, image_builder,
-                 base_url, project_id=""):
-        ViewBuilder.__init__(self, addresses_builder)
+    def __init__(self, context, addresses_builder, flavor_builder,
+            image_builder, base_url, project_id=""):
+        super(ViewBuilderV11, self).__init__(context, addresses_builder)
         self.flavor_builder = flavor_builder
         self.image_builder = image_builder
         self.base_url = base_url
         self.project_id = project_id
 
-    def _build_detail(self, inst, network):
-        response = super(ViewBuilderV11, self)._build_detail(inst, network)
+    def _build_detail(self, inst):
+        response = super(ViewBuilderV11, self)._build_detail(inst)
         response['server']['created'] = utils.isotime(inst['created_at'])
         response['server']['updated'] = utils.isotime(inst['updated_at'])
 
@@ -214,9 +215,8 @@ class ViewBuilderV11(ViewBuilder):
         servers = []
         servers_links = []
 
-        for server_obj, networks in server_objs:
-            servers.append(self.build(server_obj, networks,
-                                      is_detail)['server'])
+        for server_obj in server_objs:
+            servers.append(self.build(server_obj, is_detail)['server'])
 
         if (len(servers) and limit) and (limit == len(servers)):
             next_link = self.generate_next_link(servers[-1]['id'],
diff --git a/nova/network/api.py b/nova/network/api.py
index 9bcf474a6..70de04569 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -18,11 +18,12 @@
 
 """Handles all requests relating to instances (guest vms)."""
 
+from nova.db import base
 from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import rpc
-from nova.db import base
+from nova.rpc import common as rpc_common
 
 
 FLAGS = flags.FLAGS
@@ -205,9 +206,25 @@ class API(base.Base):
         args = {'instance_id': instance['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})
+        try:
+            return rpc.call(context, FLAGS.network_topic,
+                    {'method': 'get_instance_nw_info',
+                    'args': args})
+        # FIXME(comstud) rpc calls raise RemoteError if the remote raises
+        # an exception.  In the case here, because of a race condition,
+        # it's possible the remote will raise a InstanceNotFound when
+        # someone deletes the instance while this call is in progress.
+        #
+        # Unfortunately, we don't have access to the original exception
+        # class now.. but we do have the exception class's name.  So,
+        # we're checking it here and raising a new exception.
+        #
+        # Ultimately we need RPC to be able to serialize more things like
+        # classes.
+        except rpc_common.RemoteError as err:
+            if err.exc_type == 'InstanceNotFound':
+                raise exception.InstanceNotFound(instance_id=instance['id'])
+            raise
 
     def validate_networks(self, context, requested_networks):
         """validate the networks passed at the time of creating
diff --git a/nova/tests/api/ec2/test_cloud.py b/nova/tests/api/ec2/test_cloud.py
index 8c58b1f47..7053ebab7 100644
--- a/nova/tests/api/ec2/test_cloud.py
+++ b/nova/tests/api/ec2/test_cloud.py
@@ -505,12 +505,30 @@ class CloudTestCase(test.TestCase):
 
     def test_describe_instances(self):
         """Makes sure describe_instances works and filters results."""
+        self.flags(use_ipv6=True)
+
+        def fake_get_instance_nw_info(self, context, instance):
+            return [(None, {'label': 'public',
+                            'ips': [{'ip': '192.168.0.3'},
+                                    {'ip': '192.168.0.4'}],
+                            'ip6s': [{'ip': 'fe80::beef'}]})]
+
+        def fake_get_floating_ips_by_fixed_address(self, context, fixed_ip):
+            return ['1.2.3.4', '5.6.7.8']
+
+        self.stubs.Set(network.API, 'get_instance_nw_info',
+                fake_get_instance_nw_info)
+        self.stubs.Set(network.API, 'get_floating_ips_by_fixed_address',
+                fake_get_floating_ips_by_fixed_address)
+
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
                                                   'image_ref': 1,
+                                                  'instance_type_id': 1,
                                                   'host': 'host1',
                                                   'vm_state': 'active'})
         inst2 = db.instance_create(self.context, {'reservation_id': 'a',
                                                   'image_ref': 1,
+                                                  'instance_type_id': 1,
                                                   'host': 'host2',
                                                   'vm_state': 'active'})
         comp1 = db.service_create(self.context, {'host': 'host1',
@@ -522,28 +540,77 @@ class CloudTestCase(test.TestCase):
         result = self.cloud.describe_instances(self.context)
         result = result['reservationSet'][0]
         self.assertEqual(len(result['instancesSet']), 2)
+
+        # Now try filtering.
         instance_id = ec2utils.id_to_ec2_id(inst2['id'])
         result = self.cloud.describe_instances(self.context,
                                              instance_id=[instance_id])
         result = result['reservationSet'][0]
         self.assertEqual(len(result['instancesSet']), 1)
-        self.assertEqual(result['instancesSet'][0]['instanceId'],
-                         instance_id)
-        self.assertEqual(result['instancesSet'][0]
-                         ['placement']['availabilityZone'], 'zone2')
+        instance = result['instancesSet'][0]
+        self.assertEqual(instance['instanceId'], instance_id)
+        self.assertEqual(instance['placement']['availabilityZone'],
+                'zone2')
+        self.assertEqual(instance['publicDnsName'], '1.2.3.4')
+        self.assertEqual(instance['ipAddress'], '1.2.3.4')
+        self.assertEqual(instance['dnsName'], '1.2.3.4')
+        self.assertEqual(instance['privateDnsName'], '192.168.0.3')
+        self.assertEqual(instance['privateIpAddress'], '192.168.0.3')
+        self.assertEqual(instance['dnsNameV6'], 'fe80::beef')
         db.instance_destroy(self.context, inst1['id'])
         db.instance_destroy(self.context, inst2['id'])
         db.service_destroy(self.context, comp1['id'])
         db.service_destroy(self.context, comp2['id'])
 
+    def test_describe_instances_no_ipv6(self):
+        """Makes sure describe_instances w/ no ipv6 works."""
+        self.flags(use_ipv6=False)
+
+        def fake_get_instance_nw_info(self, context, instance):
+            return [(None, {'label': 'public',
+                            'ips': [{'ip': '192.168.0.3'},
+                                    {'ip': '192.168.0.4'}],
+                            'ip6s': [{'ip': 'fe80::beef'}]})]
+
+        def fake_get_floating_ips_by_fixed_address(self, context, fixed_ip):
+            return ['1.2.3.4', '5.6.7.8']
+
+        self.stubs.Set(network.API, 'get_instance_nw_info',
+                fake_get_instance_nw_info)
+        self.stubs.Set(network.API, 'get_floating_ips_by_fixed_address',
+                fake_get_floating_ips_by_fixed_address)
+
+        inst1 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_ref': 1,
+                                                  'instance_type_id': 1,
+                                                  'vm_state': 'active'})
+        comp1 = db.service_create(self.context, {'host': 'host1',
+                                                 'topic': "compute"})
+        result = self.cloud.describe_instances(self.context)
+        result = result['reservationSet'][0]
+        self.assertEqual(len(result['instancesSet']), 1)
+        instance = result['instancesSet'][0]
+        instance_id = ec2utils.id_to_ec2_id(inst1['id'])
+        self.assertEqual(instance['instanceId'], instance_id)
+        self.assertEqual(instance['publicDnsName'], '1.2.3.4')
+        self.assertEqual(instance['ipAddress'], '1.2.3.4')
+        self.assertEqual(instance['dnsName'], '1.2.3.4')
+        self.assertEqual(instance['privateDnsName'], '192.168.0.3')
+        self.assertEqual(instance['privateIpAddress'], '192.168.0.3')
+        self.assertNotIn('dnsNameV6', instance)
+        db.instance_destroy(self.context, inst1['id'])
+        db.service_destroy(self.context, comp1['id'])
+
     def test_describe_instances_deleted(self):
         args1 = {'reservation_id': 'a',
                  'image_ref': 1,
+                 'instance_type_id': 1,
                  'host': 'host1',
                  'vm_state': 'active'}
         inst1 = db.instance_create(self.context, args1)
         args2 = {'reservation_id': 'b',
                  'image_ref': 1,
+                 'instance_type_id': 1,
                  'host': 'host1',
                  'vm_state': 'active'}
         inst2 = db.instance_create(self.context, args2)
@@ -575,9 +642,11 @@ class CloudTestCase(test.TestCase):
     def _setUpBlockDeviceMapping(self):
         inst1 = db.instance_create(self.context,
                                   {'image_ref': 1,
+                                   'instance_type_id': 1,
                                    'root_device_name': '/dev/sdb1'})
         inst2 = db.instance_create(self.context,
                                   {'image_ref': 2,
+                                   'instance_type_id': 1,
                                    'root_device_name': '/dev/sdc1'})
 
         instance_id = inst1['id']
diff --git a/nova/tests/api/openstack/contrib/test_volumes.py b/nova/tests/api/openstack/contrib/test_volumes.py
index 9a24b9a54..e911c5ffb 100644
--- a/nova/tests/api/openstack/contrib/test_volumes.py
+++ b/nova/tests/api/openstack/contrib/test_volumes.py
@@ -49,16 +49,6 @@ def fake_compute_api_create(cls, context, instance_type, image_href, **kwargs):
              }], resv_id)
 
 
-def fake_get_instance_nw_info(cls, context, instance):
-    return [(None, {'label': 'public',
-                    'ips': [{'ip': '10.0.0.1'}],
-                    'ip6s': []})]
-
-
-def fake_get_floating_ips_by_fixed_address(self, context, fixed_ip):
-    return ['172.16.0.1']
-
-
 class BootFromVolumeTest(test.TestCase):
 
     def setUp(self):
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index 767e95165..e0176c9a3 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -190,19 +190,23 @@ def stub_out_nw_api_get_floating_ips_by_fixed_address(stubs, func=None):
     stubs.Set(nova.network.API, 'get_floating_ips_by_fixed_address', func)
 
 
-def stub_out_nw_api(stubs, cls=None):
+def stub_out_nw_api(stubs, cls=None, private=None, publics=None):
+    if not private:
+        private = '192.168.0.3'
+    if not publics:
+        publics = ['1.2.3.4']
+
     class Fake:
         def get_instance_nw_info(*args, **kwargs):
-            pass
+            return [(None, {'label': 'private',
+                            'ips': [{'ip': private}]})]
 
         def get_floating_ips_by_fixed_address(*args, **kwargs):
-            pass
+            return publics
 
     if cls is None:
         cls = Fake
     stubs.Set(nova.network, 'API', cls)
-    stub_out_nw_api_get_floating_ips_by_fixed_address(stubs)
-    stub_out_nw_api_get_instance_nw_info(stubs)
 
 
 def _make_image_fixtures():
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 97eb1da05..de0631bc8 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -77,13 +77,6 @@ def return_server_with_attributes(**kwargs):
     return _return_server
 
 
-def return_server_with_addresses(private, public):
-    def _return_server(context, id):
-        return stub_instance(id, private_address=private,
-                             public_addresses=public)
-    return _return_server
-
-
 def return_server_with_state(vm_state, task_state=None):
     def _return_server(context, id):
         return stub_instance(id, vm_state=vm_state, task_state=task_state)
@@ -143,23 +136,16 @@ def instance_addresses(context, instance_id):
     return None
 
 
-def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
-                  public_addresses=None, host=None,
+def stub_instance(id, user_id='fake', project_id='fake', host=None,
                   vm_state=None, task_state=None,
                   reservation_id="", uuid=FAKE_UUID, image_ref="10",
-                  flavor_id="1", interfaces=None, name=None, key_name='',
+                  flavor_id="1", name=None, key_name='',
                   access_ipv4=None, access_ipv6=None, progress=0):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
-    if interfaces is None:
-        interfaces = []
-
     inst_type = instance_types.get_instance_type_by_flavor_id(int(flavor_id))
 
-    if public_addresses is None:
-        public_addresses = list()
-
     if host is not None:
         host = str(host)
 
@@ -208,13 +194,8 @@ def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
         "access_ip_v4": access_ipv4,
         "access_ip_v6": access_ipv6,
         "uuid": uuid,
-        "virtual_interfaces": interfaces,
         "progress": progress}
 
-    instance["fixed_ips"] = {
-        "address": private_address,
-        "floating_ips": [{"address":ip} for ip in public_addresses]}
-
     return instance
 
 
@@ -704,10 +685,10 @@ class ServersTest(test.TestCase):
         self.assertDictMatch(res_dict, expected_server)
 
     def test_get_server_by_id_with_addresses_xml(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1')
         req.headers['Accept'] = 'application/xml'
         res = req.get_response(fakes.wsgi_app())
@@ -716,84 +697,83 @@ class ServersTest(test.TestCase):
         self.assertEquals(server.nodeName, 'server')
         self.assertEquals(server.getAttribute('id'), '1')
         self.assertEquals(server.getAttribute('name'), 'server1')
-        (public,) = server.getElementsByTagName('public')
-        (ip,) = public.getElementsByTagName('ip')
-        self.assertEquals(ip.getAttribute('addr'), '1.2.3.4')
-        (private,) = server.getElementsByTagName('private')
-        (ip,) = private.getElementsByTagName('ip')
-        self.assertEquals(ip.getAttribute('addr'), '192.168.0.3')
+        (public_elem,) = server.getElementsByTagName('public')
+        (ip,) = public_elem.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), publics[0])
+        (private_elem,) = server.getElementsByTagName('private')
+        (ip,) = private_elem.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), private)
 
     def test_get_server_by_id_with_addresses(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/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']
-        self.assertEqual(len(addresses["public"]), len(public))
-        self.assertEqual(addresses["public"][0], public[0])
+        self.assertEqual(len(addresses["public"]), len(publics))
+        self.assertEqual(addresses["public"][0], publics[0])
         self.assertEqual(len(addresses["private"]), 1)
         self.assertEqual(addresses["private"][0], private)
 
     def test_get_server_addresses_v1_0(self):
-        private = '192.168.0.3'
-        public = ['1.2.3.4']
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict, {
-            'addresses': {'public': public, 'private': [private]}})
+            'addresses': {'public': publics, 'private': [private]}})
 
     def test_get_server_addresses_xml_v1_0(self):
-        private_expected = "192.168.0.3"
-        public_expected = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private_expected,
-                                                         public_expected)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips')
         req.headers['Accept'] = 'application/xml'
         res = req.get_response(fakes.wsgi_app())
         dom = minidom.parseString(res.body)
         (addresses,) = dom.childNodes
         self.assertEquals(addresses.nodeName, 'addresses')
-        (public,) = addresses.getElementsByTagName('public')
-        (ip,) = public.getElementsByTagName('ip')
-        self.assertEquals(ip.getAttribute('addr'), public_expected[0])
-        (private,) = addresses.getElementsByTagName('private')
-        (ip,) = private.getElementsByTagName('ip')
-        self.assertEquals(ip.getAttribute('addr'), private_expected)
+        (public_elem,) = addresses.getElementsByTagName('public')
+        (ip,) = public_elem.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), publics[0])
+        (private_elem,) = addresses.getElementsByTagName('private')
+        (ip,) = private_elem.getElementsByTagName('ip')
+        self.assertEquals(ip.getAttribute('addr'), private)
 
     def test_get_server_addresses_public_v1_0(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips/public')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
-        self.assertEqual(res_dict, {'public': public})
+        self.assertEqual(res_dict, {'public': publics})
 
     def test_get_server_addresses_private_v1_0(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips/private')
         res = req.get_response(fakes.wsgi_app())
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict, {'private': [private]})
 
     def test_get_server_addresses_public_xml_v1_0(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips/public')
         req.headers['Accept'] = 'application/xml'
         res = req.get_response(fakes.wsgi_app())
@@ -801,13 +781,13 @@ class ServersTest(test.TestCase):
         (public_node,) = dom.childNodes
         self.assertEquals(public_node.nodeName, 'public')
         (ip,) = public_node.getElementsByTagName('ip')
-        self.assertEquals(ip.getAttribute('addr'), public[0])
+        self.assertEquals(ip.getAttribute('addr'), publics[0])
 
     def test_get_server_addresses_private_xml_v1_0(self):
-        private = "192.168.0.3"
-        public = ["1.2.3.4"]
-        new_return_server = return_server_with_addresses(private, public)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+        private = '192.168.1.2'
+        publics = ['1.2.3.4']
+        fakes.stub_out_nw_api(self.stubs, private=private, publics=publics)
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
         req = webob.Request.blank('/v1.0/servers/1/ips/private')
         req.headers['Accept'] = 'application/xml'
         res = req.get_response(fakes.wsgi_app())
@@ -819,17 +799,20 @@ class ServersTest(test.TestCase):
 
     # NOTE(bcwaldon): lp830817
     def test_get_server_by_id_malformed_networks_v1_1(self):
-        ifaces = [
-            {
-                'network': None,
-                'fixed_ips': [
-                    {'address': '192.168.0.3'},
-                    {'address': '192.168.0.4'},
-                ],
-            },
-        ]
-        new_return_server = return_server_with_attributes(interfaces=ifaces)
-        self.stubs.Set(nova.db.api, 'instance_get', new_return_server)
+
+        nw_info = [(None, None), (None, None)]
+
+        def get_nw_info(*args, **kwargs):
+            return nw_info
+
+        def get_floats(self, context, fixed_ip):
+            return []
+
+        fakes.stub_out_nw_api_get_instance_nw_info(self.stubs, get_nw_info)
+        fakes.stub_out_nw_api_get_floating_ips_by_fixed_address(self.stubs,
+                                                                get_floats)
+
+        self.stubs.Set(nova.db.api, 'instance_get', return_server_by_id)
 
         req = webob.Request.blank('/v1.1/fake/servers/1')
         res = req.get_response(fakes.wsgi_app())
@@ -2678,7 +2661,7 @@ class ServersTest(test.TestCase):
         '''
 
         def return_servers_with_host(context, *args, **kwargs):
-            return [stub_instance(i, 'fake', 'fake', None, None, i % 2)
+            return [stub_instance(i, 'fake', 'fake', i % 2)
                     for i in xrange(5)]
 
         self.stubs.Set(nova.db.api, 'instance_get_all_by_filters',
@@ -3959,11 +3942,29 @@ class TestGetKernelRamdiskFromImage(test.TestCase):
 class ServersViewBuilderV11Test(test.TestCase):
 
     def setUp(self):
+        super(ServersViewBuilderV11Test, self).setUp()
+        self.flags(use_ipv6=True)
         self.instance = self._get_instance()
         self.view_builder = self._get_view_builder()
 
-    def tearDown(self):
-        pass
+        public_ip = '192.168.0.3'
+        private_ip = '172.19.0.1'
+
+        nw_info = [(None, {'label': 'public',
+                           'ips': [{'ip': public_ip}],
+                           'ip6s': [{'ip': 'fe80::beef'}]}),
+                   (None, {'label': 'private',
+                           'ips': [{'ip': private_ip}]})]
+
+        def get_nw_info(*args, **kwargs):
+            return nw_info
+
+        def get_floats(self, context, fixed_ip):
+            return []
+
+        fakes.stub_out_nw_api_get_instance_nw_info(self.stubs, get_nw_info)
+        fakes.stub_out_nw_api_get_floating_ips_by_fixed_address(self.stubs,
+                                                                get_floats)
 
     def _get_instance(self):
         created_at = datetime.datetime(2010, 10, 10, 12, 0, 0)
@@ -4017,13 +4018,14 @@ class ServersViewBuilderV11Test(test.TestCase):
         flavor_builder = views.flavors.ViewBuilderV11(base_url, project_id)
         image_builder = views.images.ViewBuilderV11(base_url, project_id)
 
+        ctxt = context.RequestContext('fake_user', project_id)
         view_builder = nova.api.openstack.views.servers.ViewBuilderV11(
-            address_builder,
-            flavor_builder,
-            image_builder,
-            base_url,
-            project_id,
-        )
+                ctxt,
+                address_builder,
+                flavor_builder,
+                image_builder,
+                base_url,
+                project_id)
         return view_builder
 
     def test_build_server(self):
@@ -4045,7 +4047,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, False)
+        output = self.view_builder.build(self.instance, False)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_with_project_id(self):
@@ -4068,7 +4070,7 @@ class ServersViewBuilderV11Test(test.TestCase):
         }
 
         view_builder = self._get_view_builder(project_id='fake')
-        output = view_builder.build(self.instance, {}, False)
+        output = view_builder.build(self.instance, False)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_detail(self):
@@ -4107,7 +4109,12 @@ class ServersViewBuilderV11Test(test.TestCase):
                       },
                   ],
                 },
-                "addresses": {},
+                "addresses": {'private': [
+                                {'version': 4, 'addr': '172.19.0.1'}],
+                              'public': [
+                                {'version': 4, 'addr': '192.168.0.3'},
+                                {'version': 6, 'addr': 'fe80::beef'}]
+                             },
                 "metadata": {},
                 "config_drive": None,
                 "links": [
@@ -4123,7 +4130,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, True)
+        output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_detail_active_status(self):
@@ -4165,7 +4172,12 @@ class ServersViewBuilderV11Test(test.TestCase):
                       },
                   ],
                 },
-                "addresses": {},
+                "addresses": {'private': [
+                                {'version': 4, 'addr': '172.19.0.1'}],
+                              'public': [
+                                {'version': 4, 'addr': '192.168.0.3'},
+                                {'version': 6, 'addr': 'fe80::beef'}]
+                             },
                 "metadata": {},
                 "config_drive": None,
                 "links": [
@@ -4181,7 +4193,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, True)
+        output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_detail_with_accessipv4(self):
@@ -4221,7 +4233,12 @@ class ServersViewBuilderV11Test(test.TestCase):
                         },
                     ],
                 },
-                "addresses": {},
+                "addresses": {'private': [
+                                {'version': 4, 'addr': '172.19.0.1'}],
+                              'public': [
+                                {'version': 4, 'addr': '192.168.0.3'},
+                                {'version': 6, 'addr': 'fe80::beef'}]
+                             },
                 "metadata": {},
                 "config_drive": None,
                 "accessIPv4": "1.2.3.4",
@@ -4239,7 +4256,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, True)
+        output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_detail_with_accessipv6(self):
@@ -4279,7 +4296,12 @@ class ServersViewBuilderV11Test(test.TestCase):
                         },
                     ],
                 },
-                "addresses": {},
+                "addresses": {'private': [
+                                {'version': 4, 'addr': '172.19.0.1'}],
+                              'public': [
+                                {'version': 4, 'addr': '192.168.0.3'},
+                                {'version': 6, 'addr': 'fe80::beef'}]
+                             },
                 "metadata": {},
                 "config_drive": None,
                 "accessIPv4": "",
@@ -4297,7 +4319,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, True)
+        output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
     def test_build_server_detail_with_metadata(self):
@@ -4342,7 +4364,12 @@ class ServersViewBuilderV11Test(test.TestCase):
                         },
                     ],
                 },
-                "addresses": {},
+                "addresses": {'private': [
+                                {'version': 4, 'addr': '172.19.0.1'}],
+                              'public': [
+                                {'version': 4, 'addr': '192.168.0.3'},
+                                {'version': 6, 'addr': 'fe80::beef'}]
+                             },
                 "metadata": {
                     "Open": "Stack",
                     "Number": "1",
@@ -4361,7 +4388,7 @@ class ServersViewBuilderV11Test(test.TestCase):
             }
         }
 
-        output = self.view_builder.build(self.instance, {}, True)
+        output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
 
diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py
index 4bfad93b1..94138526c 100644
--- a/nova/tests/integrated/test_servers.py
+++ b/nova/tests/integrated/test_servers.py
@@ -31,7 +31,6 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
     def _wait_for_state_change(self, server, status):
         for i in xrange(0, 50):
             server = self.api.get_server(server['id'])
-            print server
             if server['status'] != status:
                 break
             time.sleep(.1)
diff --git a/nova/tests/test_metadata.py b/nova/tests/test_metadata.py
index 03f22d9e1..e4c5af897 100644
--- a/nova/tests/test_metadata.py
+++ b/nova/tests/test_metadata.py
@@ -19,14 +19,14 @@
 """Tests for the testing the metadata code."""
 
 import base64
-
 import webob
 
+from nova.api.ec2 import metadatarequesthandler
+from nova.db.sqlalchemy import api
 from nova import exception
 from nova import flags
+from nova import network
 from nova import test
-from nova.api.ec2 import metadatarequesthandler
-from nova.db.sqlalchemy import api
 from nova.tests import fake_network
 
 
@@ -55,10 +55,20 @@ class MetadataTestCase(test.TestCase):
                          'reservation_id': 'r-xxxxxxxx',
                          'user_data': '',
                          'image_ref': 7,
+                         'vcpus': 1,
                          'fixed_ips': [],
                          'root_device_name': '/dev/sda1',
                          'hostname': 'test'})
 
+        def fake_get_instance_nw_info(self, context, instance):
+            return [(None, {'label': 'public',
+                            'ips': [{'ip': '192.168.0.3'},
+                                    {'ip': '192.168.0.4'}],
+                            'ip6s': [{'ip': 'fe80::beef'}]})]
+
+        def fake_get_floating_ips_by_fixed_address(self, context, fixed_ip):
+            return ['1.2.3.4', '5.6.7.8']
+
         def instance_get(*args, **kwargs):
             return self.instance
 
@@ -68,6 +78,10 @@ class MetadataTestCase(test.TestCase):
         def floating_get(*args, **kwargs):
             return '99.99.99.99'
 
+        self.stubs.Set(network.API, 'get_instance_nw_info',
+                fake_get_instance_nw_info)
+        self.stubs.Set(network.API, 'get_floating_ips_by_fixed_address',
+                fake_get_floating_ips_by_fixed_address)
         self.stubs.Set(api, 'instance_get', instance_get)
         self.stubs.Set(api, 'instance_get_all_by_filters', instance_get_list)
         self.stubs.Set(api, 'instance_get_floating_address', floating_get)