Moves image creation from POST /images to POST /servers/<id>/action

6 files changed, 449 insertions, 373 deletions

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 9199c193d..53e814cd5 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -296,6 +296,37 @@ class ServerXMLDeserializer(wsgi.MetadataXMLDeserializer):
     and personality attributes
     """
 
+    def action(self, string):
+        dom = minidom.parseString(string)
+        action_node = dom.childNodes[0]
+        action_name = action_node.tagName
+
+        action_deserializer = {
+            'createImage': self._action_create_image,
+            'createBackup': self._action_create_backup,
+        }.get(action_name, self.default)
+
+        action_data = action_deserializer(action_node)
+
+        return {'body': {action_name: action_data}}
+
+    def _action_create_image(self, node):
+        return self._deserialize_image_action(node, ('name',))
+
+    def _action_create_backup(self, node):
+        attributes = ('name', 'backup_type', 'rotation')
+        return self._deserialize_image_action(node, attributes)
+
+    def _deserialize_image_action(self, node, allowed_attributes):
+        data = {}
+        for attribute in allowed_attributes:
+            value = node.getAttribute(attribute)
+            if value:
+                data[attribute] = value
+        metadata_node = self.find_first_child_named(node, 'metadata')
+        data['metadata'] = self.extract_metadata(metadata_node)
+        return data
+
     def create(self, string):
         """Deserialize an xml-formatted server create request"""
         dom = minidom.parseString(string)
diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 9ba8b639e..0834adfa5 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -98,79 +98,34 @@ class Controller(object):
         self._image_service.delete(context, id)
         return webob.exc.HTTPNoContent()
 
-    def create(self, req, body):
-        """Snapshot or backup a server instance and save the image.
-
-        Images now have an `image_type` associated with them, which can be
-        'snapshot' or the backup type, like 'daily' or 'weekly'.
-
-        If the image_type is backup-like, then the rotation factor can be
-        included and that will cause the oldest backups that exceed the
-        rotation factor to be deleted.
-
-        :param req: `wsgi.Request` object
-        """
-        def get_param(param):
-            try:
-                return body["image"][param]
-            except KeyError:
-                raise webob.exc.HTTPBadRequest(explanation="Missing required "
-                        "param: %s" % param)
-
-        context = req.environ['nova.context']
-        content_type = req.get_content_type()
-
-        if not body:
-            raise webob.exc.HTTPBadRequest()
-
-        image_type = body["image"].get("image_type", "snapshot")
-
-        try:
-            server_id = self._server_id_from_req(req, body)
-        except KeyError:
-            raise webob.exc.HTTPBadRequest()
-
-        image_name = get_param("name")
-        props = self._get_extra_properties(req, body)
-
-        if image_type == "snapshot":
-            image = self._compute_service.snapshot(
-                        context, server_id, image_name,
-                        extra_properties=props)
-        elif image_type == "backup":
-            # NOTE(sirp): Unlike snapshot, backup is not a customer facing
-            # API call; rather, it's used by the internal backup scheduler
-            if not FLAGS.allow_admin_api:
-                raise webob.exc.HTTPBadRequest(
-                        explanation="Admin API Required")
-
-            backup_type = get_param("backup_type")
-            rotation = int(get_param("rotation"))
-
-            image = self._compute_service.backup(
-                        context, server_id, image_name,
-                        backup_type, rotation, extra_properties=props)
-        else:
-            LOG.error(_("Invalid image_type '%s' passed") % image_type)
-            raise webob.exc.HTTPBadRequest(explanation="Invalue image_type: "
-                   "%s" % image_type)
-
-        return dict(image=self.get_builder(req).build(image, detail=True))
-
     def get_builder(self, request):
         """Indicates that you must use a Controller subclass."""
         raise NotImplementedError()
 
-    def _server_id_from_req(self, req, data):
-        raise NotImplementedError()
-
-    def _get_extra_properties(self, req, data):
-        return {}
-
 
 class ControllerV10(Controller):
     """Version 1.0 specific controller logic."""
 
+    def create(self, req, body):
+        """Snapshot a server instance and save the image."""
+        try:
+            image = body["image"]
+        except (KeyError, TypeError):
+            msg = _("Invalid image entity")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        try:
+            image_name = image["name"]
+            server_id = image["serverId"]
+        except KeyError as missing_key:
+            msg = _("Image entity requires %s") % missing_key
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        context = req.environ["nova.context"]
+        image = self._compute_service.snapshot(context, server_id, image_name)
+
+        return dict(image=self.get_builder(req).build(image, detail=True))
+
     def get_builder(self, request):
         """Property to get the ViewBuilder class we need to use."""
         base_url = request.application_url
@@ -202,13 +157,6 @@ class ControllerV10(Controller):
         builder = self.get_builder(req).build
         return dict(images=[builder(image, detail=True) for image in images])
 
-    def _server_id_from_req(self, req, data):
-        try:
-            return data['image']['serverId']
-        except KeyError:
-            msg = _("Expected serverId attribute on server entity.")
-            raise webob.exc.HTTPBadRequest(explanation=msg)
-
 
 class ControllerV11(Controller):
     """Version 1.1 specific controller logic."""
@@ -246,37 +194,8 @@ class ControllerV11(Controller):
         builder = self.get_builder(req).build
         return dict(images=[builder(image, detail=True) for image in images])
 
-    def _server_id_from_req(self, req, data):
-        try:
-            server_ref = data['image']['serverRef']
-        except KeyError:
-            msg = _("Expected serverRef attribute on server entity.")
-            raise webob.exc.HTTPBadRequest(explanation=msg)
-
-        if not server_ref.startswith('http'):
-            return server_ref
-
-        passed = urlparse.urlparse(server_ref)
-        expected = urlparse.urlparse(req.application_url)
-        version = expected.path.split('/')[1]
-        expected_prefix = "/%s/servers/" % version
-        _empty, _sep, server_id = passed.path.partition(expected_prefix)
-        scheme_ok = passed.scheme == expected.scheme
-        host_ok = passed.hostname == expected.hostname
-        port_ok = (passed.port == expected.port or
-                   passed.port == FLAGS.osapi_port)
-        if not (scheme_ok and port_ok and host_ok and server_id):
-            msg = _("serverRef must match request url")
-            raise webob.exc.HTTPBadRequest(explanation=msg)
-
-        return server_id
-
-    def _get_extra_properties(self, req, data):
-        server_ref = data['image']['serverRef']
-        if not server_ref.startswith('http'):
-            server_ref = os.path.join(req.application_url, 'servers',
-                                      server_ref)
-        return {'instance_ref': server_ref}
+    def create(self, *args, **kwargs):
+        raise webob.exc.HTTPMethodNotAllowed()
 
 
 class ImageXMLSerializer(wsgi.XMLDictSerializer):
@@ -369,12 +288,6 @@ class ImageXMLSerializer(wsgi.XMLDictSerializer):
                                        image_dict['image'])
         return self.to_xml_string(node, True)
 
-    def create(self, image_dict):
-        xml_doc = minidom.Document()
-        node = self._image_to_xml_detailed(xml_doc,
-                                       image_dict['image'])
-        return self.to_xml_string(node, True)
-
 
 def create_resource(version='1.0'):
     controller = {
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8d2ccc2ad..7b757143d 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -14,6 +14,7 @@
 #    under the License.
 
 import base64
+import os
 import traceback
 
 from webob import exc
@@ -154,23 +155,95 @@ class Controller(object):
 
     @scheduler_api.redirect_handler
     def action(self, req, id, body):
-        """Multi-purpose method used to reboot, rebuild, or
-        resize a server"""
+        """Multi-purpose method used to take actions on a server"""
 
-        actions = {
+        self.actions = {
             'changePassword': self._action_change_password,
             'reboot': self._action_reboot,
             'resize': self._action_resize,
             'confirmResize': self._action_confirm_resize,
             'revertResize': self._action_revert_resize,
             'rebuild': self._action_rebuild,
-            'migrate': self._action_migrate}
+            'migrate': self._action_migrate,
+            'createImage': self._action_create_image,
+        }
 
-        for key in actions.keys():
+        if FLAGS.allow_admin_api:
+            admin_actions = {
+                'createBackup': self._action_create_backup,
+            }
+            self.actions.update(admin_actions)
+
+        for key in self.actions.keys():
             if key in body:
-                return actions[key](body, req, id)
+                return self.actions[key](body, req, id)
+
         raise exc.HTTPNotImplemented()
 
+    def _action_create_backup(self, input_dict, req, instance_id):
+        """Backup a server instance.
+
+        Images now have an `image_type` associated with them, which can be
+        'snapshot' or the backup type, like 'daily' or 'weekly'.
+
+        If the image_type is backup-like, then the rotation factor can be
+        included and that will cause the oldest backups that exceed the
+        rotation factor to be deleted.
+
+        """
+        entity = input_dict["createBackup"]
+
+        try:
+            image_name = entity["name"]
+            backup_type = entity["backup_type"]
+            rotation = entity["rotation"]
+
+        except KeyError as missing_key:
+            msg = _("createBackup entity requires %s attribute") % missing_key
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        except TypeError:
+            msg = _("Malformed createBackup entity")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        try:
+            rotation = int(rotation)
+        except ValueError:
+            msg = _("createBackup attribute 'rotation' must be an integer")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        # preserve link to server in image properties
+        server_ref = os.path.join(req.application_url,
+                                  'servers',
+                                  str(instance_id))
+        props = {'instance_ref': server_ref}
+
+        metadata = entity.get('metadata', {})
+        try:
+            props.update(metadata)
+        except ValueError:
+            msg = _("Invalid metadata")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        context = req.environ["nova.context"]
+        image = self.compute_api.backup(context,
+                                        instance_id,
+                                        image_name,
+                                        backup_type,
+                                        rotation,
+                                        extra_properties=props)
+
+        # build location of newly-created image entity
+        image_id = str(image['id'])
+        image_ref = os.path.join(req.application_url, 'images', image_id)
+
+        resp = webob.Response(status_int=202)
+        resp.headers['Location'] = image_ref
+        return resp
+
+    def _action_create_image(self, input_dict, req, id):
+        return exc.HTTPNotImplemented()
+
     def _action_change_password(self, input_dict, req, id):
         return exc.HTTPNotImplemented()
 
@@ -607,6 +680,48 @@ class ControllerV11(Controller):
 
         return webob.Response(status_int=202)
 
+    def _action_create_image(self, input_dict, req, instance_id):
+        """Snapshot a server instance."""
+        entity = input_dict.get("createImage", {})
+
+        try:
+            image_name = entity["name"]
+
+        except KeyError:
+            msg = _("createImage entity requires name attribute")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        except TypeError:
+            msg = _("Malformed createImage entity")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        # preserve link to server in image properties
+        server_ref = os.path.join(req.application_url,
+                                  'servers',
+                                  str(instance_id))
+        props = {'instance_ref': server_ref}
+
+        metadata = entity.get('metadata', {})
+        try:
+            props.update(metadata)
+        except ValueError:
+            msg = _("Invalid metadata")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        context = req.environ['nova.context']
+        image = self.compute_api.snapshot(context,
+                                          instance_id,
+                                          image_name,
+                                          extra_properties=props)
+
+        # build location of newly-created image entity
+        image_id = str(image['id'])
+        image_ref = os.path.join(req.application_url, 'images', image_id)
+
+        resp = webob.Response(status_int=202)
+        resp.headers['Location'] = image_ref
+        return resp
+
     def get_default_xmlns(self, req):
         return common.XML_NS_V11
 
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index 8c5ad7f8d..942c0b333 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -1042,82 +1042,6 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         response = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, response.status_int)
 
-    def test_create_backup_no_name(self):
-        """Name is also required for backups"""
-        body = dict(image=dict(serverId='123', image_type='backup',
-                               backup_type='daily', rotation=1))
-        req = webob.Request.blank('/v1.0/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_backup_with_rotation_and_backup_type(self):
-        """The happy path for creating backups
-
-        Creating a backup is an admin-only operation, as opposed to snapshots
-        which are available to anybody.
-        """
-        # FIXME(sirp): teardown needed?
-        FLAGS.allow_admin_api = True
-
-        # FIXME(sirp): should the fact that backups are admin_only be a FLAG
-        body = dict(image=dict(serverId='123', image_type='backup',
-                               name='Backup 1',
-                               backup_type='daily', rotation=1))
-        req = webob.Request.blank('/v1.0/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(200, response.status_int)
-
-    def test_create_backup_no_rotation(self):
-        """Rotation is required for backup requests"""
-        # FIXME(sirp): teardown needed?
-        FLAGS.allow_admin_api = True
-
-        # FIXME(sirp): should the fact that backups are admin_only be a FLAG
-        body = dict(image=dict(serverId='123', name='daily',
-                               image_type='backup', backup_type='daily'))
-        req = webob.Request.blank('/v1.0/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_backup_no_backup_type(self):
-        """Backup Type (daily or weekly) is required for backup requests"""
-        # FIXME(sirp): teardown needed?
-        FLAGS.allow_admin_api = True
-
-        # FIXME(sirp): should the fact that backups are admin_only be a FLAG
-        body = dict(image=dict(serverId='123', name='daily',
-                               image_type='backup', rotation=1))
-        req = webob.Request.blank('/v1.0/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_image_with_invalid_image_type(self):
-        """Valid image_types are snapshot | daily | weekly"""
-        # FIXME(sirp): teardown needed?
-        FLAGS.allow_admin_api = True
-
-        # FIXME(sirp): should the fact that backups are admin_only be a FLAG
-        body = dict(image=dict(serverId='123', image_type='monthly',
-                               rotation=1))
-        req = webob.Request.blank('/v1.0/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
     def test_create_image_no_server_id(self):
 
         body = dict(image=dict(name='Snapshot 1'))
@@ -1128,113 +1052,6 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         response = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, response.status_int)
 
-    def test_create_image_v1_1(self):
-
-        body = dict(image=dict(serverRef='123', name='Snapshot 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(200, response.status_int)
-
-    def test_create_image_v1_1_actual_server_ref(self):
-
-        serverRef = 'http://localhost/v1.1/servers/1'
-        serverBookmark = 'http://localhost/servers/1'
-        body = dict(image=dict(serverRef=serverRef, name='Backup 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(200, response.status_int)
-        result = json.loads(response.body)
-        expected = {
-            'id': 1,
-            'links': [
-                {
-                    'rel': 'self',
-                    'href': serverRef,
-                },
-                {
-                    'rel': 'bookmark',
-                    'href': serverBookmark,
-                },
-            ]
-        }
-        self.assertEqual(result['image']['server'], expected)
-
-    def test_create_image_v1_1_actual_server_ref_port(self):
-
-        serverRef = 'http://localhost:8774/v1.1/servers/1'
-        serverBookmark = 'http://localhost:8774/servers/1'
-        body = dict(image=dict(serverRef=serverRef, name='Backup 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(200, response.status_int)
-        result = json.loads(response.body)
-        expected = {
-            'id': 1,
-            'links': [
-                {
-                    'rel': 'self',
-                    'href': serverRef,
-                },
-                {
-                    'rel': 'bookmark',
-                    'href': serverBookmark,
-                },
-            ]
-        }
-        self.assertEqual(result['image']['server'], expected)
-
-    def test_create_image_v1_1_server_ref_bad_hostname(self):
-
-        serverRef = 'http://asdf/v1.1/servers/1'
-        body = dict(image=dict(serverRef=serverRef, name='Backup 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_image_v1_1_no_server_ref(self):
-
-        body = dict(image=dict(name='Snapshot 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_image_v1_1_server_ref_missing_version(self):
-
-        serverRef = 'http://localhost/servers/1'
-        body = dict(image=dict(serverRef=serverRef, name='Backup 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
-    def test_create_image_v1_1_server_ref_missing_id(self):
-
-        serverRef = 'http://localhost/v1.1/servers'
-        body = dict(image=dict(serverRef=serverRef, name='Backup 1'))
-        req = webob.Request.blank('/v1.1/images')
-        req.method = 'POST'
-        req.body = json.dumps(body)
-        req.headers["content-type"] = "application/json"
-        response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
-
     @classmethod
     def _make_image_fixtures(cls):
         image_id = 123
@@ -1713,76 +1530,3 @@ class ImageXMLSerializationTest(test.TestCase):
         """.replace("  ", "") % (locals()))
 
         self.assertEqual(expected.toxml(), actual.toxml())
