openstack/deb-heat
Code Issues Proposed changes

Implement an "Action in progress" error.

Browse Source 
Raises an "Action in progress" error if an action is in progress when
another action is issued.

Fixes bug #1207032

Change-Id: I2b6fd92cfa4b93ac2531dd3d76bf2dfc01e58c50
This commit is contained in:
Jason Dunsmore 2013-08-01 12:37:29 -05:00
parent 05e421b03a
commit faf984cbb5
7 changed files with 151 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
heat/api/aws/exception.py
View File

@ -246,6 +246,15 @@ class HeatAPINotImplementedError(HeatAPIException):
err_type = "Server"
class HeatInvalidStateError(HeatAPIException):
'''
Cannot perform action on stack in its current state
'''
code = 400
title = 'InvalidAction'
explanation = "Cannot perform action on stack in its current state"
def map_remote_error(ex):
"""
Map rpc_common.RemoteError exceptions returned by the engine
@ -268,7 +277,8 @@ def map_remote_error(ex):
'UserParameterMissing',
)
denied_errors = ('Forbidden', 'NotAuthorized')
already_exists_errors = ('StackExists')
already_exists_errors = ('StackExists',)
invalid_state_errors = ('ActionInProgress',)
if ex.exc_type in inval_param_errors:
return HeatInvalidParameterValueError(detail=ex.value)
@ -276,6 +286,8 @@ def map_remote_error(ex):
return HeatAccessDeniedError(detail=ex.value)
elif ex.exc_type in already_exists_errors:
return AlreadyExistsError(detail=ex.value)
elif ex.exc_type in invalid_state_errors:
return HeatInvalidStateError(detail=ex.value)
else:
# Map everything else to internal server error for now
return HeatInternalFailureError(detail=ex.value)

1
heat/api/middleware/fault.py
View File

@ -55,6 +55,7 @@ class FaultWrapper(wsgi.Middleware):
error_map = {
'AttributeError': webob.exc.HTTPBadRequest,
'ActionInProgress': webob.exc.HTTPConflict,
'ValueError': webob.exc.HTTPBadRequest,
'StackNotFound': webob.exc.HTTPNotFound,
'ResourceNotFound': webob.exc.HTTPNotFound,

5
heat/common/exception.py
View File

@ -263,6 +263,11 @@ class WatchRuleNotFound(OpenstackException):
message = _("The Watch Rule (%(watch_name)s) could not be found.")
class ActionInProgress(OpenstackException):
message = _("Stack %(stack_name)s already has an action (%(action)s) "
"in progress")
class ResourceFailure(OpenstackException):
message = _("%(exc_type)s: %(message)s")

9
heat/engine/service.py
View File

@ -277,6 +277,10 @@ class EngineService(service.Service):
# Get the database representation of the existing stack
db_stack = self._get_stack(cnxt, stack_identity)
if db_stack.status != parser.Stack.COMPLETE:
raise exception.ActionInProgress(stack_name=db_stack.name,
action=db_stack.action)
current_stack = parser.Stack.load(cnxt, stack=db_stack)
# Now parse the template and any parameters for the updated
@ -378,8 +382,11 @@ class EngineService(service.Service):
"""
st = self._get_stack(cnxt, stack_identity)
logger.info('deleting stack %s' % st.name)
if st.status not in (parser.Stack.COMPLETE, parser.Stack.FAILED):
raise exception.ActionInProgress(stack_name=st.name,
action=st.action)
logger.info('deleting stack %s' % st.name)
stack = parser.Stack.load(cnxt, stack=st)
# Kill any pending threads by calling ThreadGroup.stop()

42
heat/tests/test_api_cfn_v1.py
View File

@ -821,6 +821,48 @@ class CfnStackControllerTest(HeatTestCase):
exception.AlreadyExistsError)
self.m.VerifyAll()
def test_invalid_state_err(self):
'''
Test that an ActionInProgress exception results in a
HeatInvalidStateError.
'''
# Format a dummy request
stack_name = "wordpress"
template = {u'Foo': u'bar'}
json_template = json.dumps(template)
params = {'Action': 'CreateStack', 'StackName': stack_name,
'TemplateBody': '%s' % json_template,
'TimeoutInMinutes': 30,
'Parameters.member.1.ParameterKey': 'InstanceType',
'Parameters.member.1.ParameterValue': 'm1.xlarge'}
engine_parms = {u'InstanceType': u'm1.xlarge'}
engine_args = {'timeout_mins': u'30'}
dummy_req = self._dummy_GET_request(params)
# Insert an engine RPC error and ensure we map correctly to the
# heat exception type
self.m.StubOutWithMock(rpc, 'call')
rpc.call(dummy_req.context, self.topic,
{'namespace': None,
'method': 'create_stack',
'args': {'stack_name': stack_name,
'template': template,
'params': engine_parms,
'files': {},
'args': engine_args},
'version': self.api_version}, None
).AndRaise(rpc_common.RemoteError("ActionInProgress"))
self.m.ReplayAll()
result = self.controller.create(dummy_req)
self.assertEqual(type(result),
exception.HeatInvalidStateError)
self.m.VerifyAll()
def test_create_err_engine(self):
# Format a dummy request
stack_name = "wordpress"

