def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
clients = self.app.client_manager
name = parsed_args.name
use_default_templates = False
generate_passwords = not parsed_args.disable_password_generation
source_url = parsed_args.source_url
# if the templates and source_url params are not used, then
# use the default templates
if not parsed_args.templates and not parsed_args.source_url:
use_default_templates = True
if parsed_args.templates:
plan_management.create_plan_from_templates(
clients,
name,
parsed_args.templates,
generate_passwords=generate_passwords,
plan_env_file=parsed_args.plan_environment_file)
else:
plan_management.create_deployment_plan(
clients,
container=name,
generate_passwords=generate_passwords,
source_url=source_url,
use_default_templates=use_default_templates)
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
mock_open_context = mock.mock_open()
with mock.patch('six.moves.builtins.open', mock_open_context):
plan_management.create_plan_from_templates(
self.app.client_manager,
'test-overcloud',
'/tht-root/',
networks_file='the-network-data.yaml',
validate_stack=False)
self.workflow.action_executions.create.assert_called_once_with(
'tripleo.plan.create_container', {'container': 'test-overcloud'},
run_sync=True,
save_result=True)
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_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())
def test_create_plan_from_templates_roles_data(self, mock_tarball,
mock_norm_path):
output = mock.Mock(output='{"result": ""}')
self.workflow.action_executions.create.return_value = output
self.websocket.wait_for_messages.return_value = self.message_success
mock_open_context = mock.mock_open()
with mock.patch('six.moves.builtins.open', mock_open_context):
plan_management.create_plan_from_templates(self.app.client_manager,
'test-overcloud',
'/tht-root/',
'the_roles_file.yaml')
self.workflow.action_executions.create.assert_called_once_with(
'tripleo.plan.create_container', {'container': 'test-overcloud'},
run_sync=True,
save_result=True)
self.workflow.executions.create.assert_called_once_with(
'tripleo.plan_management.v1.create_deployment_plan',
workflow_input={
'container': 'test-overcloud',
'generate_passwords': True
})
self.assertIn(mock.call('the_roles_file.yaml', '/tht-root/'),
mock_norm_path.call_args_list)
self.tripleoclient.object_store.put_object.assert_called_once_with(
'test-overcloud', 'roles_data.yaml', mock_open_context())
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
plan_management.create_plan_from_templates(self.app.client_manager,
'test-overcloud',
'/tht-root/',
generate_passwords=False,
validate_stack=False)
self.workflow.action_executions.create.assert_called_once_with(
'tripleo.plan.create_container', {'container': 'test-overcloud'},
run_sync=True,
save_result=True)
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
})
def test_create_plan_from_templates_roles_data(self, mock_tmp, mock_cd,
mock_tarball,
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(
self.app.client_manager,
'test-overcloud',
'/tht-root/',
'the_roles_file.yaml',
validate_stack=False)
mock_run_playbook.assert_called_once_with(
'cli-create-deployment-plan.yaml',
'undercloud,',
mock.ANY,
constants.ANSIBLE_TRIPLEO_PLAYBOOKS,
extra_vars={
"container": "test-overcloud",
"generate_passwords": True,
"validate": False
},
verbosity=0,
)
self.assertIn(mock.call('the_roles_file.yaml', '/tht-root/'),
mock_norm_path.call_args_list)
self.tripleoclient.object_store.put_object.assert_called_once_with(
'test-overcloud', 'roles_data.yaml', mock_open_context())
def test_create_plan_from_templates_roles_data(self, mock_tarball):
output = mock.Mock(output='{"result": ""}')
self.workflow.action_executions.create.return_value = output
self.websocket.wait_for_message.return_value = {
"status": "SUCCESS",
}
mock_open_context = mock.mock_open()
with mock.patch('six.moves.builtins.open', mock_open_context):
plan_management.create_plan_from_templates(
self.app.client_manager,
'test-overcloud',
'/tht-root/',
'the_roles_file.yaml')
self.workflow.action_executions.create.assert_called_once_with(
'tripleo.plan.create_container',
{'container': 'test-overcloud'},
run_sync=True, save_result=True)
self.workflow.executions.create.assert_called_once_with(
'tripleo.plan_management.v1.create_deployment_plan',
workflow_input={'queue_name': 'UUID4',
'container': 'test-overcloud'})
mock_open_context.assert_has_calls(
[mock.call('the_roles_file.yaml')])
self.tripleoclient.object_store.put_object.assert_called_once_with(
'test-overcloud', 'roles_data.yaml', mock_open_context())
def _deploy_tripleo_heat_templates(self, stack, parsed_args):
"""Deploy the fixed templates in TripleO Heat Templates"""
clients = self.app.client_manager
network_client = clients.network
workflow_client = clients.workflow_engine
parameters = self._update_parameters(
parsed_args, network_client, stack)
tht_root = os.path.abspath(parsed_args.templates)
plans = plan_management.list_deployment_plans(workflow_client)
# TODO(d0ugal): We need to put a more robust strategy in place here to
# handle updating plans.
if parsed_args.stack in plans:
# Upload the new plan templates to swift to replace the existing
# templates.
plan_management.update_plan_from_templates(
clients, parsed_args.stack, tht_root)
else:
plan_management.create_plan_from_templates(
clients, parsed_args.stack, tht_root)
print("Deploying templates in the directory {0}".format(
os.path.abspath(tht_root)))
self.log.debug("Creating Environment file")
# TODO(jprovazn): env file generated by create_environment_file()
# is not very usable any more, scale params are included in
# parameters and keystone cert is generated on create only
env_path = utils.create_environment_file()
env = {}
created_env_files = []
if stack is None:
self.log.debug("Creating Keystone certificates")
keystone_pki.generate_certs_into_json(env_path, False)
created_env_files.append(env_path)
if parsed_args.environment_directories:
created_env_files.extend(self._load_environment_directories(
parsed_args.environment_directories))
env.update(self._create_parameters_env(parameters))
if parsed_args.rhel_reg:
reg_env_files, reg_env = self._create_registration_env(parsed_args)
created_env_files.extend(reg_env_files)
template_utils.deep_update(env, reg_env)
if parsed_args.environment_files:
created_env_files.extend(parsed_args.environment_files)
self._try_overcloud_deploy_with_compat_yaml(
tht_root, stack, parsed_args.stack, parameters, created_env_files,
parsed_args.timeout, env)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
clients = self.app.client_manager
name = parsed_args.name
if parsed_args.templates:
plan_management.create_plan_from_templates(
clients, name, parsed_args.templates)
else:
plan_management.create_default_plan(
clients, container=name, queue_name=str(uuid.uuid4()))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
clients = self.app.client_manager
name = parsed_args.name
if parsed_args.templates:
plan_management.create_plan_from_templates(clients, name,
parsed_args.templates)
else:
plan_management.create_default_plan(clients,
container=name,
queue_name=str(uuid.uuid4()))
def test_create_plan_from_templates_success(self, mock_tmp, mock_cd,
mock_tarball,
mock_run_playbook):
plan_management.create_plan_from_templates(
self.app.client_manager,
'test-overcloud',
'/tht-root/',
validate_stack=False)
mock_run_playbook.assert_called_once_with(
'cli-create-deployment-plan.yaml',
'undercloud,',
mock.ANY,
constants.ANSIBLE_TRIPLEO_PLAYBOOKS,
extra_vars={
"container": "test-overcloud",
"generate_passwords": True,
"validate": False
},
verbosity=0,
)
def test_create_plan_from_templates_success(self, mock_tarball):
output = mock.Mock(output='{"result": ""}')
self.workflow.action_executions.create.return_value = output
self.websocket.wait_for_message.return_value = {
"status": "SUCCESS",
}
plan_management.create_plan_from_templates(
self.app.client_manager,
'test-overcloud',
'/tht-root/')
self.workflow.action_executions.create.assert_called_once_with(
'tripleo.plan.create_container',
{'container': 'test-overcloud'},
run_sync=True, save_result=True)
self.workflow.executions.create.assert_called_once_with(
'tripleo.plan_management.v1.create_deployment_plan',
workflow_input={'queue_name': 'UUID4',
'container': 'test-overcloud'})
def _deploy_tripleo_heat_templates(self, stack, parsed_args, tht_root,
user_tht_root):
"""Deploy the fixed templates in TripleO Heat Templates"""
plans = plan_management.list_deployment_plans(self.clients)
generate_passwords = not parsed_args.disable_password_generation
# TODO(d0ugal): We need to put a more robust strategy in place here to
# handle updating plans.
if parsed_args.stack in plans:
# Upload the new plan templates to swift to replace the existing
# templates.
plan_management.update_plan_from_templates(
self.clients, parsed_args.stack, tht_root,
parsed_args.roles_file, generate_passwords,
parsed_args.plan_environment_file, parsed_args.networks_file,
type(self)._keep_env_on_update)
else:
plan_management.create_plan_from_templates(
self.clients, parsed_args.stack, tht_root,
parsed_args.roles_file, generate_passwords,
parsed_args.plan_environment_file, parsed_args.networks_file)
# Get any missing (e.g j2 rendered) files from the plan to tht_root
self._download_missing_files_from_plan(tht_root, parsed_args.stack)
print("Processing templates in the directory {0}".format(
os.path.abspath(tht_root)))
self.log.debug("Creating Environment files")
env = {}
created_env_files = []
if parsed_args.environment_directories:
created_env_files.extend(
utils.load_environment_directories(
parsed_args.environment_directories))
parameters = {}
if stack:
try:
# If user environment already exist then keep it
user_env = yaml.safe_load(
self.object_client.get_object(
parsed_args.stack, constants.USER_ENVIRONMENT)[1])
template_utils.deep_update(env, user_env)
except ClientException:
pass
parameters.update(self._update_parameters(parsed_args, stack))
template_utils.deep_update(
env,
self._create_parameters_env(parameters, tht_root,
parsed_args.stack))
if parsed_args.rhel_reg:
reg_env_files, reg_env = self._create_registration_env(
parsed_args, tht_root)
created_env_files.extend(reg_env_files)
template_utils.deep_update(env, reg_env)
if parsed_args.environment_files:
created_env_files.extend(parsed_args.environment_files)
self.log.debug("Processing environment files %s" % created_env_files)
env_files, localenv = utils.process_multiple_environments(
created_env_files,
tht_root,
user_tht_root,
cleanup=not parsed_args.no_cleanup)
template_utils.deep_update(env, localenv)
if stack:
bp_cleanup = self._create_breakpoint_cleanup_env(
tht_root, parsed_args.stack)
template_utils.deep_update(env, bp_cleanup)
# FIXME(shardy) It'd be better to validate this via mistral
# e.g part of the plan create/update workflow
number_controllers = int(parameters.get('ControllerCount', 0))
if number_controllers > 1:
if not env.get('parameter_defaults').get('NtpServer'):
raise exceptions.InvalidConfiguration(
'Specify --ntp-server as parameter or NtpServer in '
'environments when using multiple controllers '
'(with HA).')
self._try_overcloud_deploy_with_compat_yaml(
tht_root, stack, parsed_args.stack, parameters, env_files,
parsed_args.timeout, env, parsed_args.update_plan_only,
parsed_args.run_validations, parsed_args.skip_deploy_identifier,
parsed_args.plan_environment_file)
def _deploy_tripleo_heat_templates(self, stack, parsed_args,
tht_root, user_tht_root):
"""Deploy the fixed templates in TripleO Heat Templates"""
clients = self.app.client_manager
network_client = clients.network
workflow_client = clients.workflow_engine
parameters = self._update_parameters(
parsed_args, network_client, stack)
plans = plan_management.list_deployment_plans(workflow_client)
# TODO(d0ugal): We need to put a more robust strategy in place here to
# handle updating plans.
if parsed_args.stack in plans:
# Upload the new plan templates to swift to replace the existing
# templates.
plan_management.update_plan_from_templates(
clients, parsed_args.stack, tht_root, parsed_args.roles_file)
else:
plan_management.create_plan_from_templates(
clients, parsed_args.stack, tht_root, parsed_args.roles_file)
# Get any missing (e.g j2 rendered) files from the plan to tht_root
added_files = self._download_missing_files_from_plan(
tht_root, parsed_args.stack)
print("Deploying templates in the directory {0}".format(
os.path.abspath(tht_root)))
self.log.debug("Creating Environment file")
# TODO(jprovazn): env file generated by create_environment_file()
# is not very usable any more, scale params are included in
# parameters and keystone cert is generated on create only
env_path = utils.create_environment_file()
env = {}
created_env_files = []
if stack is None:
self.log.debug("Creating Keystone certificates")
keystone_pki.generate_certs_into_json(env_path, False)
created_env_files.append(env_path)
if parsed_args.environment_directories:
created_env_files.extend(self._load_environment_directories(
parsed_args.environment_directories))
env.update(self._create_parameters_env(parameters))
if parsed_args.rhel_reg:
reg_env_files, reg_env = self._create_registration_env(parsed_args)
created_env_files.extend(reg_env_files)
template_utils.deep_update(env, reg_env)
if parsed_args.environment_files:
created_env_files.extend(parsed_args.environment_files)
self.log.debug("Processing environment files %s" % created_env_files)
env_files, localenv = self._process_multiple_environments(
created_env_files, added_files, tht_root, user_tht_root,
cleanup=not parsed_args.no_cleanup)
template_utils.deep_update(env, localenv)
self._try_overcloud_deploy_with_compat_yaml(
tht_root, stack, parsed_args.stack, parameters, env_files,
parsed_args.timeout, env, parsed_args.update_plan_only)
