diff --git a/ironic/conductor/deployments.py b/ironic/conductor/deployments.py
index 20c3c15b66..c04b578d62 100644
--- a/ironic/conductor/deployments.py
+++ b/ironic/conductor/deployments.py
@@ -18,13 +18,11 @@ from ironic_lib import metrics_utils
from oslo_db import exception as db_exception
from oslo_log import log
from oslo_utils import excutils
-from oslo_utils import versionutils
from ironic.common import exception
from ironic.common.glance_service import service_utils as glance_utils
from ironic.common.i18n import _
from ironic.common import images
-from ironic.common import release_mappings as versions
from ironic.common import states
from ironic.common import swift
from ironic.conductor import notification_utils as notify_utils
@@ -38,10 +36,6 @@ LOG = log.getLogger(__name__)
METRICS = metrics_utils.get_metrics_logger(__name__)
-# NOTE(rloo) This is used to keep track of deprecation warnings that have
-# already been issued for deploy drivers that do not use deploy steps.
-_SEEN_NO_DEPLOY_STEP_DEPRECATIONS = set()
-
def validate_node(task, event='deploy'):
"""Validate that a node is suitable for deployment/rebuilding.
@@ -202,97 +196,7 @@ def do_node_deploy(task, conductor_id=None, configdrive=None):
'%(node)s. Error: %(err)s' % {'node': node.uuid, 'err': e},
_("Cannot get deploy steps; failed to deploy: %s") % e)
- steps = node.driver_internal_info.get('deploy_steps', [])
-
- new_rpc_version = True
- release_ver = versions.RELEASE_MAPPING.get(CONF.pin_release_version)
- if release_ver:
- new_rpc_version = versionutils.is_compatible('1.45',
- release_ver['rpc'])
-
- if not steps or not new_rpc_version:
- # TODO(rloo): This if.. (and the above code wrt rpc version)
- # can be deleted after the deprecation period when we no
- # longer support drivers with no deploy steps.
- # Note that after the deprecation period, there needs to be at least
- # one deploy step. If none, the deployment fails.
-
- if steps:
- info = node.driver_internal_info
- info.pop('deploy_steps')
- node.driver_internal_info = info
- node.save()
-
- # We go back to using the old way, if:
- # - out-of-tree driver hasn't yet converted to using deploy steps, or
- # - we're in the middle of a rolling upgrade. This is to prevent the
- # corner case of having new conductors with old conductors, and
- # a node is deployed with a new conductor (via deploy steps), but
- # after the deploy_wait, the node gets handled by an old conductor.
- # To avoid this, we need to wait until all the conductors are new,
- # signalled by the RPC API version being '1.45'.
- _old_rest_of_do_node_deploy(task, conductor_id, not steps)
- else:
- do_next_deploy_step(task, 0, conductor_id)
-
-
-def _old_rest_of_do_node_deploy(task, conductor_id, no_deploy_steps):
- """The rest of the do_node_deploy() if not using deploy steps.
-
- To support out-of-tree drivers that have not yet migrated to using
- deploy steps.
-
- :param no_deploy_steps: Boolean; True if there are no deploy steps.
- """
- # TODO(rloo): This method can be deleted after the deprecation period
- # for supporting drivers with no deploy steps.
-
- if no_deploy_steps:
- deploy_driver_name = task.driver.deploy.__class__.__name__
- if deploy_driver_name not in _SEEN_NO_DEPLOY_STEP_DEPRECATIONS:
- LOG.warning('Deploy driver %s does not support deploy steps; this '
- 'will be required starting with the Stein release.',
- deploy_driver_name)
- _SEEN_NO_DEPLOY_STEP_DEPRECATIONS.add(deploy_driver_name)
-
- node = task.node
- try:
- new_state = task.driver.deploy.deploy(task)
- except exception.IronicException as e:
- with excutils.save_and_reraise_exception():
- utils.deploying_error_handler(
- task,
- ('Error in deploy of node %(node)s: %(err)s' %
- {'node': node.uuid, 'err': e}),
- _("Failed to deploy: %s") % e)
- except Exception as e:
- with excutils.save_and_reraise_exception():
- utils.deploying_error_handler(
- task,
- ('Unexpected error while deploying node %(node)s' %
- {'node': node.uuid}),
- _("Failed to deploy. Exception: %s") % e,
- traceback=True)
-
- # Update conductor_affinity to reference this conductor's ID
- # since there may be local persistent state
- node.conductor_affinity = conductor_id
-
- # NOTE(deva): Some drivers may return states.DEPLOYWAIT
- # eg. if they are waiting for a callback
- if new_state == states.DEPLOYDONE:
- _start_console_in_deploy(task)
- task.process_event('done')
- LOG.info('Successfully deployed node %(node)s with '
- 'instance %(instance)s.',
- {'node': node.uuid, 'instance': node.instance_uuid})
- elif new_state == states.DEPLOYWAIT:
- task.process_event('wait')
- else:
- LOG.error('Unexpected state %(state)s returned while '
- 'deploying node %(node)s.',
- {'state': new_state, 'node': node.uuid})
- node.save()
+ do_next_deploy_step(task, 0, conductor_id)
@task_manager.require_exclusive_lock
diff --git a/ironic/drivers/modules/agent_base.py b/ironic/drivers/modules/agent_base.py
index f7975c25ce..5c4f94f046 100644
--- a/ironic/drivers/modules/agent_base.py
+++ b/ironic/drivers/modules/agent_base.py
@@ -334,11 +334,6 @@ class HeartbeatMixin(object):
:param task: a TaskManager instance
:returns: True if the current deploy step is deploy.deploy.
"""
- # TODO(mgoddard): Remove this 'if' in the Train release, after the
- # deprecation period for supporting drivers with no deploy steps.
- if not task.node.driver_internal_info.get('deploy_steps'):
- return True
-
step = task.node.deploy_step
return (step
and step['interface'] == 'deploy'
@@ -851,15 +846,7 @@ class AgentDeployMixin(HeartbeatMixin):
# powered off.
log_and_raise_deployment_error(task, msg, collect_logs=False,
exc=e)
-
- if not node.deploy_step:
- # TODO(rloo): delete this 'if' part after deprecation period, when
- # we expect all (out-of-tree) drivers to support deploy steps.
- # After which we will always notify_conductor_resume_deploy().
- task.process_event('done')
- LOG.info('Deployment to node %s done', task.node.uuid)
- else:
- manager_utils.notify_conductor_resume_deploy(task)
+ manager_utils.notify_conductor_resume_deploy(task)
@METRICS.timer('AgentDeployMixin.prepare_instance_to_boot')
def prepare_instance_to_boot(self, task, root_uuid, efi_sys_uuid,
diff --git a/ironic/drivers/modules/ansible/deploy.py b/ironic/drivers/modules/ansible/deploy.py
index db2a1e4183..4a1a478d8f 100644
--- a/ironic/drivers/modules/ansible/deploy.py
+++ b/ironic/drivers/modules/ansible/deploy.py
@@ -608,14 +608,7 @@ class AnsibleDeploy(agent_base.HeartbeatMixin, base.DeployInterface):
self.reboot_and_finish_deploy(task)
task.driver.boot.clean_up_ramdisk(task)
- if not node.deploy_step:
- # TODO(rloo): delete this 'if' part after deprecation period, when
- # we expect all (out-of-tree) drivers to support deploy steps.
- # After which we will always notify_conductor_resume_deploy().
- task.process_event('done')
- LOG.info('Deployment to node %s done', task.node.uuid)
- else:
- manager_utils.notify_conductor_resume_deploy(task)
+ manager_utils.notify_conductor_resume_deploy(task)
@METRICS.timer('AnsibleDeploy.reboot_and_finish_deploy')
def reboot_and_finish_deploy(self, task):
diff --git a/ironic/tests/unit/conductor/test_deployments.py b/ironic/tests/unit/conductor/test_deployments.py
index 6d71adfe6b..b81b529a3c 100644
--- a/ironic/tests/unit/conductor/test_deployments.py
+++ b/ironic/tests/unit/conductor/test_deployments.py
@@ -86,59 +86,6 @@ class DoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase):
self.assertTrue(mock_prepare.called)
self.assertFalse(mock_deploy.called)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test__do_node_deploy_driver_raises_error_old(self, mock_deploy):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- self._start_service()
- # test when driver.deploy.deploy raises an ironic error
- mock_deploy.side_effect = exception.InstanceDeployFailure('test')
- node = obj_utils.create_test_node(self.context, driver='fake-hardware',
- provision_state=states.DEPLOYING,
- target_provision_state=states.ACTIVE)
- task = task_manager.TaskManager(self.context, node.uuid)
-
- self.assertRaises(exception.InstanceDeployFailure,
- deployments.do_node_deploy, task,
- self.service.conductor.id)
- node.refresh()
- self.assertEqual(states.DEPLOYFAIL, node.provision_state)
- # NOTE(deva): failing a deploy does not clear the target state
- # any longer. Instead, it is cleared when the instance
- # is deleted.
- self.assertEqual(states.ACTIVE, node.target_provision_state)
- self.assertIsNotNone(node.last_error)
- mock_deploy.assert_called_once_with(mock.ANY)
-
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test__do_node_deploy_driver_unexpected_exception_old(self,
- mock_deploy):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- self._start_service()
- # test when driver.deploy.deploy raises an exception
- mock_deploy.side_effect = RuntimeError('test')
- node = obj_utils.create_test_node(self.context, driver='fake-hardware',
- provision_state=states.DEPLOYING,
- target_provision_state=states.ACTIVE)
- task = task_manager.TaskManager(self.context, node.uuid)
-
- self.assertRaises(RuntimeError,
- deployments.do_node_deploy, task,
- self.service.conductor.id)
- node.refresh()
- self.assertEqual(states.DEPLOYFAIL, node.provision_state)
- # NOTE(deva): failing a deploy does not clear the target state
- # any longer. Instead, it is cleared when the instance
- # is deleted.
- self.assertEqual(states.ACTIVE, node.target_provision_state)
- self.assertIsNotNone(node.last_error)
- mock_deploy.assert_called_once_with(mock.ANY)
-
def _test__do_node_deploy_driver_exception(self, exc, unexpected=False):
self._start_service()
with mock.patch.object(fake.FakeDeploy,
@@ -174,55 +121,6 @@ class DoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase):
self._test__do_node_deploy_driver_exception(RuntimeError('test'),
unexpected=True)
- @mock.patch.object(deployments, '_store_configdrive', autospec=True)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test__do_node_deploy_ok_old(self, mock_deploy, mock_store):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- self._start_service()
- # test when driver.deploy.deploy returns DEPLOYDONE
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(self.context, driver='fake-hardware',
- provision_state=states.DEPLOYING,
- target_provision_state=states.ACTIVE)
- task = task_manager.TaskManager(self.context, node.uuid)
-
- deployments.do_node_deploy(task, self.service.conductor.id)
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- self.assertIsNone(node.last_error)
- mock_deploy.assert_called_once_with(mock.ANY)
- # assert _store_configdrive wasn't invoked
- self.assertFalse(mock_store.called)
-
- @mock.patch.object(deployments, '_store_configdrive', autospec=True)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test__do_node_deploy_ok_configdrive_old(self, mock_deploy, mock_store):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- self._start_service()
- # test when driver.deploy.deploy returns DEPLOYDONE
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(self.context, driver='fake-hardware',
- provision_state=states.DEPLOYING,
- target_provision_state=states.ACTIVE)
- task = task_manager.TaskManager(self.context, node.uuid)
- configdrive = 'foo'
-
- deployments.do_node_deploy(task, self.service.conductor.id,
- configdrive=configdrive)
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- self.assertIsNone(node.last_error)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_store.assert_called_once_with(task.node, configdrive)
-
@mock.patch.object(deployments, '_store_configdrive', autospec=True)
def _test__do_node_deploy_ok(self, mock_store, configdrive=None,
expected_configdrive=None):
@@ -396,28 +294,6 @@ class DoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase):
self.assertIsNotNone(node.last_error)
self.assertFalse(mock_prepare.called)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test__do_node_deploy_ok_2_old(self, mock_deploy):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- # NOTE(rloo): a different way of testing for the same thing as in
- # test__do_node_deploy_ok()
- self._start_service()
- # test when driver.deploy.deploy returns DEPLOYDONE
- mock_deploy.return_value = states.DEPLOYDONE
- 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_node_deploy(task, self.service.conductor.id)
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- self.assertIsNone(node.last_error)
- mock_deploy.assert_called_once_with(mock.ANY)
-
def test__do_node_deploy_ok_2(self):
# NOTE(rloo): a different way of testing for the same thing as in
# test__do_node_deploy_ok(). Instead of specifying the provision &
@@ -441,33 +317,9 @@ class DoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase):
mock_deploy.assert_called_once_with(mock.ANY, mock.ANY)
@mock.patch.object(deployments, 'do_next_deploy_step', autospec=True)
- @mock.patch.object(deployments, '_old_rest_of_do_node_deploy',
- autospec=True)
@mock.patch.object(conductor_steps, 'set_node_deployment_steps',
autospec=True)
- def test_do_node_deploy_deprecated(self, mock_set_steps, mock_old_way,
- mock_deploy_step):
- # TODO(rloo): no deploy steps; delete this when we remove support
- # for handling no deploy steps.
- 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_node_deploy(task, self.service.conductor.id)
- mock_set_steps.assert_called_once_with(task)
- mock_old_way.assert_called_once_with(task, self.service.conductor.id,
- True)
- self.assertFalse(mock_deploy_step.called)
- self.assertNotIn('deploy_steps', task.node.driver_internal_info)
-
- @mock.patch.object(deployments, 'do_next_deploy_step', autospec=True)
- @mock.patch.object(deployments, '_old_rest_of_do_node_deploy',
- autospec=True)
- @mock.patch.object(conductor_steps, 'set_node_deployment_steps',
- autospec=True)
- def test_do_node_deploy_steps(self, mock_set_steps, mock_old_way,
- mock_deploy_step):
+ def test_do_node_deploy_steps(self, mock_set_steps, mock_deploy_step):
# these are not real steps...
fake_deploy_steps = ['step1', 'step2']
@@ -485,113 +337,10 @@ class DoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin, db_base.DbTestCase):
deployments.do_node_deploy(task, self.service.conductor.id)
mock_set_steps.assert_called_once_with(task)
- self.assertFalse(mock_old_way.called)
mock_set_steps.assert_called_once_with(task)
self.assertEqual(fake_deploy_steps,
task.node.driver_internal_info['deploy_steps'])
- @mock.patch.object(deployments, 'do_next_deploy_step', autospec=True)
- @mock.patch.object(deployments, '_old_rest_of_do_node_deploy',
- autospec=True)
- @mock.patch.object(conductor_steps, 'set_node_deployment_steps',
- autospec=True)
- def test_do_node_deploy_steps_old_rpc(self, mock_set_steps, mock_old_way,
- mock_deploy_step):
- # TODO(rloo): old RPC; delete this when we remove support for drivers
- # with no deploy steps.
- CONF.set_override('pin_release_version', '11.0')
- # these are not real steps...
- fake_deploy_steps = ['step1', 'step2']
-
- def add_steps(task):
- info = task.node.driver_internal_info
- info['deploy_steps'] = fake_deploy_steps
- task.node.driver_internal_info = info
- task.node.save()
-
- mock_set_steps.side_effect = add_steps
- 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_node_deploy(task, self.service.conductor.id)
- mock_set_steps.assert_called_once_with(task)
- mock_old_way.assert_called_once_with(task, self.service.conductor.id,
- False)
- self.assertFalse(mock_deploy_step.called)
- self.assertNotIn('deploy_steps', task.node.driver_internal_info)
-
- @mock.patch.object(deployments, '_SEEN_NO_DEPLOY_STEP_DEPRECATIONS',
- autospec=True)
- @mock.patch.object(deployments, 'LOG', autospec=True)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy', autospec=True)
- def test__old_rest_of_do_node_deploy_no_steps(self, mock_deploy, mock_log,
- mock_deprecate):
- # TODO(rloo): no deploy steps; delete this when we remove support
- # for handling no deploy steps.
- mock_deprecate.__contains__.side_effect = [False, True]
- 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._old_rest_of_do_node_deploy(
- task, self.service.conductor.id, True)
- mock_deploy.assert_called_once_with(mock.ANY, task)
- self.assertTrue(mock_log.warning.called)
- self.assertEqual(self.service.conductor.id,
- task.node.conductor_affinity)
- mock_deprecate.__contains__.assert_called_once_with('FakeDeploy')
- mock_deprecate.add.assert_called_once_with('FakeDeploy')
-
- # Make sure the deprecation warning isn't logged again
- mock_log.reset_mock()
- mock_deprecate.add.reset_mock()
- deployments._old_rest_of_do_node_deploy(
- task, self.service.conductor.id, True)
- self.assertFalse(mock_log.warning.called)
- mock_deprecate.__contains__.assert_has_calls(
- [mock.call('FakeDeploy'), mock.call('FakeDeploy')])
- self.assertFalse(mock_deprecate.add.called)
-
- @mock.patch.object(deployments, 'LOG', autospec=True)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy', autospec=True)
- def test__old_rest_of_do_node_deploy_has_steps(self, mock_deploy,
- mock_log):
- # TODO(rloo): has steps but old RPC; delete this when we remove support
- # for handling no deploy steps.
- deployments._SEEN_NO_DEPLOY_STEP_DEPRECATIONS = set()
- 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._old_rest_of_do_node_deploy(
- task, self.service.conductor.id, False)
- mock_deploy.assert_called_once_with(mock.ANY, task)
- self.assertFalse(mock_log.warning.called)
- self.assertEqual(self.service.conductor.id,
- task.node.conductor_affinity)
-
- @mock.patch('ironic.conductor.deployments._start_console_in_deploy',
- autospec=True)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy', autospec=True)
- def test__old_rest_of_do_node_deploy_console(self, mock_deploy,
- mock_console):
- 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')
- mock_deploy.return_value = states.DEPLOYDONE
-
- deployments._old_rest_of_do_node_deploy(
- task, self.service.conductor.id, True)
- mock_deploy.assert_called_once_with(mock.ANY, task)
- mock_console.assert_called_once_with(task)
- self.assertEqual(self.service.conductor.id,
- task.node.conductor_affinity)
-
@mgr_utils.mock_record_keepalive
class DoNextDeployStepTestCase(mgr_utils.ServiceSetUpMixin,
diff --git a/ironic/tests/unit/conductor/test_manager.py b/ironic/tests/unit/conductor/test_manager.py
index eba6766ec2..285317f31b 100644
--- a/ironic/tests/unit/conductor/test_manager.py
+++ b/ironic/tests/unit/conductor/test_manager.py
@@ -1431,157 +1431,6 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
self.assertNotIn('agent_url', node.driver_internal_info)
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test_do_node_deploy_rebuild_active_state_old(self, mock_deploy,
- mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- # This tests manager._old_rest_of_do_node_deploy(), the 'else' path of
- # 'if new_state == states.DEPLOYDONE'. The node's states
- # aren't changed in this case.
- mock_iwdi.return_value = True
- self._start_service()
- mock_deploy.return_value = states.DEPLOYING
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- provision_state=states.ACTIVE,
- target_provision_state=states.NOSTATE,
- instance_info={'image_source': uuidutils.generate_uuid(),
- 'kernel': 'aaaa', 'ramdisk': 'bbbb'},
- driver_internal_info={'is_whole_disk_image': False})
-
- self.service.do_node_deploy(self.context, node.uuid, rebuild=True)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.DEPLOYING, node.provision_state)
- self.assertEqual(states.ACTIVE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- # Verify instance_info values has been cleared.
- self.assertNotIn('kernel', node.instance_info)
- self.assertNotIn('ramdisk', node.instance_info)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- # Verify is_whole_disk_image reflects correct value on rebuild.
- self.assertTrue(node.driver_internal_info['is_whole_disk_image'])
-
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test_do_node_deploy_rebuild_active_state_waiting_old(self, mock_deploy,
- mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- mock_iwdi.return_value = False
- self._start_service()
- mock_deploy.return_value = states.DEPLOYWAIT
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- provision_state=states.ACTIVE,
- target_provision_state=states.NOSTATE,
- instance_info={'image_source': uuidutils.generate_uuid()})
-
- self.service.do_node_deploy(self.context, node.uuid, rebuild=True)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.DEPLOYWAIT, node.provision_state)
- self.assertEqual(states.ACTIVE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
-
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test_do_node_deploy_rebuild_active_state_done_old(self, mock_deploy,
- mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- mock_iwdi.return_value = False
- self._start_service()
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- provision_state=states.ACTIVE,
- target_provision_state=states.NOSTATE)
-
- self.service.do_node_deploy(self.context, node.uuid, rebuild=True)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
-
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test_do_node_deploy_rebuild_deployfail_state_old(self, mock_deploy,
- mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- mock_iwdi.return_value = False
- self._start_service()
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- provision_state=states.DEPLOYFAIL,
- target_provision_state=states.NOSTATE)
-
- self.service.do_node_deploy(self.context, node.uuid, rebuild=True)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
-
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- def test_do_node_deploy_rebuild_error_state_old(self, mock_deploy,
- mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- mock_iwdi.return_value = False
- self._start_service()
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- provision_state=states.ERROR,
- target_provision_state=states.NOSTATE)
-
- self.service.do_node_deploy(self.context, node.uuid, rebuild=True)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
-
def test_do_node_deploy_rebuild_active_state_error(self, mock_iwdi):
# Tests manager.do_node_deploy() & deployments.do_next_deploy_step(),
# when getting an unexpected state returned from a deploy_step.
@@ -1589,10 +1438,8 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self._start_service()
# NOTE(rloo): We have to mock this here as opposed to using a
# decorator. With a decorator, when initialization is done, the
- # mocked deploy() method isn't considered a deploy step, causing
- # manager._old_rest_of_do_node_deploy() to be run instead of
- # deployments.do_next_deploy_step(). So we defer mock'ing until after
- # the init is done.
+ # mocked deploy() method isn't considered a deploy step. So we defer
+ # mock'ing until after the init is done.
with mock.patch.object(fake.FakeDeploy,
'deploy', autospec=True) as mock_deploy:
mock_deploy.return_value = states.DEPLOYING
@@ -1626,10 +1473,8 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self._start_service()
# NOTE(rloo): We have to mock this here as opposed to using a
# decorator. With a decorator, when initialization is done, the
- # mocked deploy() method isn't considered a deploy step, causing
- # manager._old_rest_of_do_node_deploy() to be run instead of
- # deployments.do_next_deploy_step(). So we defer mock'ing until after
- # the init is done.
+ # mocked deploy() method isn't considered a deploy step. So we defer
+ # mock'ing until after the init is done.
with mock.patch.object(fake.FakeDeploy,
'deploy', autospec=True) as mock_deploy:
mock_deploy.return_value = states.DEPLOYWAIT
@@ -1658,10 +1503,8 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self._start_service()
# NOTE(rloo): We have to mock this here as opposed to using a
# decorator. With a decorator, when initialization is done, the
- # mocked deploy() method isn't considered a deploy step, causing
- # manager._old_rest_of_do_node_deploy() to be run instead of
- # deployments.do_next_deploy_step(). So we defer mock'ing until after
- # the init is done.
+ # mocked deploy() method isn't considered a deploy step. So we defer
+ # mock'ing until after the init is done.
with mock.patch.object(fake.FakeDeploy,
'deploy', autospec=True) as mock_deploy:
mock_deploy.return_value = None
@@ -1689,10 +1532,8 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self._start_service()
# NOTE(rloo): We have to mock this here as opposed to using a
# decorator. With a decorator, when initialization is done, the
- # mocked deploy() method isn't considered a deploy step, causing
- # manager._old_rest_of_do_node_deploy() to be run instead of
- # deployments.do_next_deploy_step(). So we defer mock'ing until after
- # the init is done.
+ # mocked deploy() method isn't considered a deploy step. So we defer
+ # mock'ing until after the init is done.
with mock.patch.object(fake.FakeDeploy,
'deploy', autospec=True) as mock_deploy:
mock_deploy.return_value = None
@@ -1720,10 +1561,8 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
self._start_service()
# NOTE(rloo): We have to mock this here as opposed to using a
# decorator. With a decorator, when initialization is done, the
- # mocked deploy() method isn't considered a deploy step, causing
- # manager._old_rest_of_do_node_deploy() to be run instead of
- # deployments.do_next_deploy_step(). So we defer mock'ing until after
- # the init is done.
+ # mocked deploy() method isn't considered a deploy step. So we defer
+ # mock'ing until after the init is done.
with mock.patch.object(fake.FakeDeploy,
'deploy', autospec=True) as mock_deploy:
mock_deploy.return_value = None
@@ -1812,41 +1651,6 @@ class ServiceDoNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
mock_iwdi.assert_called_once_with(self.context, node.instance_info)
self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
- @mock.patch('ironic.drivers.modules.fake.FakeDeploy.deploy')
- @mock.patch('ironic.conductor.utils.remove_agent_url')
- @mock.patch('ironic.conductor.utils.is_fast_track')
- def test_do_node_deploy_fast_track(self, mock_is_fast_track,
- mock_remove_agent_url,
- mock_deploy, mock_iwdi):
- # TODO(rloo): delete this after the deprecation period for supporting
- # non deploy_steps.
- # Mocking FakeDeploy.deploy before starting the service, causes
- # it not to be a deploy_step.
- mock_iwdi.return_value = False
- mock_is_fast_track.return_value = True
- self._start_service()
- mock_deploy.return_value = states.DEPLOYDONE
- node = obj_utils.create_test_node(
- self.context, driver='fake-hardware',
- driver_internal_info={'agent_url': 'meow'},
- provision_state=states.AVAILABLE,
- target_provision_state=states.NOSTATE)
-
- self.service.do_node_deploy(self.context, node.uuid)
- self._stop_service()
- node.refresh()
- self.assertEqual(states.ACTIVE, node.provision_state)
- self.assertEqual(states.NOSTATE, node.target_provision_state)
- # last_error should be None.
- self.assertIsNone(node.last_error)
- # Verify reservation has been cleared.
- self.assertIsNone(node.reservation)
- mock_deploy.assert_called_once_with(mock.ANY)
- mock_iwdi.assert_called_once_with(self.context, node.instance_info)
- self.assertFalse(node.driver_internal_info['is_whole_disk_image'])
- mock_is_fast_track.assert_called_once_with(mock.ANY)
- mock_remove_agent_url.assert_not_called()
-
@mgr_utils.mock_record_keepalive
class ContinueNodeDeployTestCase(mgr_utils.ServiceSetUpMixin,
diff --git a/ironic/tests/unit/drivers/modules/ansible/test_deploy.py b/ironic/tests/unit/drivers/modules/ansible/test_deploy.py
index 8787848ffd..95741d02e4 100644
--- a/ironic/tests/unit/drivers/modules/ansible/test_deploy.py
+++ b/ironic/tests/unit/drivers/modules/ansible/test_deploy.py
@@ -997,29 +997,6 @@ class TestAnsibleDeploy(AnsibleDeployTestCaseBase):
task.driver.boot.clean_up_ramdisk.assert_called_once_with(
task)
- @mock.patch.object(utils, 'notify_conductor_resume_deploy', autospec=True)
- @mock.patch.object(utils, 'node_set_boot_device', autospec=True)
- def test_reboot_to_instance_deprecated(self, bootdev_mock, resume_mock):
- # TODO(rloo): no deploy steps; delete this when we remove support
- # for handling no deploy steps.
- self.node.provision_state = states.DEPLOYING
- self.node.deploy_step = None
- self.node.save()
- with task_manager.acquire(self.context, self.node.uuid) as task:
- with mock.patch.object(self.driver, 'reboot_and_finish_deploy',
- autospec=True):
- task.driver.boot = mock.Mock()
- task.process_event = mock.Mock()
- self.driver.reboot_to_instance(task)
- bootdev_mock.assert_called_once_with(task, 'disk',
- persistent=True)
- self.assertFalse(resume_mock.called)
- task.process_event.assert_called_once_with('done')
- self.driver.reboot_and_finish_deploy.assert_called_once_with(
- task)
- task.driver.boot.clean_up_ramdisk.assert_called_once_with(
- task)
-
@mock.patch.object(utils, 'restore_power_state_if_needed', autospec=True)
@mock.patch.object(utils, 'power_on_node_if_needed')
@mock.patch.object(utils, 'node_power_action', autospec=True)
diff --git a/ironic/tests/unit/drivers/modules/test_agent.py b/ironic/tests/unit/drivers/modules/test_agent.py
index 7a8575e74b..81790a28ae 100644
--- a/ironic/tests/unit/drivers/modules/test_agent.py
+++ b/ironic/tests/unit/drivers/modules/test_agent.py
@@ -1231,6 +1231,8 @@ class TestAgentDeploy(db_base.DbTestCase):
self.assertEqual(states.ACTIVE,
task.node.target_provision_state)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
autospec=True)
@mock.patch.object(deploy_utils, 'remove_http_instance_symlink',
@@ -1251,7 +1253,7 @@ class TestAgentDeploy(db_base.DbTestCase):
prepare_instance_mock, power_off_mock,
get_power_state_mock, node_power_action_mock,
uuid_mock, log_mock, remove_symlink_mock,
- power_on_node_if_needed_mock):
+ power_on_node_if_needed_mock, resume_mock):
self.config(manage_agent_boot=True, group='agent')
self.config(image_download_source='http', group='agent')
check_deploy_mock.return_value = None
@@ -1278,10 +1280,13 @@ class TestAgentDeploy(db_base.DbTestCase):
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertTrue(remove_symlink_mock.called)
+ resume_mock.assert_called_once_with(task)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
autospec=True)
@mock.patch.object(agent.LOG, 'warning', spec_set=True, autospec=True)
@@ -1300,7 +1305,8 @@ class TestAgentDeploy(db_base.DbTestCase):
def test_reboot_to_instance_no_manage_agent_boot(
self, check_deploy_mock, prepare_instance_mock, power_off_mock,
get_power_state_mock, node_power_action_mock, uuid_mock,
- bootdev_mock, log_mock, power_on_node_if_needed_mock):
+ bootdev_mock, log_mock, power_on_node_if_needed_mock,
+ resume_mock):
self.config(manage_agent_boot=False, group='agent')
check_deploy_mock.return_value = None
uuid_mock.return_value = None
@@ -1324,9 +1330,12 @@ class TestAgentDeploy(db_base.DbTestCase):
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
+ resume_mock.assert_called_once_with(task)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
autospec=True)
@mock.patch.object(agent.LOG, 'warning', spec_set=True, autospec=True)
@@ -1350,7 +1359,8 @@ class TestAgentDeploy(db_base.DbTestCase):
node_power_action_mock,
uuid_mock, boot_mode_mock,
log_mock,
- power_on_node_if_needed_mock):
+ power_on_node_if_needed_mock,
+ resume_mock):
check_deploy_mock.return_value = None
uuid_mock.return_value = 'root_uuid'
self.node.provision_state = states.DEPLOYWAIT
@@ -1381,9 +1391,12 @@ class TestAgentDeploy(db_base.DbTestCase):
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
+ resume_mock.assert_called_once_with(task)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
autospec=True)
@mock.patch.object(agent.LOG, 'warning', spec_set=True, autospec=True)
@@ -1404,7 +1417,7 @@ class TestAgentDeploy(db_base.DbTestCase):
self, check_deploy_mock, prepare_instance_mock,
power_off_mock, get_power_state_mock,
node_power_action_mock, uuid_mock, boot_mode_mock, log_mock,
- power_on_node_if_needed_mock):
+ power_on_node_if_needed_mock, resume_mock):
check_deploy_mock.return_value = None
uuid_mock.side_effect = ['root_uuid', 'prep_boot_part_uuid']
self.node.provision_state = states.DEPLOYWAIT
@@ -1442,8 +1455,8 @@ class TestAgentDeploy(db_base.DbTestCase):
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
@mock.patch.object(agent.LOG, 'warning', spec_set=True, autospec=True)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@@ -1480,6 +1493,8 @@ class TestAgentDeploy(db_base.DbTestCase):
self.assertEqual(states.DEPLOYFAIL, task.node.provision_state)
self.assertEqual(states.ACTIVE, task.node.target_provision_state)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
autospec=True)
@mock.patch.object(agent.LOG, 'warning', spec_set=True, autospec=True)
@@ -1503,7 +1518,8 @@ class TestAgentDeploy(db_base.DbTestCase):
node_power_action_mock,
uuid_mock, boot_mode_mock,
log_mock,
- power_on_node_if_needed_mock):
+ power_on_node_if_needed_mock,
+ resume_mock):
check_deploy_mock.return_value = None
uuid_mock.side_effect = ['root_uuid', 'efi_uuid']
self.node.provision_state = states.DEPLOYWAIT
@@ -1538,8 +1554,9 @@ class TestAgentDeploy(db_base.DbTestCase):
get_power_state_mock.assert_called_once_with(task)
node_power_action_mock.assert_called_once_with(
task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
+ resume_mock.assert_called_once_with(task)
@mock.patch.object(agent_client.AgentClient, 'get_commands_status',
autospec=True)
diff --git a/ironic/tests/unit/drivers/modules/test_agent_base.py b/ironic/tests/unit/drivers/modules/test_agent_base.py
index 6927391f22..de8c671521 100644
--- a/ironic/tests/unit/drivers/modules/test_agent_base.py
+++ b/ironic/tests/unit/drivers/modules/test_agent_base.py
@@ -651,13 +651,6 @@ class HeartbeatMixinTest(AgentDeployMixinBaseTest):
self.context, self.node.uuid, shared=False) as task:
self.assertTrue(self.deploy.in_core_deploy_step(task))
- def test_in_core_deploy_step_no_steps_list(self):
- # Need to handle drivers without deploy step support, remove in the
- # Train release.
- with task_manager.acquire(
- self.context, self.node.uuid, shared=False) as task:
- self.assertTrue(self.deploy.in_core_deploy_step(task))
-
def test_in_core_deploy_step_in_other_step(self):
self.node.deploy_step = {
'interface': 'deploy', 'step': 'other-step', 'priority': 100}
@@ -784,8 +777,6 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
cfg.CONF.set_override('deploy_logs_collect', 'always', 'agent')
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
- self.node.deploy_step = {
- 'step': 'deploy', 'priority': 50, 'interface': 'deploy'}
self.node.save()
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
@@ -810,41 +801,6 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
- @mock.patch.object(fake.FakePower, 'get_power_state',
- spec=types.FunctionType)
- @mock.patch.object(agent_client.AgentClient, 'power_off',
- spec=types.FunctionType)
- def test_reboot_and_finish_deploy_deprecated(
- self, power_off_mock, get_power_state_mock,
- node_power_action_mock, collect_mock, resume_mock,
- power_on_node_if_needed_mock):
- # TODO(rloo): no deploy steps; delete this when we remove support
- # for handling no deploy steps.
- cfg.CONF.set_override('deploy_logs_collect', 'always', 'agent')
- self.node.provision_state = states.DEPLOYING
- self.node.target_provision_state = states.ACTIVE
- self.node.deploy_step = None
- self.node.save()
- with task_manager.acquire(self.context, self.node.uuid,
- shared=True) as task:
- get_power_state_mock.side_effect = [states.POWER_ON,
- states.POWER_OFF]
- power_on_node_if_needed_mock.return_value = None
- self.deploy.reboot_and_finish_deploy(task)
- power_off_mock.assert_called_once_with(task.node)
- self.assertEqual(2, get_power_state_mock.call_count)
- node_power_action_mock.assert_called_once_with(
- task, states.POWER_ON)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
- collect_mock.assert_called_once_with(task.node)
- self.assertFalse(resume_mock.called)
-
- @mock.patch.object(manager_utils, 'power_on_node_if_needed',
- autospec=True)
- @mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
- @mock.patch.object(time, 'sleep', lambda seconds: None)
- @mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(fake.FakePower, 'get_power_state',
spec=types.FunctionType)
@mock.patch.object(agent_client.AgentClient, 'power_off',
@@ -856,7 +812,7 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
def test_reboot_and_finish_deploy_soft_poweroff_doesnt_complete(
self, configure_tenant_net_mock, remove_provisioning_net_mock,
power_off_mock, get_power_state_mock,
- node_power_action_mock, mock_collect,
+ node_power_action_mock, mock_collect, resume_mock,
power_on_node_if_needed_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
@@ -874,10 +830,13 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
remove_provisioning_net_mock.assert_called_once_with(mock.ANY,
task)
configure_tenant_net_mock.assert_called_once_with(mock.ANY, task)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertFalse(mock_collect.called)
+ resume_mock.assert_called_once_with(task)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(agent_client.AgentClient, 'power_off',
@@ -888,7 +847,7 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
'configure_tenant_networks', spec_set=True, autospec=True)
def test_reboot_and_finish_deploy_soft_poweroff_fails(
self, configure_tenant_net_mock, remove_provisioning_net_mock,
- power_off_mock, node_power_action_mock, mock_collect):
+ power_off_mock, node_power_action_mock, mock_collect, resume_mock):
power_off_mock.side_effect = RuntimeError("boom")
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
@@ -903,11 +862,13 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
remove_provisioning_net_mock.assert_called_once_with(mock.ANY,
task)
configure_tenant_net_mock.assert_called_once_with(mock.ANY, task)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertFalse(mock_collect.called)
@mock.patch.object(manager_utils, 'power_on_node_if_needed')
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(time, 'sleep', lambda seconds: None)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@@ -922,7 +883,7 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
def test_reboot_and_finish_deploy_get_power_state_fails(
self, configure_tenant_net_mock, remove_provisioning_net_mock,
power_off_mock, get_power_state_mock, node_power_action_mock,
- mock_collect, power_on_node_if_needed_mock):
+ mock_collect, resume_mock, power_on_node_if_needed_mock):
self.node.provision_state = states.DEPLOYING
self.node.target_provision_state = states.ACTIVE
self.node.save()
@@ -939,8 +900,8 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
remove_provisioning_net_mock.assert_called_once_with(mock.ANY,
task)
configure_tenant_net_mock.assert_called_once_with(mock.ANY, task)
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertFalse(mock_collect.called)
@mock.patch.object(manager_utils, 'power_on_node_if_needed',
@@ -1049,12 +1010,15 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertFalse(mock_collect.called)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(agent_client.AgentClient, 'sync',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_power_action_oob_power_off(
- self, sync_mock, node_power_action_mock, mock_collect):
+ self, sync_mock, node_power_action_mock, mock_collect,
+ resume_mock):
# Enable force power off
driver_info = self.node.driver_info
driver_info['deploy_forces_oob_reboot'] = True
@@ -1072,17 +1036,21 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_ON),
])
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
self.assertFalse(mock_collect.called)
+ resume_mock.assert_called_once_with(task)
+ @mock.patch.object(manager_utils, 'notify_conductor_resume_deploy',
+ autospec=True)
@mock.patch.object(driver_utils, 'collect_ramdisk_logs', autospec=True)
@mock.patch.object(agent_base.LOG, 'warning', autospec=True)
@mock.patch.object(manager_utils, 'node_power_action', autospec=True)
@mock.patch.object(agent_client.AgentClient, 'sync',
spec=types.FunctionType)
def test_reboot_and_finish_deploy_power_action_oob_power_off_failed(
- self, sync_mock, node_power_action_mock, log_mock, mock_collect):
+ self, sync_mock, node_power_action_mock, log_mock, mock_collect,
+ resume_mock):
# Enable force power off
driver_info = self.node.driver_info
driver_info['deploy_forces_oob_reboot'] = True
@@ -1101,8 +1069,8 @@ class AgentDeployMixinTest(AgentDeployMixinBaseTest):
mock.call(task, states.POWER_OFF),
mock.call(task, states.POWER_ON),
])
- self.assertEqual(states.ACTIVE, task.node.provision_state)
- self.assertEqual(states.NOSTATE, task.node.target_provision_state)
+ self.assertEqual(states.DEPLOYING, task.node.provision_state)
+ self.assertEqual(states.ACTIVE, task.node.target_provision_state)
log_error = ('The version of the IPA ramdisk used in the '
'deployment do not support the command "sync"')
log_mock.assert_called_once_with(
diff --git a/releasenotes/notes/deploy-steps-required-aa72cdf1c0ec0e84.yaml b/releasenotes/notes/deploy-steps-required-aa72cdf1c0ec0e84.yaml
new file mode 100644
index 0000000000..a9a120d8da
--- /dev/null
+++ b/releasenotes/notes/deploy-steps-required-aa72cdf1c0ec0e84.yaml
@@ -0,0 +1,4 @@
+---
+upgrade:
+ - |
+ Removes compatibility with deploy interfaces that do not use deploy steps.