def test_update_in_env(self):
env = plan_utils.get_env(self.swift, self.container)
updated_env = plan_utils.update_in_env(self.swift, env, 'template',
'updated-overcloud.yaml')
self.assertEqual(updated_env['template'], 'updated-overcloud.yaml')
updated_env = plan_utils.update_in_env(
self.swift, env, 'parameter_defaults',
{'another-key': 'another-value'})
self.assertEqual(
updated_env['parameter_defaults'], {
'BlockStorageCount': 42,
'OvercloudControlFlavor': 'yummy',
'another-key': 'another-value'
})
updated_env = plan_utils.update_in_env(self.swift,
env,
'parameter_defaults',
delete_key=True)
self.assertNotIn('parameter_defaults', updated_env)
self.swift.get_object.assert_called()
self.swift.put_object.assert_called()
def test_update_in_env(self):
env = plan_utils.get_env(self.swift, self.container)
updated_env = plan_utils.update_in_env(
self.swift,
env,
'template',
'updated-overcloud.yaml'
)
self.assertEqual(updated_env['template'], 'updated-overcloud.yaml')
updated_env = plan_utils.update_in_env(
self.swift,
env,
'parameter_defaults',
{'another-key': 'another-value'}
)
self.assertEqual(updated_env['parameter_defaults'], {
'BlockStorageCount': 42,
'OvercloudControlFlavor': 'yummy',
'another-key': 'another-value'
})
updated_env = plan_utils.update_in_env(
self.swift,
env,
'parameter_defaults',
delete_key=True
)
self.assertNotIn('parameter_defaults', updated_env)
self.swift.get_object.assert_called()
self.swift.put_object.assert_called()
def run(self, context):
try:
swift = self.get_object_client(context)
plan_env = plan_utils.get_env(swift, self.container)
if self.env_key not in plan_env:
msg = "The environment key doesn't exist: %s" % self.env_key
return actions.Result(error=msg)
if self.delete:
if not self.parameter:
raise ValueError("delete must specify a parameter")
plan_env[self.env_key].pop(self.parameter, None)
elif self.parameter:
plan_env[self.env_key][self.parameter] = self.value
elif self.value is not None:
plan_env[self.env_key] = self.value
else:
# Nothing to modify
return
plan_utils.update_in_env(swift, plan_env,
self.env_key,
value=plan_env[self.env_key])
except swiftexceptions.ClientException as err:
msg = "Error attempting an operation on container: %s" % err
return actions.Result(error=msg)
except Exception as err:
msg = "Error while updating plan: %s" % err
return actions.Result(error=msg)
def run(self, context):
swift = self.get_object_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, self.key, delete_key=True)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
self.cache_delete(context, self.container, "tripleo.parameters.get")
return env
def run(self, context):
swift = self.get_object_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, self.key,
delete_key=True)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
self.cache_delete(context,
self.container,
"tripleo.parameters.get")
return env
def run(self, context):
# check to see if the stack exists
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container, resolve_outputs=False)
except heat_exc.HTTPNotFound:
stack = None
stack_is_new = stack is None
# update StackAction, DeployIdentifier and UpdateIdentifier
swift = self.get_object_client(context)
parameters = dict()
if not self.skip_deploy_identifier:
parameters['DeployIdentifier'] = int(time.time())
parameters['UpdateIdentifier'] = ''
parameters['StackAction'] = 'CREATE' if stack_is_new else 'UPDATE'
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
self.set_tls_parameters(parameters, env)
try:
plan_utils.update_in_env(swift, env, 'parameter_defaults',
parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
if not stack_is_new:
try:
LOG.debug('Checking for compatible neutron mechanism drivers')
msg = update.check_neutron_mechanism_drivers(
env, stack, swift, self.container)
if msg:
return actions.Result(error=msg)
except swiftexceptions.ClientException as err:
err_msg = ("Error getting template %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
# process all plan files and create or update a stack
process_templates_action = templates.ProcessTemplatesAction(
container=self.container)
processed_data = process_templates_action.run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
stack_args['timeout_mins'] = self.timeout_mins
if stack_is_new:
try:
swift.copy_object(
"%s-swift-rings" % self.container, "swift-rings.tar.gz",
"%s-swift-rings/%s-%d" %
(self.container, "swift-rings.tar.gz", time.time()))
swift.delete_object("%s-swift-rings" % self.container,
"swift-rings.tar.gz")
except swiftexceptions.ClientException:
pass
LOG.info("Perfoming Heat stack create")
try:
return heat.stacks.create(**stack_args)
except heat_exc.HTTPException as err:
err_msg = "Error during stack creation: %s" % (err, )
LOG.exception(err_msg)
return actions.Result(error=err_msg)
LOG.info("Performing Heat stack update")
stack_args['existing'] = 'true'
try:
return heat.stacks.update(stack.id, **stack_args)
except heat_exc.HTTPException as err:
err_msg = "Error during stack update: %s" % (err, )
LOG.exception(err_msg)
return actions.Result(error=err_msg)
def run(self, context):
# check to see if the stack exists
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container)
except heat_exc.HTTPNotFound:
stack = None
stack_is_new = stack is None
# update StackAction, DeployIdentifier and UpdateIdentifier
swift = self.get_object_client(context)
parameters = dict()
if not self.skip_deploy_identifier:
parameters['DeployIdentifier'] = int(time.time())
parameters['UpdateIdentifier'] = ''
parameters['StackAction'] = 'CREATE' if stack_is_new else 'UPDATE'
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, 'parameter_defaults',
parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
# process all plan files and create or update a stack
processed_data = super(DeployStackAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
stack_args['timeout_mins'] = self.timeout_mins
if stack_is_new:
try:
swift.copy_object(
"%s-swift-rings" % self.container, "swift-rings.tar.gz",
"%s-swift-rings/%s-%d" %
(self.container, "swift-rings.tar.gz", time.time()))
swift.delete_object("%s-swift-rings" % self.container,
"swift-rings.tar.gz")
except swiftexceptions.ClientException:
pass
LOG.info("Perfoming Heat stack create")
return heat.stacks.create(**stack_args)
LOG.info("Performing Heat stack update")
stack_args['existing'] = 'true'
return heat.stacks.update(stack.id, **stack_args)
def run(self, context):
# check to see if the stack exists
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container)
except heat_exc.HTTPNotFound:
stack = None
stack_is_new = stack is None
# update StackAction, DeployIdentifier and UpdateIdentifier
swift = self.get_object_client(context)
parameters = dict()
if not self.skip_deploy_identifier:
parameters['DeployIdentifier'] = int(time.time())
parameters['UpdateIdentifier'] = ''
parameters['StackAction'] = 'CREATE' if stack_is_new else 'UPDATE'
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, 'parameter_defaults',
parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
# process all plan files and create or update a stack
processed_data = super(DeployStackAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
stack_args['timeout_mins'] = self.timeout_mins
if stack_is_new:
try:
swift.copy_object(
"%s-swift-rings" % self.container, "swift-rings.tar.gz",
"%s-swift-rings/%s-%d" % (
self.container, "swift-rings.tar.gz", time.time()))
swift.delete_object(
"%s-swift-rings" % self.container, "swift-rings.tar.gz")
except swiftexceptions.ClientException:
pass
LOG.info("Perfoming Heat stack create")
return heat.stacks.create(**stack_args)
LOG.info("Performing Heat stack update")
stack_args['existing'] = 'true'
return heat.stacks.update(stack.id, **stack_args)
def run(self, context):
swift = self.get_object_client(context)
heat = self.get_orchestration_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
saved_env = copy.deepcopy(env)
try:
plan_utils.update_in_env(swift, env, self.key, self.parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
processed_data = super(UpdateParametersAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
env = plan_utils.get_env(swift, self.container)
if not self.validate:
return env
params = env.get('parameter_defaults')
fields = {
'template': processed_data['template'],
'files': processed_data['files'],
'environment': processed_data['environment'],
'show_nested': True
}
try:
result = {
'heat_resource_tree': heat.stacks.validate(**fields),
'environment_parameters': params,
}
# Validation passes so the old cache gets replaced.
self.cache_set(context, self.container, "tripleo.parameters.get",
result)
if result['heat_resource_tree']:
flattened = {'resources': {}, 'parameters': {}}
_flat_it(flattened, 'Root', result['heat_resource_tree'])
result['heat_resource_tree'] = flattened
except heat_exc.HTTPException as err:
LOG.debug("Validation failed rebuilding saved env")
# There has been an error validating we must reprocess the
# templates with the saved working env
plan_utils.put_env(swift, saved_env)
self._process_custom_roles(context)
err_msg = ("Error validating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
LOG.debug("Validation worked new env is saved")
return result
def run(self, context):
# get the stack. Error if doesn't exist
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container)
except heat_exc.HTTPNotFound:
msg = "Error retrieving stack: %s" % self.container
LOG.exception(msg)
return actions.Result(error=msg)
parameters = dict()
timestamp = int(time.time())
parameters['DeployIdentifier'] = timestamp
parameters['UpdateIdentifier'] = timestamp
parameters['StackAction'] = 'UPDATE'
swift = self.get_object_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, 'parameter_defaults',
parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" % (
self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
# process all plan files and create or update a stack
processed_data = super(UpdateStackAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
env = stack_args.get('environment', {})
template_utils.deep_update(env, {
'resource_registry': {
'resources': {
'*': {
'*': {
constants.UPDATE_RESOURCE_NAME: {
'hooks': 'pre-update'}
}
}
}
}
})
stack_args['environment'] = env
stack_args['timeout_mins'] = self.timeout_mins
stack_args['existing'] = 'true'
LOG.info("Performing Heat stack update")
LOG.info('updating stack: %s', stack.stack_name)
return heat.stacks.update(stack.id, **stack_args)
def run(self, context):
# get the stack. Error if doesn't exist
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container)
except heat_exc.HTTPNotFound:
msg = "Error retrieving stack: %s" % self.container
LOG.exception(msg)
return actions.Result(error=msg)
parameters = dict()
timestamp = int(time.time())
parameters['DeployIdentifier'] = timestamp
parameters['UpdateIdentifier'] = timestamp
parameters['StackAction'] = 'UPDATE'
swift = self.get_object_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
try:
plan_utils.update_in_env(swift, env, 'parameter_defaults',
parameters)
except swiftexceptions.ClientException as err:
err_msg = ("Error updating environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
# process all plan files and create or update a stack
processed_data = super(UpdateStackAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
env = stack_args.get('environment', {})
template_utils.deep_update(
env, {
'resource_registry': {
'resources': {
'*': {
'*': {
constants.UPDATE_RESOURCE_NAME: {
'hooks': 'pre-update'
}
}
}
}
}
})
stack_args['environment'] = env
stack_args['timeout_mins'] = self.timeout_mins
stack_args['existing'] = 'true'
LOG.info("Performing Heat stack update")
LOG.info('updating stack: %s', stack.stack_name)
return heat.stacks.update(stack.id, **stack_args)
def run(self, context):
# get the stack. Error if doesn't exist
heat = self.get_orchestration_client(context)
try:
stack = heat.stacks.get(self.container)
except heat_exc.HTTPNotFound:
msg = "Error retrieving stack: %s" % self.container
LOG.exception(msg)
return actions.Result(error=msg)
swift = self.get_object_client(context)
try:
env = plan_utils.get_env(swift, self.container)
except swiftexceptions.ClientException as err:
err_msg = ("Error retrieving environment for plan %s: %s" %
(self.container, err))
LOG.exception(err_msg)
return actions.Result(error=err_msg)
update_env = {}
if self.container_registry is not None:
update_env.update(self.container_registry)
noop_env = {
'resource_registry': {
'OS::TripleO::DeploymentSteps': 'OS::Heat::None',
},
}
for output in stack.to_dict().get('outputs', {}):
if output['output_key'] == 'RoleData':
for role in output['output_value']:
role_env = {
"OS::TripleO::Tasks::%sPreConfig" % role:
'OS::Heat::None',
"OS::TripleO::Tasks::%sPostConfig" % role:
'OS::Heat::None',
}
noop_env['resource_registry'].update(role_env)
update_env.update(noop_env)
template_utils.deep_update(env, update_env)
parameters = {}
if self.container_registry is not None:
parameters.update(self.container_registry['parameter_defaults'])
if self.ceph_ansible_playbook:
parameters.update(
{'CephAnsiblePlaybook': '%s' % self.ceph_ansible_playbook})
plan_utils.update_in_env(swift, env, 'parameter_defaults', parameters)
# process all plan files and create or update a stack
processed_data = super(UpdateStackAction, self).run(context)
# If we receive a 'Result' instance it is because the parent action
# had an error.
if isinstance(processed_data, actions.Result):
return processed_data
stack_args = processed_data.copy()
LOG.info("Performing Heat stack update")
LOG.info('updating stack: %s', stack.stack_name)
return heat.stacks.update(stack.id, **stack_args)
