170 lines
5.7 KiB
Python
170 lines
5.7 KiB
Python
import anyjson
|
|
import eventlet
|
|
|
|
import jsonpath
|
|
from conductor.openstack.common import log as logging
|
|
import conductor.helpers
|
|
from command import CommandBase
|
|
import conductor.config
|
|
from heatclient.client import Client
|
|
import heatclient.exc
|
|
from keystoneclient.v2_0 import client as ksclient
|
|
import types
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class HeatExecutor(CommandBase):
|
|
def __init__(self, stack, token, tenant_id):
|
|
self._update_pending_list = []
|
|
self._delete_pending_list = []
|
|
self._stack = stack
|
|
settings = conductor.config.CONF.heat
|
|
|
|
client = ksclient.Client(endpoint=settings.auth_url)
|
|
auth_data = client.tokens.authenticate(
|
|
tenant_id=tenant_id,
|
|
token=token)
|
|
|
|
scoped_token = auth_data.id
|
|
|
|
heat_url = jsonpath.jsonpath(auth_data.serviceCatalog,
|
|
"$[?(@.name == 'heat')].endpoints[0].publicURL")[0]
|
|
|
|
self._heat_client = Client('1', heat_url,
|
|
token_only=True, token=scoped_token)
|
|
|
|
def execute(self, command, callback, **kwargs):
|
|
log.debug('Got command {0} on stack {1}'.format(command, self._stack))
|
|
|
|
if command == 'CreateOrUpdate':
|
|
return self._execute_create_update(
|
|
kwargs['template'],
|
|
kwargs['mappings'],
|
|
kwargs['arguments'],
|
|
callback)
|
|
elif command == 'Delete':
|
|
return self._execute_delete(callback)
|
|
|
|
def _execute_create_update(self, template, mappings, arguments, callback):
|
|
with open('data/templates/cf/%s.template' % template) as template_file:
|
|
template_data = template_file.read()
|
|
|
|
template_data = conductor.helpers.transform_json(
|
|
anyjson.loads(template_data), mappings)
|
|
|
|
self._update_pending_list.append({
|
|
'template': template_data,
|
|
'arguments': arguments,
|
|
'callback': callback
|
|
})
|
|
|
|
def _execute_delete(self, callback):
|
|
self._delete_pending_list.append({
|
|
'callback': callback
|
|
})
|
|
|
|
def has_pending_commands(self):
|
|
return len(self._update_pending_list) + \
|
|
len(self._delete_pending_list) > 0
|
|
|
|
def execute_pending(self):
|
|
r1 = self._execute_pending_updates()
|
|
r2 = self._execute_pending_deletes()
|
|
return r1 or r2
|
|
|
|
def _execute_pending_updates(self):
|
|
if not len(self._update_pending_list):
|
|
return False
|
|
|
|
template, arguments = self._get_current_template()
|
|
stack_exists = (template != {})
|
|
|
|
for t in self._update_pending_list:
|
|
template = conductor.helpers.merge_dicts(
|
|
template, t['template'], max_levels=2)
|
|
arguments = conductor.helpers.merge_dicts(
|
|
arguments, t['arguments'], max_levels=1)
|
|
|
|
log.info(
|
|
'Executing heat template {0} with arguments {1} on stack {2}'
|
|
.format(anyjson.dumps(template), arguments, self._stack))
|
|
|
|
if stack_exists:
|
|
self._heat_client.stacks.update(
|
|
stack_id=self._stack,
|
|
parameters=arguments,
|
|
template=template)
|
|
log.debug(
|
|
'Waiting for the stack {0} to be update'.format(self._stack))
|
|
self._wait_state('UPDATE_COMPLETE')
|
|
log.info('Stack {0} updated'.format(self._stack))
|
|
else:
|
|
self._heat_client.stacks.create(
|
|
stack_name=self._stack,
|
|
parameters=arguments,
|
|
template=template)
|
|
log.debug('Waiting for the stack {0} to be create'.format(
|
|
self._stack))
|
|
self._wait_state('CREATE_COMPLETE')
|
|
log.info('Stack {0} created'.format(self._stack))
|
|
|
|
pending_list = self._update_pending_list
|
|
self._update_pending_list = []
|
|
|
|
for item in pending_list:
|
|
item['callback'](True)
|
|
|
|
return True
|
|
|
|
def _execute_pending_deletes(self):
|
|
if not len(self._delete_pending_list):
|
|
return False
|
|
|
|
log.debug('Deleting stack {0}'.format(self._stack))
|
|
try:
|
|
self._heat_client.stacks.delete(
|
|
stack_id=self._stack)
|
|
log.debug(
|
|
'Waiting for the stack {0} to be deleted'.format(self._stack))
|
|
self._wait_state(['DELETE_COMPLETE', ''])
|
|
log.info('Stack {0} deleted'.format(self._stack))
|
|
except Exception as ex:
|
|
log.exception(ex)
|
|
|
|
pending_list = self._delete_pending_list
|
|
self._delete_pending_list = []
|
|
|
|
for item in pending_list:
|
|
item['callback'](True)
|
|
return True
|
|
|
|
def _get_current_template(self):
|
|
try:
|
|
stack_info = self._heat_client.stacks.get(stack_id=self._stack)
|
|
template = self._heat_client.stacks.template(
|
|
stack_id='{0}/{1}'.format(stack_info.stack_name, stack_info.id))
|
|
return template, stack_info.parameters
|
|
except heatclient.exc.HTTPNotFound:
|
|
return {}, {}
|
|
|
|
def _wait_state(self, state):
|
|
if isinstance(state, types.ListType):
|
|
states = state
|
|
else:
|
|
states = [state]
|
|
|
|
while True:
|
|
try:
|
|
status = self._heat_client.stacks.get(
|
|
stack_id=self._stack).stack_status
|
|
except heatclient.exc.HTTPNotFound:
|
|
status = ''
|
|
|
|
if 'IN_PROGRESS' in status:
|
|
eventlet.sleep(1)
|
|
continue
|
|
if status not in states:
|
|
raise EnvironmentError()
|
|
return
|