diff --git a/tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py b/tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py index f670c8e21..7cb3eb16c 100644 --- a/tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py +++ b/tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py @@ -624,10 +624,6 @@ class TestDeployOvercloud(fakes.TestDeployOvercloud): mock_rm = shutil.rmtree = mock.MagicMock() self.cmd.take_action(parsed_args) mock_rm.assert_called_once() - execution_calls = workflow_client.executions.create.call_args_list - deploy_plan_call = execution_calls[1] - deploy_plan_call_input = deploy_plan_call[1]['workflow_input'] - self.assertTrue(deploy_plan_call_input['skip_deploy_identifier']) mock_copy.assert_called_once() @mock.patch('tripleoclient.utils.copy_clouds_yaml') diff --git a/tripleoclient/tests/v1/test_overcloud_plan.py b/tripleoclient/tests/v1/test_overcloud_plan.py index 23544015a..d9495bea4 100644 --- a/tripleoclient/tests/v1/test_overcloud_plan.py +++ b/tripleoclient/tests/v1/test_overcloud_plan.py @@ -9,11 +9,11 @@ # 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 mock from osc_lib.tests import utils +from tripleoclient import constants from tripleoclient import exceptions from tripleoclient import plugin from tripleoclient.tests import fakes @@ -120,7 +120,8 @@ class TestOvercloudCreatePlan(utils.TestCommand): self.create_action.start() self.addCleanup(self.create_action.stop) - def test_create_default_plan(self): + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) + def test_create_default_plan(self, mock_run_playbook): # Setup arglist = ['overcast'] @@ -130,55 +131,26 @@ class TestOvercloudCreatePlan(utils.TestCommand): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "SUCCESS" - }]) - # Run self.cmd.take_action(parsed_args) # Verify - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'generate_passwords': True, - 'use_default_templates': True, - 'source_url': None - }) - - def test_create_default_plan_failed(self): - - # Setup - arglist = ['overcast'] - verifylist = [ - ('name', 'overcast'), - ('templates', None) - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "ERROR", "message": "failed" - }]) - - # Run - self.assertRaises(exceptions.WorkflowServiceError, - self.cmd.take_action, parsed_args) - - # Verify - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'generate_passwords': True, - 'use_default_templates': True, - 'source_url': None - }) + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "overcast", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch("tripleoclient.workflows.plan_management.tarball") - def test_create_custom_plan(self, mock_tarball): + def test_create_custom_plan(self, mock_tarball, + mock_run_playbook): # Setup arglist = ['overcast', '--templates', '/fake/path'] @@ -188,82 +160,26 @@ class TestOvercloudCreatePlan(utils.TestCommand): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "SUCCESS" - }]) - mock_result = mock.Mock(output='{"result": null}') - self.workflow.action_executions.create.return_value = mock_result - # Run self.cmd.take_action(parsed_args) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'generate_passwords': True, - 'validate_stack': False - }) - - @mock.patch("tripleoclient.workflows.plan_management.tarball") - def test_create_custom_plan_failed(self, mock_tarball): - - # Setup - arglist = ['overcast', '--templates', '/fake/path'] - verifylist = [ - ('name', 'overcast'), - ('templates', '/fake/path') - ] - parsed_args = self.check_parser(self.cmd, arglist, verifylist) - - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "ERROR", "message": "failed" - }]) - mock_result = mock.Mock(output='{"result": null}') - self.workflow.action_executions.create.return_value = mock_result - - self.swift.get_account.return_value = ( - {u'accept-ranges': u'bytes'}, - [{u'bytes': 1719440, u'count': 482, u'name': u'overcast'}, - {u'bytes': 1719440, u'count': 482, u'name': u'overcloud'}] + # Verify + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "overcast", + "generate_passwords": True, + "validate": False + }, + verbosity=3, ) - self.swift.get_container.return_value = ( - {u'x-container-meta-usage-tripleo': u'plan'}, - [{u'hash': u'2df2606ed8b866806b162ab3fa9a77ea', - u'last_modified': u'2016-12-09T21:18:16.172610', u'bytes': 808, - u'name': u'all-nodes-validation.yaml', - u'content_type': u'application/octet-stream'}, - {u'hash': u'0f1043e65e95ec24054a4ea63cdb3984', - u'last_modified': u'2016-12-09T21:18:19.612600', u'bytes': 583, - u'name': u'bootstrap-config.yaml', - u'content_type': u'application/octet-stream'}] - ) - - # Run - self.assertRaises(exceptions.WorkflowServiceError, - self.cmd.take_action, parsed_args) - - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'generate_passwords': True, - 'validate_stack': False - }) - - self.swift.get_account.assert_called_once() - self.swift.get_container.assert_called_once_with('overcast') - self.swift.delete_object.assert_has_calls([ - mock.call('overcast', u'bootstrap-config.yaml'), - mock.call('overcast', u'all-nodes-validation.yaml'), - ], any_order=True) - + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch("tripleoclient.workflows.plan_management.tarball") - def test_create_custom_plan_plan_environment_file(self, - mock_tarball): + def test_create_custom_plan_plan_environment_file( + self, mock_tarball, mock_run_playbook): # Setup arglist = ['overcast', '--templates', '/fake/path', '-p', 'the_plan_environment.yaml'] @@ -274,32 +190,31 @@ class TestOvercloudCreatePlan(utils.TestCommand): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "SUCCESS" - }]) - mock_result = mock.Mock(output='{"result": null}') - self.workflow.action_executions.create.return_value = mock_result - - mock_open_context = mock.mock_open() - with mock.patch('six.moves.builtins.open', mock_open_context): + mock_open = mock.mock_open() + # Run + with mock.patch('six.moves.builtins.open', mock_open): self.cmd.take_action(parsed_args) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'generate_passwords': True, - 'validate_stack': False - }) - - mock_open_context.assert_has_calls( + mock_open.assert_has_calls( [mock.call('the_plan_environment.yaml', 'rb')]) - self.tripleoclient.object_store.put_object.assert_called_once_with( - 'overcast', 'plan-environment.yaml', mock_open_context()) + # Verify + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "overcast", + "generate_passwords": True, + "plan_environment": "the_plan_environment.yaml", + "validate": False + }, + verbosity=3, + ) - def test_create_default_plan_with_password_gen_disabled(self): + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) + def test_create_default_plan_with_password_gen_disabled( + self, mock_run_playbook): # Setup arglist = ['overcast', '--disable-password-generation'] @@ -310,23 +225,20 @@ class TestOvercloudCreatePlan(utils.TestCommand): ] parsed_args = self.check_parser(self.cmd, arglist, verifylist) - self.websocket.wait_for_messages.return_value = iter([{ - "execution_id": "IDID", - "status": "SUCCESS" - }]) - # Run self.cmd.take_action(parsed_args) - # Verify - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={ - 'container': 'overcast', - 'use_default_templates': True, - 'generate_passwords': False, - 'source_url': None - }) + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "overcast", + "generate_passwords": False, + "validate": False + }, + verbosity=3, + ) class TestOvercloudDeployPlan(utils.TestCommand): diff --git a/tripleoclient/tests/workflows/test_plan_management.py b/tripleoclient/tests/workflows/test_plan_management.py index 353712163..f99023a3d 100644 --- a/tripleoclient/tests/workflows/test_plan_management.py +++ b/tripleoclient/tests/workflows/test_plan_management.py @@ -11,13 +11,12 @@ # 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 mock from osc_lib.tests import utils from swiftclient import exceptions as swift_exc -from tripleoclient import exceptions +from tripleoclient import constants from tripleoclient.tests import base from tripleoclient.workflows import plan_management @@ -26,12 +25,7 @@ class TestPlanCreationWorkflows(utils.TestCommand): def setUp(self): super(TestPlanCreationWorkflows, self).setUp() - self.app.client_manager.workflow_engine = self.workflow = mock.Mock() self.tripleoclient = mock.Mock() - self.websocket = mock.Mock() - self.websocket.__enter__ = lambda s: self.websocket - self.websocket.__exit__ = lambda s, *exc: None - self.tripleoclient.messaging_websocket.return_value = self.websocket self.app.client_manager.tripleoclient = self.tripleoclient self.message_success = iter([{ @@ -47,60 +41,36 @@ class TestPlanCreationWorkflows(utils.TestCommand): self.create_action.start() self.addCleanup(self.create_action.stop) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) - def test_create_plan_from_templates_success(self, mock_tarball): - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.websocket.wait_for_messages.return_value = self.message_success - + def test_create_plan_from_templates_success(self, mock_tarball, + mock_run_playbook): plan_management.create_plan_from_templates( self.app.client_manager, 'test-overcloud', '/tht-root/', validate_stack=False) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, - 'validate_stack': False}) - - @mock.patch('tripleoclient.workflows.plan_management.create_container', - autospec=True, - return_value=mock.Mock(error='Error')) - @mock.patch('tripleoclient.workflows.plan_management.tarball', - autospec=True) - def test_create_plan_from_templates_container_error(self, mock_tarball, - mock_create_container): - error = mock.Mock(output='{"result": "Error"}') - error.id = "IDID" - self.workflow.action_executions.create.return_value = error - self.workflow.executions.create.return_value = error - - self.assertRaises( - exceptions.PlanCreationError, - plan_management.create_plan_from_templates, - self.app.client_manager, - 'test-overcloud', - '/tht-root/', - validate_stack=False) - - self.workflow.executions.create.assert_not_called() + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.utils.rel_or_abs_path') @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) def test_create_plan_from_templates_roles_data(self, mock_tarball, - mock_norm_path): - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.websocket.wait_for_messages.return_value = self.message_success - + mock_norm_path, + mock_run_playbook): mock_open_context = mock.mock_open() with mock.patch('six.moves.builtins.open', mock_open_context): plan_management.create_plan_from_templates( @@ -110,11 +80,17 @@ class TestPlanCreationWorkflows(utils.TestCommand): 'the_roles_file.yaml', validate_stack=False) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, - 'validate_stack': False}) + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) self.assertIn(mock.call('the_roles_file.yaml', '/tht-root/'), mock_norm_path.call_args_list) @@ -122,15 +98,11 @@ class TestPlanCreationWorkflows(utils.TestCommand): self.tripleoclient.object_store.put_object.assert_called_once_with( 'test-overcloud', 'roles_data.yaml', mock_open_context()) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) - def test_create_plan_from_templates_plan_env_data(self, mock_tarball): - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.websocket.wait_for_messages.return_value = self.message_success - + def test_create_plan_from_templates_plan_env_data(self, mock_tarball, + mock_run_playbook): mock_open_context = mock.mock_open() with mock.patch('six.moves.builtins.open', mock_open_context): plan_management.create_plan_from_templates( @@ -140,27 +112,29 @@ class TestPlanCreationWorkflows(utils.TestCommand): plan_env_file='the-plan-environment.yaml', validate_stack=False) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, - 'validate_stack': False}) - + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "plan_environment": "the-plan-environment.yaml", + "validate": False + }, + verbosity=3, + ) mock_open_context.assert_has_calls( [mock.call('the-plan-environment.yaml', 'rb')]) self.tripleoclient.object_store.put_object.assert_called_once_with( 'test-overcloud', 'plan-environment.yaml', mock_open_context()) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) - def test_create_plan_from_templates_networks_data(self, mock_tarball): - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.websocket.wait_for_messages.return_value = self.message_success - + def test_create_plan_from_templates_networks_data(self, mock_tarball, + mock_run_playbook): mock_open_context = mock.mock_open() with mock.patch('six.moves.builtins.open', mock_open_context): plan_management.create_plan_from_templates( @@ -170,27 +144,28 @@ class TestPlanCreationWorkflows(utils.TestCommand): networks_file='the-network-data.yaml', validate_stack=False) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, - 'validate_stack': False}) - + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) mock_open_context.assert_has_calls( [mock.call('the-network-data.yaml', 'rb')]) self.tripleoclient.object_store.put_object.assert_called_once_with( 'test-overcloud', 'network_data.yaml', mock_open_context()) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) - def test_create_plan_with_password_gen_disabled(self, mock_tarball): - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.websocket.wait_for_messages.return_value = self.message_success - + def test_create_plan_with_password_gen_disabled(self, mock_tarball, + mock_run_playbook): plan_management.create_plan_from_templates( self.app.client_manager, 'test-overcloud', @@ -198,36 +173,27 @@ class TestPlanCreationWorkflows(utils.TestCommand): generate_passwords=False, validate_stack=False) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.create_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': False, - 'validate_stack': False}) + mock_run_playbook.assert_called_once_with( + 'cli-create-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": False, + "validate": False + }, + verbosity=3, + ) class TestPlanUpdateWorkflows(base.TestCommand): def setUp(self): super(TestPlanUpdateWorkflows, self).setUp() - self.app.client_manager.workflow_engine = self.workflow = mock.Mock() self.app.client_manager.tripleoclient = self.tripleoclient = \ mock.Mock() self.tripleoclient.object_store = self.object_store = mock.Mock() - self.websocket = mock.Mock() - self.websocket.__enter__ = lambda s: self.websocket - self.websocket.__exit__ = lambda s, *exc: None - self.tripleoclient.messaging_websocket.return_value = self.websocket - output = mock.Mock(output='{"result": ""}') - output.id = "IDID" - self.workflow.action_executions.create.return_value = output - self.workflow.executions.create.return_value = output - self.message_success = iter([{ - "execution_id": "IDID", - "status": "SUCCESS", - }]) - self.websocket.wait_for_messages.return_value = self.message_success - self.object_store.get_container.return_value = ( {}, [ @@ -252,12 +218,13 @@ class TestPlanUpdateWorkflows(base.TestCommand): return {}, '{0}: mock content\n'.format(args[1]) self.object_store.get_object.side_effect = get_object + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) @mock.patch('tripleo_common.utils.swift.empty_container', autospec=True) def test_update_plan_from_templates_keep_env( - self, mock_empty_container, mock_tarball): + self, mock_empty_container, mock_tarball, mock_run_playbook): plan_management.update_plan_from_templates( self.app.client_manager, @@ -288,19 +255,25 @@ class TestPlanUpdateWorkflows(base.TestCommand): ], any_order=True, ) + mock_run_playbook.assert_called_once_with( + 'cli-update-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.update_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, 'source_url': None, - 'validate_stack': False}) - + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management.tarball', autospec=True) @mock.patch('tripleo_common.utils.swift.empty_container', autospec=True) def test_update_plan_from_templates_recreate_env( - self, mock_empty_container, mock_tarball): + self, mock_empty_container, mock_tarball, mock_run_playbook): plan_management.update_plan_from_templates( self.app.client_manager, @@ -318,12 +291,19 @@ class TestPlanUpdateWorkflows(base.TestCommand): 'plan-environment.yaml: mock content\n' ) - self.workflow.executions.create.assert_called_once_with( - 'tripleo.plan_management.v1.update_deployment_plan', - workflow_input={'container': 'test-overcloud', - 'generate_passwords': True, 'source_url': None, - 'validate_stack': False}) + mock_run_playbook.assert_called_once_with( + 'cli-update-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) + @mock.patch("tripleoclient.utils.run_ansible_playbook", autospec=True) @mock.patch('tripleoclient.workflows.plan_management._update_passwords', autospec=True) @mock.patch('yaml.safe_load', @@ -334,7 +314,7 @@ class TestPlanUpdateWorkflows(base.TestCommand): autospec=True) def test_update_plan_from_templates_recreate_env_missing_passwords( self, mock_empty_container, mock_tarball, mock_yaml_safe_load, - mock_update_passwords): + mock_update_passwords, mock_run_playbook): plan_management.update_plan_from_templates( self.app.client_manager, 'test-overcloud', @@ -346,6 +326,17 @@ class TestPlanUpdateWorkflows(base.TestCommand): # Ensure that the passwords variable is passed with a value of None. mock_update_passwords.assert_called_with( mock.ANY, 'test-overcloud', None) + mock_run_playbook.assert_called_once_with( + 'cli-update-deployment-plan.yaml', + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": "test-overcloud", + "generate_passwords": True, + "validate": False + }, + verbosity=3, + ) class TestUpdatePasswords(base.TestCase): diff --git a/tripleoclient/v1/overcloud_plan.py b/tripleoclient/v1/overcloud_plan.py index 53bbf6602..6e63ead1c 100644 --- a/tripleoclient/v1/overcloud_plan.py +++ b/tripleoclient/v1/overcloud_plan.py @@ -133,7 +133,8 @@ class CreatePlan(command.Command): clients, container=name, generate_passwords=generate_passwords, source_url=source_url, - use_default_templates=use_default_templates) + use_default_templates=use_default_templates, + validate_stack=False) class DeployPlan(command.Command): diff --git a/tripleoclient/workflows/plan_management.py b/tripleoclient/workflows/plan_management.py index 42ae7688b..f59cc418a 100644 --- a/tripleoclient/workflows/plan_management.py +++ b/tripleoclient/workflows/plan_management.py @@ -23,7 +23,6 @@ from tripleo_common.utils import tarball from tripleoclient import constants from tripleoclient import exceptions from tripleoclient import utils -from tripleoclient.workflows import base LOG = logging.getLogger(__name__) # Plan management workflows should generally be quick. However, the creation @@ -65,32 +64,25 @@ def _upload_templates(swift_client, container_name, tht_root, roles_file=None, constants.PLAN_ENVIRONMENT, plan_env_file) -def _create_update_deployment_plan(clients, workflow, **workflow_input): - workflow_client = clients.workflow_engine - tripleoclients = clients.tripleoclient - - with tripleoclients.messaging_websocket() as ws: - execution = base.start_workflow( - workflow_client, workflow, - workflow_input=workflow_input - ) - - for payload in base.wait_for_messages(workflow_client, ws, execution, - _WORKFLOW_TIMEOUT): - if 'message' in payload: - print(payload['message']) - - return payload - - def create_deployment_plan(clients, **workflow_input): - payload = _create_update_deployment_plan( - clients, 'tripleo.plan_management.v1.create_deployment_plan', - **workflow_input) + extra_vars = { + "container": workflow_input['container'], + "validate": workflow_input['validate_stack'], + "generate_passwords": workflow_input["generate_passwords"]} - if payload['status'] != 'SUCCESS': - raise exceptions.WorkflowServiceError( - 'Exception creating plan: {}'.format(payload['message'])) + if 'plan_env_file' in workflow_input and workflow_input[ + 'plan_env_file'] is not None: + extra_vars.update(plan_environment=workflow_input['plan_env_file']) + + utils.run_ansible_playbook( + "cli-create-deployment-plan.yaml", + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars=extra_vars, + verbosity=3 + ) + + print("Success.") def delete_deployment_plan(clients, container): @@ -111,13 +103,19 @@ def delete_deployment_plan(clients, container): def update_deployment_plan(clients, **workflow_input): - payload = _create_update_deployment_plan( - clients, 'tripleo.plan_management.v1.update_deployment_plan', - **workflow_input) + utils.run_ansible_playbook( + "cli-update-deployment-plan.yaml", + 'undercloud,', + constants.ANSIBLE_TRIPLEO_PLAYBOOKS, + extra_vars={ + "container": workflow_input['container'], + "validate": workflow_input['validate_stack'], + "generate_passwords": workflow_input["generate_passwords"], + }, + verbosity=3 + ) - if payload['status'] != 'SUCCESS': - raise exceptions.WorkflowServiceError( - 'Exception updating plan: {}'.format(payload['message'])) + print("Success.") def list_deployment_plans(clients): @@ -164,6 +162,7 @@ def create_plan_from_templates(clients, name, tht_root, roles_file=None, try: create_deployment_plan(clients, container=name, generate_passwords=generate_passwords, + plan_env_file=plan_env_file, validate_stack=validate_stack) except exceptions.WorkflowServiceError: swiftutils.delete_container(swift_client, name)