Sync trunk

5 files changed, 382 insertions, 28 deletions

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 2a8e7fd7e..894d47beb 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -304,6 +304,54 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
 
     metadata_deserializer = common.MetadataXMLDeserializer()
 
+    def create(self, string):
+        """Deserialize an xml-formatted server create request"""
+        dom = minidom.parseString(string)
+        server = self._extract_server(dom)
+        return {'body': {'server': server}}
+
+    def _extract_server(self, node):
+        """Marshal the server attribute of a parsed request"""
+        server = {}
+        server_node = self.find_first_child_named(node, 'server')
+
+        attributes = ["name", "imageId", "flavorId", "adminPass"]
+        for attr in attributes:
+            if server_node.getAttribute(attr):
+                server[attr] = server_node.getAttribute(attr)
+
+        metadata_node = self.find_first_child_named(server_node, "metadata")
+        server["metadata"] = self.metadata_deserializer.extract_metadata(
+                                                            metadata_node)
+
+        server["personality"] = self._extract_personality(server_node)
+
+        return server
+
+    def _extract_personality(self, server_node):
+        """Marshal the personality attribute of a parsed request"""
+        node = self.find_first_child_named(server_node, "personality")
+        personality = []
+        if node is not None:
+            for file_node in self.find_children_named(node, "file"):
+                item = {}
+                if file_node.hasAttribute("path"):
+                    item["path"] = file_node.getAttribute("path")
+                item["contents"] = self.extract_text(file_node)
+                personality.append(item)
+        return personality
+
+
+class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
+    """
+    Deserializer to handle xml-formatted server create requests.
+
+    Handles standard server attributes as well as optional metadata
+    and personality attributes
+    """
+
+    metadata_deserializer = common.MetadataXMLDeserializer()
+
     def action(self, string):
         dom = minidom.parseString(string)
         action_node = dom.childNodes[0]
@@ -312,6 +360,12 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
         action_deserializer = {
             'createImage': self._action_create_image,
             'createBackup': self._action_create_backup,
+            'changePassword': self._action_change_password,
+            'reboot': self._action_reboot,
+            'rebuild': self._action_rebuild,
+            'resize': self._action_resize,
+            'confirmResize': self._action_confirm_resize,
+            'revertResize': self._action_revert_resize,
         }.get(action_name, self.default)
 
         action_data = action_deserializer(action_node)
@@ -325,6 +379,46 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
         attributes = ('name', 'backup_type', 'rotation')
         return self._deserialize_image_action(node, attributes)
 
+    def _action_change_password(self, node):
+        if not node.hasAttribute("adminPass"):
+            raise AttributeError("No adminPass was specified in request")
+        return {"adminPass": node.getAttribute("adminPass")}
+
+    def _action_reboot(self, node):
+        if not node.hasAttribute("type"):
+            raise AttributeError("No reboot type was specified in request")
+        return {"type": node.getAttribute("type")}
+
+    def _action_rebuild(self, node):
+        rebuild = {}
+        if node.hasAttribute("name"):
+            rebuild['name'] = node.getAttribute("name")
+
+        metadata_node = self.find_first_child_named(node, "metadata")
+        if metadata_node is not None:
+            rebuild["metadata"] = self.extract_metadata(metadata_node)
+
+        personality = self._extract_personality(node)
+        if personality is not None:
+            rebuild["personality"] = personality
+
+        if not node.hasAttribute("imageRef"):
+            raise AttributeError("No imageRef was specified in request")
+        rebuild["imageRef"] = node.getAttribute("imageRef")
+
+        return rebuild
+
+    def _action_resize(self, node):
+        if not node.hasAttribute("flavorRef"):
+            raise AttributeError("No flavorRef was specified in request")
+        return {"flavorRef": node.getAttribute("flavorRef")}
+
+    def _action_confirm_resize(self, node):
+        return None
+
+    def _action_revert_resize(self, node):
+        return None
+
     def _deserialize_image_action(self, node, allowed_attributes):
         data = {}
         for attribute in allowed_attributes:
