openstack/nova
Code Issues Proposed changes

Merge "Change v3 shelve to v2.1"

Browse Source
This commit is contained in:
Jenkins
2014-08-31 06:49:44 +00:00
committed by Gerrit Code Review
parent 664f0972b9 9daf3bdd87
commit 094f8cd13f
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()