Merge w/ trunk.

6 files changed, 243 insertions, 20 deletions

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/images.py b/nova/api/openstack/images.py
index 96c5cd3fa..30e4fd389 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -34,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):
@@ -61,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):
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 a242efa45..ddbf7a144 100644
--- a/nova/api/openstack/views/addresses.py
+++ b/nova/api/openstack/views/addresses.py
@@ -15,9 +15,12 @@
 #    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."""
@@ -50,22 +53,37 @@ class ViewBuilderV11(ViewBuilder):
             if network_label not in networks:
                 networks[network_label] = []
 
-            networks[network_label].extend(self._extract_ipv4(interface))
+            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 = self._extract_ipv4(interface)
-                return {network_label: list(ips)}
+                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(self, interface):
+    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/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 05767da19..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