def _test_engine_service_stop(self, service_delete_method,
admin_context_method):
cfg.CONF.set_default('periodic_interval', 60)
self.patchobject(self.eng, 'service_manage_cleanup')
self.patchobject(self.eng, 'reset_stack_status')
self.patchobject(self.eng, 'service_manage_report')
self.eng.start()
# Add dummy thread group to test thread_group_mgr.stop() is executed?
dtg1 = tools.DummyThreadGroup()
dtg2 = tools.DummyThreadGroup()
self.eng.thread_group_mgr.groups['sample-uuid1'] = dtg1
self.eng.thread_group_mgr.groups['sample-uuid2'] = dtg2
self.eng.service_id = 'sample-service-uuid'
self.patchobject(self.eng.manage_thread_grp,
'stop',
new=mock.Mock(wraps=self.eng.manage_thread_grp.stop))
self.patchobject(self.eng,
'_stop_rpc_server',
new=mock.Mock(wraps=self.eng._stop_rpc_server))
orig_stop = self.eng.thread_group_mgr.stop
with mock.patch.object(self.eng.thread_group_mgr, 'stop') as stop:
stop.side_effect = orig_stop
self.eng.stop()
# RPC server
self.eng._stop_rpc_server.assert_called_once_with()
if cfg.CONF.convergence_engine:
# WorkerService
self.eng.worker_service.stop.assert_called_once_with()
# Wait for all active threads to be finished
calls = [
mock.call('sample-uuid1', True),
mock.call('sample-uuid2', True)
]
self.eng.thread_group_mgr.stop.assert_has_calls(calls, True)
# Manage Thread group
self.eng.manage_thread_grp.stop.assert_called_with()
# Service delete
admin_context_method.assert_called_once_with()
ctxt = admin_context_method.return_value
service_delete_method.assert_called_once_with(
ctxt, self.eng.service_id)
def test_set_watch_state(self, mock_ref):
self._create_periodic_tasks()
# Insert dummy watch rule into the DB
rule = {
u'EvaluationPeriods': u'1',
u'AlarmActions': [u'WebServerRestartPolicy'],
u'AlarmDescription': u'Restart the WikiDatabase',
u'Namespace': u'system/linux',
u'Period': u'300',
u'ComparisonOperator': u'GreaterThanThreshold',
u'Statistic': u'SampleCount',
u'Threshold': u'2',
u'MetricName': u'ServiceFailure'
}
self.wr = watchrule.WatchRule(context=self.ctx,
watch_name='OverrideAlarm',
rule=rule,
watch_data=[],
stack_id=self.stack.id,
state='NORMAL')
self.wr.store()
class DummyAction(object):
def signal(self):
return "dummyfoo"
dummy_action = DummyAction()
mock_ref.return_value = dummy_action
# Replace the real stack threadgroup with a dummy one, so we can
# check the function returned on ALARM is correctly scheduled
dtg = tools.DummyThreadGroup()
self.eng.thread_group_mgr.groups[self.stack.id] = dtg
state = watchrule.WatchRule.NODATA
result = self.eng.set_watch_state(self.ctx,
watch_name="OverrideAlarm",
state=state)
self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE])
self.assertEqual(
[], self.eng.thread_group_mgr.groups[self.stack.id].threads)
state = watchrule.WatchRule.NORMAL
result = self.eng.set_watch_state(self.ctx,
watch_name="OverrideAlarm",
state=state)
self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE])
self.assertEqual(
[], self.eng.thread_group_mgr.groups[self.stack.id].threads)
state = watchrule.WatchRule.ALARM
result = self.eng.set_watch_state(self.ctx,
watch_name="OverrideAlarm",
state=state)
self.assertEqual(state, result[rpc_api.WATCH_STATE_VALUE])
self.assertEqual(
[dummy_action.signal],
self.eng.thread_group_mgr.groups[self.stack.id].threads)
mock_ref.assert_called_once_with('WebServerRestartPolicy')
def test_stack_create_nested(self, mock_validate, mock_tg):
convergence_engine = cfg.CONF.convergence_engine
stack_name = 'service_create_nested_test_stack'
mock_tg.return_value = tools.DummyThreadGroup()
stk = tools.get_stack(stack_name, self.ctx, with_params=True)
tmpl_id = stk.t.store(self.ctx)
mock_load = self.patchobject(templatem.Template,
'load',
return_value=stk.t)
mock_stack = self.patchobject(stack, 'Stack', return_value=stk)
result = self.man.create_stack(self.ctx,
stack_name,
None,
None,
None, {},
nested_depth=1,
template_id=tmpl_id)
self.assertEqual(stk.identifier(), result)
self.assertIsInstance(result, dict)
self.assertTrue(result['stack_id'])
mock_load.assert_called_once_with(self.ctx, tmpl_id)
mock_stack.assert_called_once_with(self.ctx,
stack_name,
stk.t,
owner_id=None,
nested_depth=1,
user_creds_id=None,
stack_user_project_id=None,
convergence=convergence_engine,
parent_resource=None)
mock_validate.assert_called_once_with()
def _test_stack_create(self, stack_name, mock_validate, mock_tg):
mock_tg.return_value = tools.DummyThreadGroup()
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
stk = tools.get_stack(stack_name, self.ctx)
mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t)
mock_env = self.patchobject(environment,
'Environment',
return_value=stk.env)
mock_stack = self.patchobject(stack, 'Stack', return_value=stk)
result = self.man.create_stack(self.ctx, stack_name, template, params,
None, {})
self.assertEqual(stk.identifier(), result)
self.assertIsInstance(result, dict)
self.assertTrue(result['stack_id'])
mock_tmpl.assert_called_once_with(template, files=None, env=stk.env)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(self.ctx,
stack_name,
stk.t,
owner_id=None,
nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=False,
parent_resource=None)
mock_validate.assert_called_once_with()
def test_stack_delete_current_engine_active_lock(self, mock_acquire,
mock_try, mock_load):
self.man.start()
stack_name = 'service_delete_test_stack_current_active_lock'
stack = tools.get_stack(stack_name, self.ctx)
sid = stack.store()
# Insert a fake lock into the db
stack_lock_object.StackLock.create(stack.id, self.man.engine_id)
# Create a fake ThreadGroup too
self.man.thread_group_mgr.groups[stack.id] = tools.DummyThreadGroup()
st = stack_object.Stack.get_by_id(self.ctx, sid)
mock_load.return_value = stack
mock_try.return_value = self.man.engine_id
mock_stop = self.patchobject(self.man.thread_group_mgr, 'stop')
self.assertIsNone(self.man.delete_stack(self.ctx, stack.identifier()))
mock_load.assert_called_with(self.ctx, stack=st)
self.assertEqual(2, len(mock_load.mock_calls))
mock_try.assert_called_once_with()
mock_acquire.assert_called_once_with(True)
mock_stop.assert_called_once_with(stack.id)
def _test_stack_create(self,
stack_name,
mock_validate,
mock_tg,
environment_files=None,
files_container=None,
error=False):
mock_tg.return_value = tools.DummyThreadGroup()
params = {'foo': 'bar'}
template = '{ "Template": "data" }'
stk = tools.get_stack(stack_name,
self.ctx,
convergence=cfg.CONF.convergence_engine)
files = None
if files_container:
files = {'/env/test.yaml': "{'resource_registry': {}}"}
mock_tmpl = self.patchobject(templatem, 'Template', return_value=stk.t)
mock_env = self.patchobject(environment,
'Environment',
return_value=stk.env)
mock_stack = self.patchobject(stack, 'Stack', return_value=stk)
mock_merge = self.patchobject(env_util, 'merge_environments')
if not error:
result = self.man.create_stack(self.ctx,
stack_name,
template,
params,
None, {},
environment_files=environment_files,
files_container=files_container)
self.assertEqual(stk.identifier(), result)
self.assertIsInstance(result, dict)
self.assertTrue(result['stack_id'])
mock_tmpl.assert_called_once_with(template, files=files)
mock_env.assert_called_once_with(params)
mock_stack.assert_called_once_with(
self.ctx,
stack_name,
stk.t,
owner_id=None,
nested_depth=0,
user_creds_id=None,
stack_user_project_id=None,
convergence=cfg.CONF.convergence_engine,
parent_resource=None)
if environment_files:
mock_merge.assert_called_once_with(environment_files, files,
params, mock.ANY)
mock_validate.assert_called_once_with()
else:
ex = self.assertRaises(dispatcher.ExpectedException,
self.man.create_stack,
self.ctx,
stack_name,
template,
params,
None, {},
environment_files=environment_files,
files_container=files_container)
self.assertEqual(exception.NotFound, ex.exc_info[0])
self.assertIn(
'Could not fetch files from container '
'test_container, reason: error.',
six.text_type(ex.exc_info[1]))