42
heat/tests/test_api_openstack_v1.py
View File

@ -957,6 +957,48 @@ class StackControllerTest(ControllerTest, HeatTestCase):
body=body)
self.m.VerifyAll()
def test_update_in_progress_err(self):
'''
Tests that the ActionInProgress exception results in an HTTPConflict.
'''
identity = identifier.HeatIdentifier(self.tenant, 'wordpress', '6')
template = {u'Foo': u'bar'}
parameters = {u'InstanceType': u'm1.xlarge'}
body = {'template': template,
'parameters': parameters,
'files': {},
'timeout_mins': 30}
req = self._put('/stacks/%(stack_name)s/%(stack_id)s' % identity,
json.dumps(body))
self.m.StubOutWithMock(rpc, 'call')
error = to_remote_error(heat_exc.ActionInProgress(stack_name="foo",
action="UPDATE"))
rpc.call(req.context, self.topic,
{'namespace': None,
'method': 'update_stack',
'args': {'stack_identity': dict(identity),
'template': template,
'params': {'parameters': parameters},
'files': {},
'args': {'timeout_mins': 30}},
'version': self.api_version},
None).AndRaise(error)
self.m.ReplayAll()
resp = request_with_middleware(fault.FaultWrapper,
self.controller.update,
req, tenant_id=identity.tenant,
stack_name=identity.stack_name,
stack_id=identity.stack_id,
body=body)
self.assertEqual(resp.json['code'], 409)
self.assertEqual(resp.json['title'], 'Conflict')
self.assertEqual(resp.json['error']['type'], 'ActionInProgress')
self.m.VerifyAll()
def test_update_bad_name(self):
identity = identifier.HeatIdentifier(self.tenant, 'wibble', '6')
template = {u'Foo': u'bar'}

49
heat/tests/test_engine_service.py
View File

@ -413,12 +413,8 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
def test_stack_delete(self):
stack_name = 'service_delete_test_stack'
stack = get_wordpress_stack(stack_name, self.ctx)
sid = stack.store()
s = db_api.stack_get(self.ctx, sid)
self.m.StubOutWithMock(parser.Stack, 'load')
parser.Stack.load(self.ctx, stack=s).AndReturn(stack)
stack.status = "COMPLETE"
stack.store()
self.man.tg = DummyThreadGroup()
@ -428,16 +424,29 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
self.man.delete_stack(self.ctx, stack.identifier()))
self.m.VerifyAll()
def test_stack_delete_action_in_progress_err(self):
'''
Test that deleting a stack with an action in progress results in
an ActionInProgress exception.
'''
stack_name = 'service_delete_action_in_progress_err'
stack = get_wordpress_stack(stack_name, self.ctx)
stack.status = "IN_PROGRESS"
stack.store()
self.assertRaises(exception.ActionInProgress,
self.man.delete_stack,
self.ctx,
stack.identifier())
def test_stack_delete_nonexist(self):
stack_name = 'service_delete_nonexist_test_stack'
stack = get_wordpress_stack(stack_name, self.ctx)
self.m.ReplayAll()
self.assertRaises(exception.StackNotFound,
self.man.delete_stack,
self.ctx, stack.identifier())
self.m.VerifyAll()
def test_stack_update(self):
stack_name = 'service_update_test_stack'
@ -445,6 +454,7 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
template = '{ "Template": "data" }'
old_stack = get_wordpress_stack(stack_name, self.ctx)
old_stack.status = 'COMPLETE'
sid = old_stack.store()
s = db_api.stack_get(self.ctx, sid)
@ -477,12 +487,33 @@ class StackServiceCreateUpdateDeleteTest(HeatTestCase):
self.assertTrue(result['stack_id'])
self.m.VerifyAll()
def test_stack_update_action_in_progress_err(self):
'''
Test that updating a stack with an action in progress results
in an ActionInProgress exception.
'''
stack_name = 'service_update_action_in_progress_err_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
old_stack = get_wordpress_stack(stack_name, self.ctx)
old_stack.status = 'IN_PROGRESS'
old_stack.store()
self.assertRaises(
exception.ActionInProgress,
self.man.update_stack,
self.ctx, old_stack.identifier(),
template, params, None, {})
def test_stack_update_verify_err(self):
stack_name = 'service_update_verify_err_test_stack'
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
old_stack = get_wordpress_stack(stack_name, self.ctx)
old_stack.status = 'COMPLETE'
old_stack.store()
sid = old_stack.store()
s = db_api.stack_get(self.ctx, sid)