openstack
/
python-tripleoclient
Code Issues Proposed changes

Use ansible playbooks for plan creation/update 

This removes mistral usage from plan create and
update cli commands by calling the new playbooks.

Depends-On: https://review.opendev.org/712605
Depends-On: https://review.opendev.org/712899
Change-Id: Icdc6c22a4e9fde316ef1700a4ee484a06c9dfd7d
This commit is contained in:
Rabi Mishra 2020-03-12 11:04:02 +05:30
parent 39a9e8aa15
commit 4a55e5b9c2
5 changed files with 205 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tripleoclient/tests/v1/overcloud_deploy/test_overcloud_deploy.py
View File

@ -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')

212
tripleoclient/tests/v1/test_overcloud_plan.py
View File

@ -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):

231
tripleoclient/tests/workflows/test_plan_management.py
View File

@ -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):

3
tripleoclient/v1/overcloud_plan.py
View File

@ -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):

61
tripleoclient/workflows/plan_management.py
View File

@ -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)