openstack/nova
Code Issues Proposed changes

Change v3 shelve to v2.1

Browse Source 
This patch changes v3 shelve API to v2.1 and makes v2
unit tests share between v2 and v2.1.
The differences between v2 and v3 are described on the wiki page
https://wiki.openstack.org/wiki/NovaAPIv2tov3 .

Partially implements blueprint v2-on-v3-api
Change-Id: Ie4cd72d23592fe2bd1a66137b12bb84400ccfc18
This commit is contained in:
Eli Qiao
2014-08-27 09:50:03 +08:00
committed by Ken'ichi Ohmichi
parent b26a281ebe
commit 9daf3bdd87
5 changed files with 45 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
doc/v3/api_samples/os-shelve/os-shelve-offload.json
View File

@@ -1,3 +1,3 @@
{
"shelve_offload": null
"shelveOffload": null
}

4
nova/api/openstack/compute/plugins/v3/shelve.py
View File

@@ -56,7 +56,7 @@ class ShelveController(wsgi.Controller):
return webob.Response(status_int=202)
@exts.expected_errors((404, 409))
@wsgi.action('shelve_offload')
@wsgi.action('shelveOffload')
def _shelve_offload(self, req, id, body):
"""Force removal of a shelved instance from the compute node."""
context = req.environ["nova.context"]
@@ -70,7 +70,7 @@ class ShelveController(wsgi.Controller):
raise exc.HTTPConflict(explanation=e.format_message())
except exception.InstanceInvalidState as state_error:
common.raise_http_conflict_for_instance_invalid_state(state_error,
'shelve_offload')
'shelveOffload')
return webob.Response(status_int=202)

64
nova/tests/api/openstack/compute/contrib/test_shelve.py
View File