@@ -332,8 +426,10 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
             if value:
                 data[attribute] = value
         metadata_node = self.find_first_child_named(node, 'metadata')
-        metadata = self.metadata_deserializer.extract_metadata(metadata_node)
-        data['metadata'] = metadata
+        if metadata_node is not None:
+            metadata = self.metadata_deserializer.extract_metadata(
+                                                        metadata_node)
+            data['metadata'] = metadata
         return data
 
     def create(self, string):
@@ -347,29 +443,32 @@ class ServerXMLDeserializer(wsgi.XMLDeserializer):
         server = {}
         server_node = self.find_first_child_named(node, 'server')
 
-        attributes = ["name", "imageId", "flavorId", "imageRef",
-                     "flavorRef", "adminPass"]
+        attributes = ["name", "imageRef", "flavorRef", "adminPass"]
         for attr in attributes:
             if server_node.getAttribute(attr):
                 server[attr] = server_node.getAttribute(attr)
 
         metadata_node = self.find_first_child_named(server_node, "metadata")
-        server["metadata"] = self.metadata_deserializer.extract_metadata(
-            metadata_node)
+        if metadata_node is not None:
+            server["metadata"] = self.extract_metadata(metadata_node)
 
-        server["personality"] = self._extract_personality(server_node)
+        personality = self._extract_personality(server_node)
+        if personality is not None:
+            server["personality"] = personality
 
         return server
 
     def _extract_personality(self, server_node):
         """Marshal the personality attribute of a parsed request"""
         node = self.find_first_child_named(server_node, "personality")
-        personality = []
         if node is not None:
+            personality = []
             for file_node in self.find_children_named(node, "file"):
                 item = {}
                 if file_node.hasAttribute("path"):
                     item["path"] = file_node.getAttribute("path")
                 item["contents"] = self.extract_text(file_node)
                 personality.append(item)
-        return personality
+            return personality
+        else:
+            return None
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 3930982dc..1051ba571 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -267,10 +267,16 @@ class Controller(object):
 
     def _action_reboot(self, input_dict, req, id):
         if 'reboot' in input_dict and 'type' in input_dict['reboot']:
-            reboot_type = input_dict['reboot']['type']
+            valid_reboot_types = ['HARD', 'SOFT']
+            reboot_type = input_dict['reboot']['type'].upper()
+            if not valid_reboot_types.count(reboot_type):
+                msg = _("Argument 'type' for reboot is not HARD or SOFT")
+                LOG.exception(msg)
+                raise exc.HTTPBadRequest(explanation=msg)
         else:
-            LOG.exception(_("Missing argument 'type' for reboot"))
-            raise exc.HTTPUnprocessableEntity()
+            msg = _("Missing argument 'type' for reboot")
+            LOG.exception(msg)
+            raise exc.HTTPBadRequest(explanation=msg)
         try:
             # TODO(gundlach): pass reboot_type, support soft reboot in
             # virt driver
@@ -646,6 +652,9 @@ class ControllerV11(Controller):
         """ Resizes a given instance to the flavor size requested """
         try:
             flavor_ref = input_dict["resize"]["flavorRef"]
+            if not flavor_ref:
+                msg = _("Resize request has invalid 'flavorRef' attribute.")
+                raise exc.HTTPBadRequest(explanation=msg)
         except (KeyError, TypeError):
             msg = _("Resize requests require 'flavorRef' attribute.")
             raise exc.HTTPBadRequest(explanation=msg)
@@ -891,8 +900,13 @@ def create_resource(version='1.0'):
         'application/xml': xml_serializer,
     }
 
+    xml_deserializer = {
+        '1.0': helper.ServerXMLDeserializer(),
+        '1.1': helper.ServerXMLDeserializerV11(),
+    }[version]
+
     body_deserializers = {
-        'application/xml': helper.ServerXMLDeserializer(),
+        'application/xml': xml_deserializer,
     }
 
     serializer = wsgi.ResponseSerializer(body_serializers, headers_serializer)
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index 562cefe90..7e24d24fd 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -475,6 +475,21 @@ class ServerActionsTestV11(test.TestCase):
         self.assertEqual(mock_method.instance_id, '1')
         self.assertEqual(mock_method.password, '1234pass')
 
