merging parent branch servers-xml-serialization

5 files changed, 214 insertions, 88 deletions

diff --git a/nova/api/openstack/__init__.py b/nova/api/openstack/__init__.py
index 868b98a31..1d14474a8 100644
--- a/nova/api/openstack/__init__.py
+++ b/nova/api/openstack/__init__.py
@@ -175,7 +175,7 @@ class APIRouterV11(APIRouter):
                        action='update_all',
                        conditions={"method": ['PUT']})
 
-        mapper.resource("server_meta", "meta",
+        mapper.resource("server_meta", "metadata",
                         controller=server_metadata.create_resource(),
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index bd14a1389..efa4ab385 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -17,12 +17,14 @@
 
 import re
 from urlparse import urlparse
+from xml.dom import minidom
 
 import webob
 
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova.api.openstack import wsgi
 
 
 LOG = logging.getLogger('nova.api.openstack.common')
@@ -192,3 +194,83 @@ def get_version_from_href(href):
     except IndexError:
         version = '1.0'
     return version
+
+
+class MetadataXMLDeserializer(wsgi.MetadataXMLDeserializer):
+
+    def _extract_metadata_container(self, datastring):
+        dom = minidom.parseString(datastring)
+        metadata_node = self.find_first_child_named(dom, "metadata")
+        metadata = self.extract_metadata(metadata_node)
+        return {'body': {'metadata': metadata}}
+
+    def create(self, datastring):
+        return self._extract_metadata_container(datastring)
+
+    def update_all(self, datastring):
+        return self._extract_metadata_container(datastring)
+
+    def update(self, datastring):
+        dom = minidom.parseString(datastring)
+        metadata_item = self.extract_metadata(dom)
+        return {'body': {'meta': metadata_item}}
+
+
+class MetadataHeadersSerializer(wsgi.ResponseHeadersSerializer):
+
+    def delete(self, response, data):
+        response.status_int = 204
+
+
+class MetadataXMLSerializer(wsgi.XMLDictSerializer):
+    def __init__(self, xmlns=wsgi.XMLNS_V11):
+        super(MetadataXMLSerializer, self).__init__(xmlns=xmlns)
+
+    def _meta_item_to_xml(self, doc, key, value):
+        node = doc.createElement('meta')
+        doc.appendChild(node)
+        node.setAttribute('key', '%s' % key)
+        text = doc.createTextNode('%s' % value)
+        node.appendChild(text)
+        return node
+
+    def meta_list_to_xml(self, xml_doc, meta_items):
+        container_node = xml_doc.createElement('metadata')
+        for (key, value) in meta_items:
+            item_node = self._meta_item_to_xml(xml_doc, key, value)
+            container_node.appendChild(item_node)
+        return container_node
+
+    def _meta_list_to_xml_string(self, metadata_dict):
+        xml_doc = minidom.Document()
+        items = metadata_dict['metadata'].items()
+        container_node = self.meta_list_to_xml(xml_doc, items)
+        xml_doc.appendChild(container_node)
+        self._add_xmlns(container_node)
+        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
+
+    def index(self, metadata_dict):
+        return self._meta_list_to_xml_string(metadata_dict)
+
+    def create(self, metadata_dict):
+        return self._meta_list_to_xml_string(metadata_dict)
+
+    def update_all(self, metadata_dict):
+        return self._meta_list_to_xml_string(metadata_dict)
+
+    def _meta_item_to_xml_string(self, meta_item_dict):
+        xml_doc = minidom.Document()
+        item_key, item_value = meta_item_dict.items()[0]
+        item_node = self._meta_item_to_xml(xml_doc, item_key, item_value)
+        xml_doc.appendChild(item_node)
+        self._add_xmlns(item_node)
+        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
+
+    def show(self, meta_item_dict):
+        return self._meta_item_to_xml_string(meta_item_dict['meta'])
+
+    def update(self, meta_item_dict):
+        return self._meta_item_to_xml_string(meta_item_dict['meta'])
+
+    def default(self, *args, **kwargs):
+        return ''
diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index ee181c924..da753dee5 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -16,12 +16,13 @@
 #    under the License.
 
 from webob import exc
-from xml.dom import minidom
 
 from nova import flags
 from nova import image
 from nova import quota
 from nova import utils
+from nova.api.openstack import common
+from nova.api.openstack import faults
 from nova.api.openstack import wsgi
 
 
@@ -118,95 +119,15 @@ class Controller(object):
         self.image_service.update(context, image_id, img, None)
 
 
-class ImageMetadataXMLDeserializer(wsgi.MetadataXMLDeserializer):
-
-    def _extract_metadata_container(self, datastring):
-        dom = minidom.parseString(datastring)
-        metadata_node = self.find_first_child_named(dom, "metadata")
-        metadata = self.extract_metadata(metadata_node)
-        return {'body': {'metadata': metadata}}
-
-    def create(self, datastring):
-        return self._extract_metadata_container(datastring)
-
-    def update_all(self, datastring):
-        return self._extract_metadata_container(datastring)
-
-    def update(self, datastring):
-        dom = minidom.parseString(datastring)
-        metadata_item = self.extract_metadata(dom)
-        return {'body': {'meta': metadata_item}}
-
-
-class HeadersSerializer(wsgi.ResponseHeadersSerializer):
-
-    def delete(self, response, data):
-        response.status_int = 204
-
-
-class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
-    def __init__(self, xmlns=wsgi.XMLNS_V11):
-        super(ImageMetadataXMLSerializer, self).__init__(xmlns=xmlns)
-
-    def _meta_item_to_xml(self, doc, key, value):
-        node = doc.createElement('meta')
-        doc.appendChild(node)
-        node.setAttribute('key', '%s' % key)
-        text = doc.createTextNode('%s' % value)
-        node.appendChild(text)
-        return node
-
-    def meta_list_to_xml(self, xml_doc, meta_items):
-        container_node = xml_doc.createElement('metadata')
-        for (key, value) in meta_items:
-            item_node = self._meta_item_to_xml(xml_doc, key, value)
-            container_node.appendChild(item_node)
-        return container_node
-
-    def _meta_list_to_xml_string(self, metadata_dict):
-        xml_doc = minidom.Document()
-        items = metadata_dict['metadata'].items()
-        container_node = self.meta_list_to_xml(xml_doc, items)
-        xml_doc.appendChild(container_node)
-        self._add_xmlns(container_node)
-        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
-
-    def index(self, metadata_dict):
-        return self._meta_list_to_xml_string(metadata_dict)
-
-    def create(self, metadata_dict):
-        return self._meta_list_to_xml_string(metadata_dict)
-
-    def update_all(self, metadata_dict):
-        return self._meta_list_to_xml_string(metadata_dict)
-
-    def _meta_item_to_xml_string(self, meta_item_dict):
-        xml_doc = minidom.Document()
-        item_key, item_value = meta_item_dict.items()[0]
-        item_node = self._meta_item_to_xml(xml_doc, item_key, item_value)
-        xml_doc.appendChild(item_node)
-        self._add_xmlns(item_node)
-        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
-
-    def show(self, meta_item_dict):
-        return self._meta_item_to_xml_string(meta_item_dict['meta'])
-
-    def update(self, meta_item_dict):
-        return self._meta_item_to_xml_string(meta_item_dict['meta'])
-
-    def default(self, *args, **kwargs):
-        return ''
-
-
 def create_resource():
-    headers_serializer = HeadersSerializer()
+    headers_serializer = common.MetadataHeadersSerializer()
 
     body_deserializers = {
-        'application/xml': ImageMetadataXMLDeserializer(),
+        'application/xml': common.MetadataXMLDeserializer(),
     }
 
     body_serializers = {
-        'application/xml': ImageMetadataXMLSerializer(),
+        'application/xml': common.MetadataXMLSerializer(),
     }
     serializer = wsgi.ResponseSerializer(body_serializers, headers_serializer)
     deserializer = wsgi.RequestDeserializer(body_deserializers)
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 30e4fd389..9ba8b639e 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -284,7 +284,7 @@ class ImageXMLSerializer(wsgi.XMLDictSerializer):
     xmlns = wsgi.XMLNS_V11
 
     def __init__(self):
-        self.metadata_serializer = image_metadata.ImageMetadataXMLSerializer()
+        self.metadata_serializer = common.MetadataXMLSerializer()
 
     def _image_to_xml(self, xml_doc, image):
         image_node = xml_doc.createElement('image')
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index d7cabb067..b35c528eb 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -18,6 +18,7 @@ import traceback
 
 from webob import exc
 import webob
+from xml.dom import minidom
 
 from nova import compute
 from nova import db
@@ -27,6 +28,7 @@ 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 ips
 import nova.api.openstack.views.addresses
 import nova.api.openstack.views.flavors
 import nova.api.openstack.views.images
@@ -599,6 +601,123 @@ class HeadersSerializer(wsgi.ResponseHeadersSerializer):
         response.status_int = 204
 
 
+class ServerXMLSerializer(wsgi.XMLDictSerializer):
+
+    xmlns = wsgi.XMLNS_V11
+
+    def __init__(self):
+        self.metadata_serializer = common.MetadataXMLSerializer()
+        self.addresses_serializer = ips.IPXMLSerializer()
+
+    def _create_basic_entity_node(self, xml_doc, id, links, name):
+        basic_node = xml_doc.createElement(name)
+        basic_node.setAttribute('id', str(id))
+        link_nodes = self._create_link_nodes(xml_doc, links)
+        for link_node in link_nodes:
+            basic_node.appendChild(link_node)
+        return basic_node
+
+    def _create_metadata_node(self, xml_doc, metadata):
+        return self.metadata_serializer.meta_list_to_xml(xml_doc, metadata)
+
+    def _create_addresses_node(self, xml_doc, addresses):
+        return self.addresses_serializer.networks_to_xml(xml_doc, addresses)
+
+    def _add_server_attributes(self, node, server):
+        node.setAttribute('id', str(server['id']))
+        node.setAttribute('uuid', str(server['uuid']))
+        node.setAttribute('hostId', str(server['hostId']))
+        node.setAttribute('name', server['name'])
+        node.setAttribute('created', str(server['created']))
+        node.setAttribute('updated', str(server['updated']))
+        node.setAttribute('status', server['status'])
+        if 'progress' in server:
+            node.setAttribute('progress', str(server['progress']))
+
+    def _server_to_xml(self, xml_doc, server):
+        server_node = xml_doc.createElement('server')
+        server_node.setAttribute('id', str(server['id']))
+        server_node.setAttribute('name', server['name'])
+        link_nodes = self._create_link_nodes(xml_doc,
+                                             server['links'])
+        for link_node in link_nodes:
+            server_node.appendChild(link_node)
+        return server_node
+
+    def _server_to_xml_detailed(self, xml_doc, server):
+        server_node = xml_doc.createElement('server')
+        self._add_server_attributes(server_node, server)
+
+        link_nodes = self._create_link_nodes(xml_doc,
+                                             server['links'])
+        for link_node in link_nodes:
+            server_node.appendChild(link_node)
+
+        if 'image' in server:
+            image_node = self._create_basic_entity_node(xml_doc,
+                                                    server['image']['id'],
+                                                    server['image']['links'],
+                                                    'image')
+            server_node.appendChild(image_node)
+
+        if 'flavor' in server:
+            flavor_node = self._create_basic_entity_node(xml_doc,
+                                                    server['flavor']['id'],
+                                                    server['flavor']['links'],
+                                                    'flavor')
+            server_node.appendChild(flavor_node)
+
+        metadata = server.get('metadata', {}).items()
+        if len(metadata) > 0:
+            metadata_node = self._create_metadata_node(xml_doc, metadata)
+            server_node.appendChild(metadata_node)
+
+        addresses_node = self._create_addresses_node(xml_doc,
+                                                     server['addresses'])
+        server_node.appendChild(addresses_node)
+
+        return server_node
+
+    def _server_list_to_xml(self, xml_doc, servers, detailed):
+        container_node = xml_doc.createElement('servers')
+        if detailed:
+            server_to_xml = self._server_to_xml_detailed
+        else:
+            server_to_xml = self._server_to_xml
+
+        for server in servers:
+            item_node = server_to_xml(xml_doc, server)
+            container_node.appendChild(item_node)
+        return container_node
+
+    def index(self, servers_dict):
+        xml_doc = minidom.Document()
+        node = self._server_list_to_xml(xml_doc,
+                                       servers_dict['servers'],
+                                       detailed=False)
+        return self.to_xml_string(node, True)
+
+    def detail(self, servers_dict):
+        xml_doc = minidom.Document()
+        node = self._server_list_to_xml(xml_doc,
+                                       servers_dict['servers'],
+                                       detailed=True)
+        return self.to_xml_string(node, True)
+
+    def show(self, server_dict):
+        xml_doc = minidom.Document()
+        node = self._server_to_xml_detailed(xml_doc,
+                                       server_dict['server'])
+        return self.to_xml_string(node, True)
+
+    def create(self, server_dict):
+        xml_doc = minidom.Document()
+        node = self._server_to_xml_detailed(xml_doc,
+                                       server_dict['server'])
+        node.setAttribute('adminPass', server_dict['server']['adminPass'])
+        return self.to_xml_string(node, True)
+
+
 def create_resource(version='1.0'):
     controller = {
         '1.0': ControllerV10,
@@ -628,9 +747,13 @@ def create_resource(version='1.0'):
 
     headers_serializer = HeadersSerializer()
 
+    xml_serializer = {
+        '1.0': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V10),
+        '1.1': ServerXMLSerializer(),
+    }[version]
+
     body_serializers = {
-        'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
-                                                  xmlns=xmlns),
+        'application/xml': xml_serializer,
     }
 
     body_deserializers = {