@@ -16,7 +16,8 @@ import uuid
import webob
from nova.api.openstack.compute.contrib import shelve
from nova.api.openstack.compute.contrib import shelve as shelve_v2
from nova.api.openstack.compute.plugins.v3 import shelve as shelve_v21
from nova.compute import api as compute_api
from nova import db
from nova import exception
@@ -37,94 +38,111 @@ def fake_auth_context(context):
return True
class ShelvePolicyTest(test.NoDBTestCase):
class ShelvePolicyTestV21(test.NoDBTestCase):
plugin = shelve_v21
prefix = 'v3:os-shelve:'
offload = 'shelve_offload'
def setUp(self):
super(ShelvePolicyTest, self).setUp()
self.controller = shelve.ShelveController()
super(ShelvePolicyTestV21, self).setUp()
self.controller = self.plugin.ShelveController()
def _fake_request(self):
return fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
def test_shelve_restricted_by_role(self):
rules = {'compute_extension:shelve':
rules = {'compute_extension:%sshelve' % self.prefix:
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_shelve_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:shelve':
'compute_extension:%sshelve' % self.prefix:
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_shelve_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_shelve', fake_auth_context)
self.stubs.Set(self.plugin, 'auth_shelve', fake_auth_context)
self.stubs.Set(compute_api.API, 'shelve',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(webob.exc.HTTPConflict, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_unshelve_restricted_by_role(self):
rules = {'compute_extension:unshelve':
rules = {'compute_extension:%sunshelve' % self.prefix:
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_unshelve_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:unshelve': common_policy.parse_rule('')}
'compute_extension:%sunshelve' % self.prefix:
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_unshelve_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_unshelve', fake_auth_context)
self.stubs.Set(self.plugin, 'auth_unshelve', fake_auth_context)
self.stubs.Set(compute_api.API, 'unshelve',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(webob.exc.HTTPConflict, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_shelve_offload_restricted_by_role(self):
rules = {'compute_extension:shelveOffload':
common_policy.parse_rule('role:admin')}
rules = {'compute_extension:%s%s' % (self.prefix, self.offload):
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden,
self.controller._shelve_offload, req, str(uuid.uuid4()), {})
def test_shelve_offload_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:shelveOffload':
'compute_extension:%s%s' % (self.prefix, self.offload):
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(exception.Forbidden,
self.controller._shelve_offload, req, str(uuid.uuid4()), {})
def test_shelve_offload_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_shelve_offload', fake_auth_context)
self.stubs.Set(self.plugin, 'auth_shelve_offload', fake_auth_context)
self.stubs.Set(compute_api.API, 'shelve_offload',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')
req = self._fake_request()
self.assertRaises(webob.exc.HTTPConflict,
self.controller._shelve_offload,
req, str(uuid.uuid4()), {})
class ShelvePolicyTestV2(ShelvePolicyTestV21):
plugin = shelve_v2
prefix = ''
offload = 'shelveOffload'
def _fake_request(self):
return fakes.HTTPRequest.blank('/v2/123/servers/12/os-shelve')

131
nova/tests/api/openstack/compute/plugins/v3/test_shelve.py
View File

@@ -1,131 +0,0 @@
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import uuid
import webob
from nova.api.openstack.compute.plugins.v3 import shelve
from nova.compute import api as compute_api
from nova import db
from nova import exception
from nova.openstack.common import policy as common_policy
from nova import policy
from nova import test
from nova.tests.api.openstack import fakes
from nova.tests import fake_instance
def fake_instance_get_by_uuid(context, instance_id,
columns_to_join=None, use_slave=False):
return fake_instance.fake_db_instance(
**{'name': 'fake', 'project_id': '%s_unequal' % context.project_id})
def fake_auth_context(context):
return True
class ShelvePolicyTest(test.NoDBTestCase):
def setUp(self):
super(ShelvePolicyTest, self).setUp()
self.controller = shelve.ShelveController()
def test_shelve_restricted_by_role(self):
rules = {'compute_extension:v3:os-shelve:shelve':
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_shelve_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:v3:os-shelve:shelve':
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_shelve_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_shelve', fake_auth_context)
self.stubs.Set(compute_api.API, 'shelve',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
self.assertRaises(webob.exc.HTTPConflict, self.controller._shelve,
req, str(uuid.uuid4()), {})
def test_unshelve_restricted_by_role(self):
rules = {'compute_extension:v3:os-shelve:unshelve':
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_unshelve_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:v3:os-shelve:unshelve':
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_unshelve_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_unshelve', fake_auth_context)
self.stubs.Set(compute_api.API, 'unshelve',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
self.assertRaises(webob.exc.HTTPConflict, self.controller._unshelve,
req, str(uuid.uuid4()), {})
def test_shelve_offload_restricted_by_role(self):
rules = {'compute_extension:v3:os-shelve:shelve_offload':
common_policy.parse_rule('role:admin')}
policy.set_rules(rules)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden,
self.controller._shelve_offload, req, str(uuid.uuid4()), {})
def test_shelve_offload_allowed(self):
rules = {'compute:get': common_policy.parse_rule(''),
'compute_extension:v3:shelve_offload':
common_policy.parse_rule('')}
policy.set_rules(rules)
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
req = fakes.HTTPRequestV3.blank('/servers/12/os-shelve')
self.assertRaises(exception.Forbidden,
self.controller._shelve_offload, req, str(uuid.uuid4()), {})
def test_shelve_offload_locked_server(self):
self.stubs.Set(db, 'instance_get_by_uuid', fake_instance_get_by_uuid)
self.stubs.Set(shelve, 'auth_shelve_offload', fake_auth_context)
self.stubs.Set(compute_api.API, 'shelve_offload',
fakes.fake_actions_to_locked_server)
req = fakes.HTTPRequestV3.blank('/123/servers/12/os-shelve')
self.assertRaises(webob.exc.HTTPConflict,
self.controller._shelve_offload,
req, str(uuid.uuid4()), {})

2
nova/tests/integrated/v3/test_shelve.py
View File

@@ -42,7 +42,7 @@ class ShelveJsonTest(test_servers.ServersSampleBase):
def test_shelve_offload(self):
uuid = self._post_server()
self._test_server_action(uuid, 'os-shelve', 'shelve')
self._test_server_action(uuid, 'os-shelve-offload', 'shelve_offload')
self._test_server_action(uuid, 'os-shelve-offload', 'shelveOffload')
def test_unshelve(self):
uuid = self._post_server()