def post(self, request, env_template_id, path, body):
"""It adds a service into a template
:param request: The operation request.
:param env_template_id: the env template ID where the
service belongs to.
:param path: The path
:param body: the information about the service
:return: the service description.
"""
secure_data = token_sanitizer.TokenSanitizer().sanitize(body)
LOG.debug('Applications:Post <EnvTempId: {env_id}, Path: {path}, '
'Body: {body}>'.format(env_id=env_template_id,
body=secure_data,
path=path))
post_data = core_services.CoreServices.post_application_data
try:
result = post_data(env_template_id, body, path)
except (KeyError, ValueError):
msg = _('The template does not exist {templ_id}').format(
templ_id=env_template_id)
LOG.exception(msg)
raise exc.HTTPNotFound(msg)
return result
def execute(task):
s_task = token_sanitizer.TokenSanitizer().sanitize(task)
LOG.info('Starting processing task: {task_desc}'.format(
task_desc=jsonutils.dumps(s_task)))
result = None
reporter = status_reporter.StatusReporter(task['id'])
try:
task_executor = TaskExecutor(task, reporter)
result = task_executor.execute()
return result
finally:
s_result = token_sanitizer.TokenSanitizer().sanitize(result)
LOG.info('Finished processing task: {task_desc}'.format(
task_desc=jsonutils.dumps(s_result)))
class TokenSanitizerTests(base.MuranoTestCase):
sanitizer = token_sanitizer.TokenSanitizer()
def test_dict_with_one_value(self):
source = {'token': 'value'}
value = self.sanitizer.sanitize(source)
self.assertEqual(value['token'], self.sanitizer.message)
def test_dict_with_few_value(self):
source = {'token': 'value', 'pass': '******', 'TrustId': 'value'}
value = self.sanitizer.sanitize(source)
self.assertEqual(value['token'], self.sanitizer.message)
self.assertEqual(value['pass'], self.sanitizer.message)
self.assertEqual(value['TrustId'], self.sanitizer.message)
def test_dict_with_nested_dict(self):
source = {'obj': {'pass': '******'}}
value = self.sanitizer.sanitize(source)
self.assertEqual(value['obj']['pass'], self.sanitizer.message)
def test_dict_with_nested_list(self):
source = {'obj': [{'pass': '******'}]}
value = self.sanitizer.sanitize(source)
self.assertEqual(value['obj'][0]['pass'], self.sanitizer.message)
def test_leave_out_other_values(self):
source = {'obj': ['value']}
value = self.sanitizer.sanitize(source)
self.assertEqual(value['obj'][0], 'value')
def post(self, request, environment_id, path, body):
secure_data = token_sanitizer.TokenSanitizer().sanitize(body)
LOG.debug('Services:Post <EnvId: {0}, Path: {2}, '
'Body: {1}>'.format(environment_id, secure_data, path))
post_data = core_services.CoreServices.post_data
session_id = request.context.session
try:
result = post_data(environment_id, session_id, body, path)
except (KeyError, ValueError):
raise exc.HTTPNotFound
return result
def call_static_action(cls, context, task):
s_task = token_sanitizer.TokenSanitizer().sanitize(task)
LOG.info('Starting execution of static action: '
'{task_desc}'.format(task_desc=jsonutils.dumps(s_task)))
result = None
reporter = status_reporter.StatusReporter(task['id'])
try:
task_executor = StaticActionExecutor(task, reporter)
result = task_executor.execute()
return result
finally:
LOG.info('Finished execution of static action: '
'{task_desc}'.format(task_desc=jsonutils.dumps(result)))
def _push(self, object_store=None):
template = copy.deepcopy(self._template)
s_template = token_sanitizer.TokenSanitizer().sanitize(template)
LOG.debug(
'Pushing: {template}'.format(template=json.dumps(s_template)))
object_store = object_store or helpers.get_object_store()
while True:
try:
with helpers.with_object_store(object_store):
current_status = self._get_status()
resources = template.get('Resources') or template.get(
'resources')
if current_status == 'NOT_FOUND':
if resources is not None:
token_client = self._get_token_client()
token_client.stacks.create(
stack_name=self._name,
parameters=self._parameters,
template=template,
files=self._files,
environment=self._hot_environment,
disable_rollback=True,
tags=self._tags)
self._wait_state(
lambda status: status == 'CREATE_COMPLETE')
else:
if resources is not None:
self._client.stacks.update(
stack_id=self._name,
parameters=self._parameters,
files=self._files,
environment=self._hot_environment,
template=template,
disable_rollback=True,
tags=self._tags)
self._wait_state(
lambda status: status == 'UPDATE_COMPLETE',
True)
else:
self.delete()
except heat_exc.HTTPConflict as e:
LOG.warning('Conflicting operation: {msg}'.format(msg=e))
eventlet.sleep(3)
else:
break
self._applied = self._template == template
def update_task(action, session, task, unit):
session.state = state.SessionState.deploying
task_info = models.Task()
task_info.environment_id = session.environment_id
objects = session.description.get('Objects', None)
if objects:
task_info.description = token_sanitizer.TokenSanitizer().sanitize(
dict(session.description.get('Objects')))
task_info.action = task['action']
status = models.Status()
status.text = 'Action {0} is scheduled'.format(action)
status.level = 'info'
task_info.statuses.append(status)
with unit.begin():
unit.add(session)
unit.add(task_info)
def post(self, request, environment_id, path, body=None):
if not body:
msg = _('Request body is empty: please, provide'
' application object model')
LOG.error(msg)
raise exc.HTTPBadRequest(msg)
secure_data = token_sanitizer.TokenSanitizer().sanitize(body)
LOG.debug('Services:Post <EnvId: {env_id}, Path: {path}, '
'Body: {body}>'.format(env_id=environment_id,
body=secure_data,
path=path))
post_data = core_services.CoreServices.post_data
session_id = request.context.session
try:
result = post_data(environment_id, session_id, body, path)
except (KeyError, ValueError):
raise exc.HTTPNotFound
return result
def handle_task(context, task):
s_task = token_sanitizer.TokenSanitizer().sanitize(task)
LOG.info(
_('Starting processing task: {task_desc}').format(
task_desc=anyjson.dumps(s_task)))
result = task['model']
try:
task_executor = TaskExecutor(task)
result = task_executor.execute()
except Exception as e:
LOG.exception('Error during task execution for tenant %s',
task['tenant_id'])
msg_env = Environment(task['id'])
reporter = status_reporter.StatusReporter()
reporter.initialize(msg_env)
reporter.report_error(msg_env, str(e))
finally:
rpc.api().process_result(result, task['id'])
def _patch_description(description):
if not description:
description = {}
description['services'] = description.pop('applications', [])
return token_sanitizer.TokenSanitizer().sanitize(description)
def process_result(context, result, environment_id):
secure_result = token_sanitizer.TokenSanitizer().sanitize(result)
LOG.debug('Got result from orchestration '
'engine:\n{0}'.format(secure_result))
model = result['model']
action_result = result.get('action', {})
unit = session.get_session()
environment = unit.query(models.Environment).get(environment_id)
if not environment:
LOG.warning(_LW('Environment result could not be handled, '
'specified environment not found in database'))
return
if model['Objects'] is None and model.get('ObjectsCopy', {}) is None:
environments.EnvironmentServices.remove(environment_id)
return
environment.description = model
if environment.description['Objects'] is not None:
environment.description['Objects']['services'] = \
environment.description['Objects'].pop('applications', [])
# environment.networking = result.get('networking', {})
action_name = 'Deployment'
deleted = False
else:
action_name = 'Deletion'
deleted = True
environment.version += 1
environment.save(unit)
# close deployment
deployment = get_last_deployment(unit, environment.id)
deployment.finished = timeutils.utcnow()
deployment.result = action_result
num_errors = unit.query(models.Status)\
.filter_by(level='error', task_id=deployment.id).count()
num_warnings = unit.query(models.Status)\
.filter_by(level='warning', task_id=deployment.id).count()
final_status_text = action_name + ' finished'
if num_errors:
final_status_text += " with errors"
elif num_warnings:
final_status_text += " with warnings"
status = models.Status()
status.task_id = deployment.id
status.text = final_status_text
status.level = 'info'
deployment.statuses.append(status)
deployment.save(unit)
# close session
conf_session = unit.query(models.Session).filter_by(
**{'environment_id': environment.id,
'state': states.SessionState.DEPLOYING if not deleted
else states.SessionState.DELETING}).first()
if num_errors > 0:
conf_session.state = \
states.SessionState.DELETE_FAILURE if deleted else \
states.SessionState.DEPLOY_FAILURE
else:
conf_session.state = states.SessionState.DEPLOYED
conf_session.save(unit)
# output application tracking information
message = _LI('EnvId: {0} TenantId: {1} Status: {2} Apps: {3}').format(
environment.id,
environment.tenant_id,
_('Failed') if num_errors + num_warnings > 0 else _('Successful'),
', '.join(map(
lambda a: a['?']['type'],
model['Objects']['services']
))
)
LOG.info(message)
def process_result(context, result, environment_id):
secure_result = token_sanitizer.TokenSanitizer().sanitize(result)
LOG.debug('Got result from orchestration '
'engine:\n{0}'.format(secure_result))
unit = session.get_session()
environment = unit.query(models.Environment).get(environment_id)
if not environment:
LOG.warning(
_('Environment result could not be handled, specified '
'environment was not found in database'))
return
if result['Objects'] is None and result.get('ObjectsCopy', {}) is None:
environments.EnvironmentServices.remove(environment_id)
return
environment.description = result
if environment.description['Objects'] is not None:
environment.description['Objects']['services'] = \
environment.description['Objects'].pop('applications', [])
# environment.networking = result.get('networking', {})
action_name = 'Deployment'
deleted = False
else:
action_name = 'Deletion'
deleted = True
environment.version += 1
environment.save(unit)
#close deployment
deployment = get_last_deployment(unit, environment.id)
deployment.finished = timeutils.utcnow()
num_errors = unit.query(models.Status)\
.filter_by(level='error', task_id=deployment.id).count()
num_warnings = unit.query(models.Status)\
.filter_by(level='warning', task_id=deployment.id).count()
final_status_text = action_name + ' finished'
if num_errors:
final_status_text += " with errors"
elif num_warnings:
final_status_text += " with warnings"
status = models.Status()
status.task_id = deployment.id
status.text = final_status_text
status.level = 'info'
deployment.statuses.append(status)
deployment.save(unit)
#close session
conf_session = unit.query(models.Session).filter_by(
**{
'environment_id': environment.id,
'state': 'deploying' if not deleted else 'deleting'
}).first()
if num_errors > 0:
conf_session.state = \
sessions.SessionState.DELETE_FAILURE if deleted else \
sessions.SessionState.DEPLOY_FAILURE
else:
conf_session.state = sessions.SessionState.DEPLOYED
conf_session.save(unit)
def process_result(context, result, environment_id):
secure_result = token_sanitizer.TokenSanitizer().sanitize(result)
LOG.debug('Got result from orchestration '
'engine:\n{result}'.format(result=secure_result))
model = result['model']
action_result = result.get('action', {})
unit = session.get_session()
environment = unit.query(models.Environment).get(environment_id)
if not environment:
LOG.warning('Environment result could not be handled, '
'specified environment not found in database')
return
if model['Objects'] is None and model.get('ObjectsCopy', {}) is None:
environments.EnvironmentServices.remove(environment_id)
return
environment.description = model
if environment.description['Objects'] is not None:
environment.description['Objects']['services'] = \
environment.description['Objects'].pop('applications', [])
action_name = 'Deployment'
deleted = False
else:
action_name = 'Deletion'
deleted = True
environment.version += 1
environment.save(unit)
# close deployment
deployment = get_last_deployment(unit, environment.id)
deployment.finished = timeutils.utcnow()
deployment.result = action_result
num_errors = unit.query(models.Status)\
.filter_by(level='error', task_id=deployment.id).count()
num_warnings = unit.query(models.Status)\
.filter_by(level='warning', task_id=deployment.id).count()
final_status_text = action_name + ' finished'
if num_errors:
final_status_text += " with errors"
elif num_warnings:
final_status_text += " with warnings"
status = models.Status()
status.task_id = deployment.id
status.text = final_status_text
status.level = 'info'
deployment.statuses.append(status)
deployment.save(unit)
# close session
conf_session = unit.query(models.Session).filter_by(
**{
'environment_id':
environment.id,
'state':
states.SessionState.DEPLOYING if not deleted else states.
SessionState.DELETING
}).first()
if num_errors > 0 or result['action'].get('isException'):
conf_session.state = \
states.SessionState.DELETE_FAILURE if deleted else \
states.SessionState.DEPLOY_FAILURE
else:
conf_session.state = states.SessionState.DEPLOYED
conf_session.save(unit)
# output application tracking information
services = []
objects = model['Objects']
if objects:
services = objects.get('services')
if num_errors + num_warnings > 0:
LOG.warning('EnvId: {env_id} TenantId: {tenant_id} Status: '
'Failed Apps: {services}'.format(
env_id=environment.id,
tenant_id=environment.tenant_id,
services=services))
else:
LOG.info('EnvId: {env_id} TenantId: {tenant_id} Status: '
'Successful Apps: {services}'.format(
env_id=environment.id,
tenant_id=environment.tenant_id,
services=services))
if action_name == 'Deployment':
env = environment.to_dict()
env["deployment_started"] = deployment.started
env["deployment_finished"] = deployment.finished
status_reporter.get_notifier().report('environment.deploy.end',
env)
