def validate_template(self, req):
con = context.get_admin_context()
try:
templ = self._get_template(req)
except socket.gaierror:
msg = _('Invalid Template URL')
return webob.exc.HTTPBadRequest(explanation=msg)
if templ is None:
msg = _("TemplateBody or TemplateUrl were not given.")
return webob.exc.HTTPBadRequest(explanation=msg)
try:
stack = json.loads(templ)
except ValueError:
msg = _("The Template must be a JSON document.")
return webob.exc.HTTPBadRequest(explanation=msg)
logger.info('validate_template')
try:
return rpc.call(con, 'engine',
{'method': 'validate_template',
'args': {'template': stack,
'params': dict(req.params)}})
except rpc_common.RemoteError as ex:
return webob.exc.HTTPBadRequest(str(ex))
def start(self):
vcs_string = version.version_string_with_vcs()
LOG.info(_('Starting %(topic)s node (version %(vcs_string)s)'),
{'topic': self.topic, 'vcs_string': vcs_string})
# TODO do we need this ? -> utils.cleanup_file_locks()
self.manager.init_host()
self.model_disconnected = False
ctxt = context.get_admin_context()
# self._create_service_ref(ctxt)
self.conn = rpc.create_connection(new=True)
LOG.debug(_("Creating Consumer connection for Service %s") %
self.topic)
# Share this same connection for these Consumers
self.conn.create_consumer(self.topic, self, fanout=False)
node_topic = '%s.%s' % (self.topic, self.host)
self.conn.create_consumer(node_topic, self, fanout=False)
self.conn.create_consumer(self.topic, self, fanout=True)
# Consume from all consumers in a thread
self.conn.consume_in_thread()
if self.periodic_interval:
periodic = heat_utils.LoopingCall(self.periodic_tasks)
periodic.start(interval=self.periodic_interval, now=False)
self.timers.append(periodic)
def create(self, req):
"""
Returns the following information for all stacks:
"""
con = context.get_admin_context()
try:
templ = self._get_template(req)
except socket.gaierror:
msg = _('Invalid Template URL')
return webob.exc.HTTPBadRequest(explanation=msg)
if templ is None:
msg = _("TemplateBody or TemplateUrl were not given.")
return webob.exc.HTTPBadRequest(explanation=msg)
try:
stack = json.loads(templ)
except ValueError:
msg = _("The Template must be a JSON document.")
return webob.exc.HTTPBadRequest(explanation=msg)
stack['StackName'] = req.params['StackName']
try:
return rpc.call(con, 'engine',
{'method': 'create_stack',
'args': {'stack_name': req.params['StackName'],
'template': stack,
'params': dict(req.params)}})
except rpc_common.RemoteError as ex:
return webob.exc.HTTPBadRequest(str(ex))
def create_event(self, req, body=None):
con = context.get_admin_context()
[error, event] = rpc.call(con, 'engine',
{'method': 'event_create',
'args': {'event': body}})
if error:
return json_error(400, error)
return json_response(201, event)
def list_resources(self, req, stack_name):
con = context.get_admin_context()
resources = rpc.call(con, 'engine',
{'method': 'metadata_list_resources',
'args': {'stack_name': stack_name}})
if resources:
return resources
else:
return json_error(404,
'The stack "%s" does not exist.' % stack_name)
def get_resource(self, req, stack_name, resource_id):
con = context.get_admin_context()
[error, metadata] = rpc.call(con, 'engine',
{'method': 'metadata_get_resource',
'args': {'stack_name': stack_name,
'resource_id': resource_id}})
if error:
if error == 'stack':
return json_error(404,
'The stack "%s" does not exist.' % stack_name)
else:
return json_error(404,
'The resource "%s" does not exist.' % resource_id)
return metadata
def events_list(self, req):
"""
Returns the following information for all stacks:
"""
con = context.get_admin_context()
stack_name = req.params.get('StackName', None)
try:
event_res = rpc.call(con, 'engine',
{'method': 'list_events',
'args': {'stack_name': stack_name}})
except rpc_common.RemoteError as ex:
return webob.exc.HTTPBadRequest(str(ex))
events = 'Error' not in event_res and event_res['events'] or []
return {'DescribeStackEventsResult': {'StackEvents': events}}
def update_metadata(self, req, body, stack_name, resource_id):
con = context.get_admin_context()
[error, metadata] = rpc.call(con, 'engine',
{'method': 'metadata_update',
'args': {'stack_name': stack_name,
'resource_id': resource_id,
'metadata': body}})
if error:
if error == 'stack':
return json_error(404,
'The stack "%s" does not exist.' % stack_name)
else:
return json_error(404,
'The resource "%s" does not exist.' % resource_id)
return json_response(201, {
'resource': resource_id,
'metadata': body,
})
def list(self, req):
"""
Returns the following information for all stacks:
"""
con = context.get_admin_context()
stack_list = rpc.call(con, 'engine',
{'method': 'list_stacks',
'args': {'params': dict(req.params)}})
res = {'ListStacksResponse': {
'ListStacksResult': {'StackSummaries': []}}}
results = res['ListStacksResponse']['ListStacksResult']
summaries = results['StackSummaries']
if stack_list != None:
for s in stack_list['stacks']:
summaries.append(s)
return res
def delete(self, req):
"""
Returns the following information for all stacks:
"""
con = context.get_admin_context()
try:
res = rpc.call(con, 'engine',
{'method': 'delete_stack',
'args': {'stack_name': req.params['StackName'],
'params': dict(req.params)}})
except rpc_common.RemoteError as ex:
return webob.exc.HTTPBadRequest(str(ex))
if res == None:
return {'DeleteStackResult': ''}
else:
return {'DeleteStackResult': res['Error']}
def describe(self, req):
"""
Returns the following information for all stacks:
"""
con = context.get_admin_context()
try:
stack_list = rpc.call(con, 'engine',
{'method': 'show_stack',
'args': {'stack_name': req.params['StackName'],
'params': dict(req.params)}})
except rpc_common.RemoteError as ex:
return webob.exc.HTTPBadRequest(str(ex))
res = {'DescribeStacksResult': {'Stacks': []}}
stacks = res['DescribeStacksResult']['Stacks']
for s in stack_list['stacks']:
mem = {'member': s}
stacks.append(mem)
return res
def list_stacks(self, req):
con = context.get_admin_context()
resp = rpc.call(con, 'engine',
{'method': 'metadata_list_stacks'})
return resp
def periodic_tasks(self, raise_on_error=False):
"""Tasks to be run at a periodic interval."""
ctxt = context.get_admin_context()
self.manager.periodic_tasks(ctxt, raise_on_error=raise_on_error)
