def test_do_next_deploy_step_bad_step_return_value(self, mock_execute):
# When a deploy step fails, go to DEPLOYFAIL
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
driver_internal_info={'deploy_steps': self.deploy_steps,
'deploy_step_index': None},
deploy_step={})
mock_execute.return_value = "foo"
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, 0, self.service.conductor.id)
# Make sure we go to DEPLOYFAIL, clear deploy_steps
node.refresh()
self.assertEqual(states.DEPLOYFAIL, node.provision_state)
self.assertEqual(states.ACTIVE, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertIsNotNone(node.last_error)
self.assertFalse(node.maintenance)
mock_execute.assert_called_once_with(mock.ANY, mock.ANY,
self.deploy_steps[0])
def test_do_next_deploy_step_oob_reboot_fail(self, mock_execute):
# When a deploy step fails with no reboot requested go to DEPLOYFAIL
tgt_prov_state = states.ACTIVE
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
provision_state=states.DEPLOYING,
target_provision_state=tgt_prov_state,
last_error=None,
driver_internal_info={'deploy_steps': self.deploy_steps,
'deploy_step_index': None},
deploy_step={})
mock_execute.side_effect = exception.AgentConnectionFailed(
reason='failed')
with task_manager.acquire(
self.context, node.uuid, shared=False) as task:
deployments.do_next_deploy_step(task, 0, mock.ANY)
self._stop_service()
node.refresh()
# Make sure we go to DEPLOYFAIL, clear deploy_steps
self.assertEqual(states.DEPLOYFAIL, node.provision_state)
self.assertEqual(tgt_prov_state, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertNotIn('skip_current_deploy_step', node.driver_internal_info)
self.assertIsNotNone(node.last_error)
mock_execute.assert_called_once_with(
mock.ANY, mock.ANY, self.deploy_steps[0])
def test__do_next_deploy_step_fast_track(self, mock_execute):
self.config(fast_track=True, group='deploy')
# Run all steps from start to finish (all synchronous)
driver_internal_info = {'deploy_step_index': None,
'deploy_steps': self.deploy_steps,
'agent_url': 'url',
'agent_secret_token': 'token'}
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
driver_internal_info=driver_internal_info,
deploy_step={})
mock_execute.return_value = None
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, 0, self.service.conductor.id)
# Deploying should be complete
node.refresh()
self.assertEqual(states.ACTIVE, node.provision_state)
self.assertEqual(states.NOSTATE, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertIsNone(node.driver_internal_info['deploy_steps'])
mock_execute.assert_has_calls(
[mock.call(task.driver.deploy, task, self.deploy_steps[0]),
mock.call(task.driver.deploy, task, self.deploy_steps[1])])
self.assertEqual('url', node.driver_internal_info['agent_url'])
self.assertEqual('token',
node.driver_internal_info['agent_secret_token'])
def test_do_next_deploy_step_no_steps(self, mock_execute):
self._start_service()
for info in ({'deploy_steps': None, 'deploy_step_index': None},
{'deploy_steps': None}):
# Resume where there are no steps, should be a noop
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
uuid=uuidutils.generate_uuid(),
last_error=None,
driver_internal_info=info,
deploy_step={})
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, None,
self.service.conductor.id)
# Deploying should be complete without calling additional steps
node.refresh()
self.assertEqual(states.ACTIVE, node.provision_state)
self.assertEqual(states.NOSTATE, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertFalse(mock_execute.called)
mock_execute.reset_mock()
def test__do_next_deploy_step_continue_from_last_step(self, mock_execute):
# Resume an in-progress deploy after the first async step
driver_internal_info = {'deploy_step_index': 0,
'deploy_steps': self.deploy_steps}
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
provision_state=states.DEPLOYWAIT,
target_provision_state=states.ACTIVE,
driver_internal_info=driver_internal_info,
deploy_step=self.deploy_steps[0])
mock_execute.return_value = states.DEPLOYWAIT
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('resume')
deployments.do_next_deploy_step(task, 1, self.service.conductor.id)
node.refresh()
self.assertEqual(states.DEPLOYWAIT, node.provision_state)
self.assertEqual(states.ACTIVE, node.target_provision_state)
self.assertEqual(self.deploy_steps[1], node.deploy_step)
self.assertEqual(1, node.driver_internal_info['deploy_step_index'])
mock_execute.assert_called_once_with(mock.ANY, task,
self.deploy_steps[1])
def _test__do_next_deploy_step_last_step_done(self, mock_execute,
mock_console,
console_enabled=False,
console_error=False):
# Resume where last_step is the last deploy step that was executed
driver_internal_info = {'deploy_step_index': 1,
'deploy_steps': self.deploy_steps}
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
provision_state=states.DEPLOYWAIT,
target_provision_state=states.ACTIVE,
driver_internal_info=driver_internal_info,
deploy_step=self.deploy_steps[1],
console_enabled=console_enabled)
mock_execute.return_value = None
if console_error:
mock_console.side_effect = exception.ConsoleError()
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('resume')
deployments.do_next_deploy_step(task, None, self.service.conductor.id)
node.refresh()
# Deploying should be complete without calling additional steps
self.assertEqual(states.ACTIVE, node.provision_state)
self.assertEqual(states.NOSTATE, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertIsNone(node.driver_internal_info['deploy_steps'])
self.assertFalse(mock_execute.called)
if console_enabled:
mock_console.assert_called_once_with(mock.ANY, task)
else:
self.assertFalse(mock_console.called)
def test__do_next_deploy_step_in_deploywait(self, mock_execute):
driver_internal_info = {'deploy_step_index': None,
'deploy_steps': self.deploy_steps}
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
driver_internal_info=driver_internal_info,
deploy_step={})
def fake_execute(interface, task, step):
# A deploy step leaves the node in DEPLOYWAIT
task.process_event('wait')
return states.DEPLOYWAIT
mock_execute.side_effect = fake_execute
expected_first_step = node.driver_internal_info['deploy_steps'][0]
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, 0, self.service.conductor.id)
node.refresh()
self.assertIsNone(node.last_error)
self.assertEqual(states.DEPLOYWAIT, node.provision_state)
self.assertEqual(states.ACTIVE, node.target_provision_state)
self.assertEqual(expected_first_step, node.deploy_step)
self.assertEqual(0, node.driver_internal_info['deploy_step_index'])
self.assertEqual(self.service.conductor.id, node.conductor_affinity)
mock_execute.assert_called_once_with(mock.ANY, task,
self.deploy_steps[0])
def test_do_next_deploy_step_agent_busy(self, mock_execute):
# When a deploy step fails, go to DEPLOYWAIT
tgt_prov_state = states.ACTIVE
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
provision_state=states.DEPLOYING,
target_provision_state=tgt_prov_state,
last_error=None,
driver_internal_info={'deploy_steps': self.deploy_steps,
'deploy_step_index': None,
'deployment_reboot': True},
clean_step={})
mock_execute.side_effect = exception.AgentInProgress(
reason='meow')
with task_manager.acquire(
self.context, node.uuid, shared=False) as task:
deployments.do_next_deploy_step(task, 0)
self._stop_service()
node.refresh()
# Make sure we go to DEPLOYWAIT
self.assertEqual(states.DEPLOYWAIT, node.provision_state)
self.assertEqual(tgt_prov_state, node.target_provision_state)
self.assertEqual(self.deploy_steps[0], node.deploy_step)
self.assertEqual(0, node.driver_internal_info['deploy_step_index'])
self.assertFalse(node.driver_internal_info['skip_current_deploy_step'])
mock_execute.assert_called_once_with(
mock.ANY, mock.ANY, self.deploy_steps[0])
def _do_next_deploy_step_execute_fail(self, exc, traceback,
mock_execute, mock_log):
# When a deploy step fails, go to DEPLOYFAIL
driver_internal_info = {'deploy_step_index': None,
'deploy_steps': self.deploy_steps}
self._start_service()
node = obj_utils.create_test_node(
self.context, driver='fake-hardware',
driver_internal_info=driver_internal_info,
deploy_step={})
mock_execute.side_effect = exc
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, 0)
# Make sure we go to DEPLOYFAIL, clear deploy_steps
node.refresh()
self.assertEqual(states.DEPLOYFAIL, node.provision_state)
self.assertEqual(states.ACTIVE, node.target_provision_state)
self.assertEqual({}, node.deploy_step)
self.assertNotIn('deploy_step_index', node.driver_internal_info)
self.assertIsNotNone(node.last_error)
self.assertFalse(node.maintenance)
mock_execute.assert_called_once_with(mock.ANY, mock.ANY,
self.deploy_steps[0])
mock_log.error.assert_called_once_with(mock.ANY, exc_info=traceback)
def test__do_next_deploy_step_async(self, mock_execute):
driver_internal_info = {
'deploy_step_index': None,
'deploy_steps': self.deploy_steps
}
self._start_service()
node = obj_utils.create_test_node(
self.context,
driver='fake-hardware',
driver_internal_info=driver_internal_info,
deploy_step={})
mock_execute.return_value = states.DEPLOYWAIT
expected_first_step = node.driver_internal_info['deploy_steps'][0]
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, 0, self.service.conductor.id)
node.refresh()
self.assertEqual(states.DEPLOYWAIT, node.provision_state)
self.assertEqual(states.ACTIVE, node.target_provision_state)
self.assertEqual(expected_first_step, node.deploy_step)
self.assertEqual(0, node.driver_internal_info['deploy_step_index'])
self.assertEqual(self.service.conductor.id, node.conductor_affinity)
mock_execute.assert_called_once_with(mock.ANY, task,
self.deploy_steps[0])
def test__do_next_deploy_step_none(self, mock_log):
self._start_service()
node = obj_utils.create_test_node(self.context, driver='fake-hardware')
task = task_manager.TaskManager(self.context, node.uuid)
task.process_event('deploy')
deployments.do_next_deploy_step(task, None, self.service.conductor.id)
node.refresh()
self.assertEqual(states.ACTIVE, node.provision_state)
self.assertEqual(2, mock_log.info.call_count)