+    def test_server_change_password_xml(self):
+        mock_method = MockSetAdminPassword()
+        self.stubs.Set(nova.compute.api.API, 'set_admin_password', mock_method)
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = "application/xml"
+        req.body = """<?xml version="1.0" encoding="UTF-8"?>
+                    <changePassword
+                        xmlns="http://docs.openstack.org/compute/api/v1.1"
+                        adminPass="1234pass"/>"""
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(mock_method.instance_id, '1')
+        self.assertEqual(mock_method.password, '1234pass')
+
     def test_server_change_password_not_a_string(self):
         body = {'changePassword': {'adminPass': 1234}}
         req = webob.Request.blank('/v1.1/servers/1/action')
@@ -511,6 +526,42 @@ class ServerActionsTestV11(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_server_reboot_hard(self):
+        body = dict(reboot=dict(type="HARD"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+
+    def test_server_reboot_soft(self):
+        body = dict(reboot=dict(type="SOFT"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+
+    def test_server_reboot_incorrect_type(self):
+        body = dict(reboot=dict(type="NOT_A_TYPE"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_server_reboot_missing_type(self):
+        body = dict(reboot=dict())
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.content_type = 'application/json'
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
     def test_server_rebuild_accepted_minimum(self):
         body = {
             "rebuild": {
@@ -653,6 +704,62 @@ class ServerActionsTestV11(test.TestCase):
         self.assertEqual(res.status_int, 202)
         self.assertEqual(self.resize_called, True)
 
+    def test_resize_server_no_flavor(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(resize=dict())
+        req.body = json.dumps(body_dict)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_resize_server_no_flavor_ref(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(resize=dict(flavorRef=None))
+        req.body = json.dumps(body_dict)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 400)
+
+    def test_confirm_resize_server(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(confirmResize=None)
+        req.body = json.dumps(body_dict)
+
+        self.confirm_resize_called = False
+
+        def cr_mock(*args):
+            self.confirm_resize_called = True
+
+        self.stubs.Set(nova.compute.api.API, 'confirm_resize', cr_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 204)
+        self.assertEqual(self.confirm_resize_called, True)
+
+    def test_revert_resize_server(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.content_type = 'application/json'
+        req.method = 'POST'
+        body_dict = dict(revertResize=None)
+        req.body = json.dumps(body_dict)
+
+        self.revert_resize_called = False
+
+        def revert_mock(*args):
+            self.revert_resize_called = True
+
+        self.stubs.Set(nova.compute.api.API, 'revert_resize', revert_mock)
+
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 202)
+        self.assertEqual(self.revert_resize_called, True)
+
     def test_create_image(self):
         body = {
             'createImage': {
@@ -730,10 +837,10 @@ class ServerActionsTestV11(test.TestCase):
         self.assertTrue(response.headers['Location'])
 
 
-class TestServerActionXMLDeserializer(test.TestCase):
+class TestServerActionXMLDeserializerV11(test.TestCase):
 
     def setUp(self):
-        self.deserializer = create_instance_helper.ServerXMLDeserializer()
+        self.deserializer = create_instance_helper.ServerXMLDeserializerV11()
 
     def tearDown(self):
         pass
@@ -746,7 +853,6 @@ class TestServerActionXMLDeserializer(test.TestCase):
         expected = {
             "createImage": {
                 "name": "new-server-test",
-                "metadata": {},
             },
         }
         self.assertEquals(request['body'], expected)
@@ -767,3 +873,147 @@ class TestServerActionXMLDeserializer(test.TestCase):
             },
         }
         self.assertEquals(request['body'], expected)
+
+    def test_change_pass(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <changePassword
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    adminPass="1234pass"/> """
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "changePassword": {
+                "adminPass": "1234pass",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_change_pass_no_pass(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <changePassword
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/> """
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_reboot(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <reboot
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    type="HARD"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "reboot": {
+                "type": "HARD",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_reboot_no_type(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <reboot
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <resize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    flavorRef="http://localhost/flavors/3"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "resize": {
+                "flavorRef": "http://localhost/flavors/3"
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_resize_no_flavor_ref(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <resize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
+
+    def test_confirm_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <confirmResize
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "confirmResize": None,
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_revert_resize(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <revertResize
+                   xmlns="http://docs.openstack.org/compute/api/v1.1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "revertResize": None,
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_rebuild(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    name="new-server-test"
+                    imageRef="http://localhost/images/1">
+                    <metadata>
+                        <meta key="My Server Name">Apache1</meta>
+                    </metadata>
+                    <personality>
+                        <file path="/etc/banner.txt">Mg==</file>
+                    </personality>
+                </rebuild>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "rebuild": {
+                "name": "new-server-test",
+                "imageRef": "http://localhost/images/1",
+                "metadata": {
+                    "My Server Name": "Apache1",
+                },
+                "personality": [
+                    {"path": "/etc/banner.txt", "contents": "Mg=="},
+                ],
+            },
+        }
+        self.assertDictMatch(request['body'], expected)
+
+    def test_rebuild_minimum(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    imageRef="http://localhost/images/1"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "rebuild": {
+                "imageRef": "http://localhost/images/1",
+            },
+        }
+        self.assertDictMatch(request['body'], expected)
+
+    def test_rebuild_no_imageRef(self):
+        serial_request = """<?xml version="1.0" encoding="UTF-8"?>
+                <rebuild
+                    xmlns="http://docs.openstack.org/compute/api/v1.1"
+                    name="new-server-test">
+                    <metadata>
+                        <meta key="My Server Name">Apache1</meta>
+                    </metadata>
+                    <personality>
+                        <file path="/etc/banner.txt">Mg==</file>
+                    </personality>
+                </rebuild>"""
+        self.assertRaises(AttributeError,
+                          self.deserializer.deserialize,
+                          serial_request,
+                          'action')
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 0477f6d92..fd06b2e64 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -2177,7 +2177,7 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
 
     def setUp(self):
         super(TestServerCreateRequestXMLDeserializerV11, self).setUp()
-        self.deserializer = create_instance_helper.ServerXMLDeserializer()
+        self.deserializer = create_instance_helper.ServerXMLDeserializerV11()
 
     def test_minimal_request(self):
         serial_request = """
@@ -2191,8 +2191,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "2",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2211,8 +2209,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "imageRef": "1",
                 "flavorRef": "2",
                 "adminPass": "1234",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2229,8 +2225,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "http://localhost:8774/v1.1/images/2",
                 "flavorRef": "3",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2247,8 +2241,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "http://localhost:8774/v1.1/flavors/3",
-                "metadata": {},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2292,7 +2284,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "imageRef": "1",
                 "flavorRef": "2",
                 "metadata": {"one": "two", "open": "snack"},
-                "personality": [],
             },
         }
         self.assertEquals(request['body'], expected)
@@ -2314,7 +2305,6 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
                 "name": "new-server-test",
                 "imageRef": "1",
                 "flavorRef": "2",
-                "metadata": {},
                 "personality": [
                     {"path": "/etc/banner.txt", "contents": "MQ=="},
                     {"path": "/etc/hosts", "contents": "Mg=="},
diff --git a/smoketests/test_netadmin.py b/smoketests/test_netadmin.py
index 60086f065..de69c98a2 100644
--- a/smoketests/test_netadmin.py
+++ b/smoketests/test_netadmin.py
@@ -115,7 +115,8 @@ class SecurityGroupTests(base.UserSmokeTestCase):
         if not instance_id:
             return False
         if instance_id != self.data['instance'].id:
-            raise Exception("Wrong instance id")
+            raise Exception("Wrong instance id. Expected: %s, Got: %s" %
+                               (self.data['instance'].id, instance_id))
         return True
 
     def test_001_can_create_security_group(self):