-
-    def test_create(self):
-        serializer = images.ImageXMLSerializer()
-
-        fixture = {
-            'image': {
-                'id': 1,
-                'name': 'Image1',
-                'created': self.TIMESTAMP,
-                'updated': self.TIMESTAMP,
-                'status': 'SAVING',
-                'progress': 80,
-                'server': {
-                    'id': 1,
-                    'links': [
-                        {
-                            'href': self.SERVER_HREF,
-                            'rel': 'self',
-                        },
-                        {
-                            'href': self.SERVER_BOOKMARK,
-                            'rel': 'bookmark',
-                        },
-                    ],
-                },
-                'metadata': {
-                    'key1': 'value1',
-                },
-                'links': [
-                    {
-                        'href': self.IMAGE_HREF % 1,
-                        'rel': 'self',
-                    },
-                    {
-                        'href': self.IMAGE_BOOKMARK % 1,
-                        'rel': 'bookmark',
-                    },
-                ],
-            },
-        }
-
-        output = serializer.serialize(fixture, 'create')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected_server_href = self.SERVER_HREF
-        expected_server_bookmark = self.SERVER_BOOKMARK
-        expected_href = self.IMAGE_HREF % 1
-        expected_bookmark = self.IMAGE_BOOKMARK % 1
-        expected_now = self.TIMESTAMP
-        expected = minidom.parseString("""
-        <image id="1"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="Image1"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                status="SAVING"
-                progress="80">
-            <server id="1">
-                <atom:link rel="self" href="%(expected_server_href)s"/>
-                <atom:link rel="bookmark" href="%(expected_server_bookmark)s"/>
-            </server>
-            <metadata>
-                <meta key="key1">
-                    value1
-                </meta>
-            </metadata>
-            <atom:link href="%(expected_href)s" rel="self"/>
-            <atom:link href="%(expected_bookmark)s" rel="bookmark"/>
-        </image>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index 14ce42837..1871cac96 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -260,6 +260,17 @@ class ServersTest(test.TestCase):
         self.stubs.Set(nova.compute.API, "get_diagnostics", fake_compute_api)
         self.stubs.Set(nova.compute.API, "get_actions", fake_compute_api)
 
+        fakes.stub_out_glance(self.stubs)
+        fakes.stub_out_compute_api_snapshot(self.stubs)
+        service_class = 'nova.image.glance.GlanceImageService'
+        self.service = utils.import_object(service_class)
+        self.context = context.RequestContext(1, None)
+        self.service.delete_all()
+        self.sent_to_glance = {}
+        fakes.stub_out_glance_add_image(self.stubs, self.sent_to_glance)
+
+        self.allow_admin = FLAGS.allow_admin_api
+
         self.webreq = common.webob_factory('/v1.0/servers')
 
     def test_get_server_by_id(self):
@@ -2346,6 +2357,268 @@ class ServersTest(test.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['server']['status'], 'SHUTOFF')
 
+    def test_create_image_v1_1(self):
+        body = {
+            'createImage': {
+                'name': 'Snapshot 1',
+            },
+        }
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(202, response.status_int)
+        location = response.headers['Location']
+        self.assertEqual('http://localhost/v1.1/images/123', location)
+
+    def test_create_image_v1_1_with_metadata(self):
+        body = {
+            'createImage': {
+                'name': 'Snapshot 1',
+                'metadata': {'key': 'asdf'},
+            },
+        }
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(202, response.status_int)
+        location = response.headers['Location']
+        self.assertEqual('http://localhost/v1.1/images/123', location)
+
+    def test_create_image_v1_1_no_name(self):
+        body = {
+            'createImage': {},
+        }
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+    def test_create_image_v1_1_bad_metadata(self):
+        body = {
+            'createImage': {
+                'name': 'geoff',
+                'metadata': 'henry',
+            },
+        }
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+    def test_create_backup(self):
+        """The happy path for creating backups"""
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'backup_type': 'daily',
+                'rotation': 1,
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(202, response.status_int)
+        self.assertTrue(response.headers['Location'])
+
+    def test_create_backup_v1_1(self):
+        """The happy path for creating backups through v1.1 api"""
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'backup_type': 'daily',
+                'rotation': 1,
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(202, response.status_int)
+        self.assertTrue(response.headers['Location'])
+
+    def test_create_backup_admin_api_off(self):
+        """The happy path for creating backups"""
+        FLAGS.allow_admin_api = False
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'backup_type': 'daily',
+                'rotation': 1,
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(501, response.status_int)
+
+    def test_create_backup_with_metadata(self):
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'backup_type': 'daily',
+                'rotation': 1,
+                'metadata': {'123': 'asdf'},
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/servers/1/action')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(202, response.status_int)
+        self.assertTrue(response.headers['Location'])
+
+    def test_create_backup_no_name(self):
+        """Name is required for backups"""
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'backup_type': 'daily',
+                'rotation': 1,
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/images')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+    def test_create_backup_no_rotation(self):
+        """Rotation is required for backup requests"""
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'backup_type': 'daily',
+            },
+        }
+
+        req = webob.Request.blank('/v1.0/images')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+    def test_create_backup_no_backup_type(self):
+        """Backup Type (daily or weekly) is required for backup requests"""
+        FLAGS.allow_admin_api = True
+
+        body = {
+            'createBackup': {
+                'name': 'Backup 1',
+                'rotation': 1,
+            },
+        }
+        req = webob.Request.blank('/v1.0/images')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+    def test_create_backup_bad_entity(self):
+        FLAGS.allow_admin_api = True
+
+        body = {'createBackup': 'go'}
+        req = webob.Request.blank('/v1.0/images')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEqual(400, response.status_int)
+
+
+class TestServerActionXMLDeserializer(test.TestCase):
+
+    def setUp(self):
+        self.deserializer = create_instance_helper.ServerXMLDeserializer()
+
+    def tearDown(self):
+        pass
+
+    def test_create_image(self):
+        serial_request = """
+<createImage xmlns="http://docs.openstack.org/compute/api/v1.1"
+             name="new-server-test"/>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "createImage": {
+                "name": "new-server-test",
+                "metadata": {},
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_create_image_with_metadata(self):
+        serial_request = """
+<createImage xmlns="http://docs.openstack.org/compute/api/v1.1"
+             name="new-server-test">
+    <metadata>
+        <meta key="key1">value1</meta>
+    </metadata>
+</createImage>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "createImage": {
+                "name": "new-server-test",
+                "metadata": {"key1": "value1"},
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_create_backup_with_metadata(self):
+        serial_request = """
+<createBackup xmlns="http://docs.openstack.org/compute/api/v1.1"
+             name="new-server-test"
+             rotation="12"
+             backup_type="daily">
+    <metadata>
+        <meta key="key1">value1</meta>
+    </metadata>
+</createBackup>"""
+        request = self.deserializer.deserialize(serial_request, 'action')
+        expected = {
+            "createBackup": {
+                "name": "new-server-test",
+                "rotation": "12",
+                "backup_type": "daily",
+                "metadata": {"key1": "value1"},
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
 
 class TestServerCreateRequestXMLDeserializerV10(unittest.TestCase):
 
@@ -2815,7 +3088,7 @@ class TestServerCreateRequestXMLDeserializerV11(unittest.TestCase):
         self.assertEquals(request['body'], expected)
 
 
-class TextAddressesXMLSerialization(test.TestCase):
+class TestAddressesXMLSerialization(test.TestCase):
 
     serializer = nova.api.openstack.ips.IPXMLSerializer()
 
diff --git a/tools/pip-requires b/tools/pip-requires
index 497bf3ddd..23e707034 100644
--- a/tools/pip-requires
+++ b/tools/pip-requires
@@ -9,7 +9,7 @@ boto==1.9b
 carrot==0.10.5
 eventlet
 lockfile==0.8
-python-novaclient==2.5.7
+python-novaclient==2.5.9
 python-daemon==1.5.5
 python-gflags==1.3
 redis==2.0.0