def describe_stack_resources(self, context, stack_name,
physical_resource_id, logical_resource_id):
auth.authenticate(context)
if stack_name is not None:
s = db_api.stack_get_by_name(context, stack_name)
else:
rs = db_api.resource_get_by_physical_resource_id(context,
physical_resource_id)
if not rs:
msg = "The specified PhysicalResourceId doesn't exist"
raise AttributeError(msg)
s = rs.stack
if not s:
raise AttributeError("The specified stack doesn't exist")
stack = parser.Stack.load(context, s.id)
if logical_resource_id is not None:
name_match = lambda r: r.name == logical_resource_id
else:
name_match = lambda r: True
return [api.format_stack_resource(resource)
for resource in stack if resource.id is not None and
name_match(resource)]
def event_create(self, context, event):
auth.authenticate(context)
stack_name = event['stack']
resource_name = event['resource']
stack = db_api.stack_get_by_name(context, stack_name)
resource = db_api.resource_get_by_name_and_stack(context,
resource_name,
stack.id)
if not resource:
return ['Unknown resource', None]
new_event = {
'name': event['message'],
'resource_status_reason': event['reason'],
'StackId': stack.id,
'LogicalResourceId': resource.name,
'PhysicalResourceId': None,
'ResourceType': event['resource_type'],
'ResourceProperties': {},
}
try:
result = db_api.event_create(context, new_event)
new_event['id'] = result.id
return [None, new_event]
except Exception as ex:
logger.warn('db error %s' % str(ex))
msg = 'Error creating event'
return [msg, None]
def setUp(self):
self.m = mox.Mox()
self.ctx = create_context(self.m, self.username, self.tenant)
auth.authenticate(self.ctx).AndReturn(True)
setup_mocks(self.m, self.stack)
self.m.ReplayAll()
self.man = manager.EngineManager()
def list_stack_resources(self, context, stack_name):
auth.authenticate(context)
s = db_api.stack_get_by_name(context, stack_name)
if not s:
raise AttributeError('Unknown stack name')
stack = parser.Stack.load(context, s.id)
return [api.format_stack_resource(resource)
for resource in stack if resource.id is not None]
def get_template(self, context, stack_name, params):
"""
Get the template.
arg1 -> RPC context.
arg2 -> Name of the stack you want to see.
arg3 -> Dict of http request parameters passed in from API side.
"""
auth.authenticate(context)
s = db_api.stack_get_by_name(context, stack_name)
if s:
return s.raw_template.template
return None
def test_validate_volumeattach_invalid(self):
t = json.loads(test_template_volumeattach % 'sda')
self.m.StubOutWithMock(auth, 'authenticate')
auth.authenticate(None).AndReturn(True)
stack = parser.Stack(None, 'test_stack', parser.Template(t))
self.m.StubOutWithMock(db_api, 'resource_get_by_name_and_stack')
db_api.resource_get_by_name_and_stack(None, 'test_resource_name',
stack).AndReturn(None)
self.m.ReplayAll()
volumeattach = stack.resources['MountPoint']
self.assertTrue(volumeattach.validate())
def test_validate_findinmap_invalid(self):
t = json.loads(test_template_findinmap_invalid)
t['Parameters']['KeyName']['Value'] = 'test'
params = {}
self.m.StubOutWithMock(auth, 'authenticate')
auth.authenticate(None).AndReturn(True)
self.m.StubOutWithMock(instances.Instance, 'nova')
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
manager = managers.EngineManager()
res = dict(manager.
validate_template(None, t, params)['ValidateTemplateResult'])
self.assertNotEqual(res['Description'], 'Successfully validated')
def describe_stack_resource(self, context, stack_name, resource_name):
auth.authenticate(context)
s = db_api.stack_get_by_name(context, stack_name)
if not s:
raise AttributeError('Unknown stack name')
stack = parser.Stack.load(context, s.id)
if resource_name not in stack:
raise AttributeError('Unknown resource name')
resource = stack[resource_name]
if resource.id is None:
raise AttributeError('Resource not created')
return api.format_stack_resource(stack[resource_name])
def test_validate_ref_valid(self):
t = json.loads(test_template_ref % 'WikiDatabase')
t['Parameters']['KeyName']['Value'] = 'test'
params = {}
self.m.StubOutWithMock(auth, 'authenticate')
auth.authenticate(None).AndReturn(True)
self.m.StubOutWithMock(instances.Instance, 'nova')
instances.Instance.nova().AndReturn(self.fc)
self.m.ReplayAll()
manager = managers.EngineManager()
res = dict(manager.
validate_template(None, t, params)['ValidateTemplateResult'])
print 'res %s' % res
self.assertEqual(res['Description'], 'test.')
def nova(self, service_type='compute'):
if service_type in self._nova:
return self._nova[service_type]
self._nova[service_type] = auth.authenticate(self.context,
service_type=service_type,
service_name=None)
return self._nova[service_type]
def nova(self, service_type='compute'):
if service_type in self._nova:
return self._nova[service_type]
self._nova[service_type] = auth.authenticate(self.context,
service_type=service_type,
service_name=None)
return self._nova[service_type]
def delete_stack(self, context, stack_name, params):
"""
The delete_stack method deletes a given stack.
arg1 -> RPC context.
arg2 -> Name of the stack you want to delete.
arg3 -> Params passed from API.
"""
auth.authenticate(context)
st = db_api.stack_get_by_name(context, stack_name)
if not st:
raise AttributeError('Unknown stack name')
logger.info('deleting stack %s' % stack_name)
stack = parser.Stack.load(context, st.id)
greenpool.spawn_n(stack.delete)
return None
def list_events(self, context, stack_name, params):
"""
The list_events method lists all events associated with a given stack.
arg1 -> RPC context.
arg2 -> Name of the stack you want to get events for.
arg3 -> Params passed from API.
"""
auth.authenticate(context)
if stack_name is not None:
st = db_api.stack_get_by_name(context, stack_name)
if not st:
raise AttributeError('Unknown stack name')
events = db_api.event_get_all_by_stack(context, st.id)
else:
events = db_api.event_get_all_by_tenant(context)
return {'events': [api.format_event(e) for e in events]}
def validate_template(self, context, template, params):
"""
The validate_template method uses the stack parser to check
the validity of a template.
arg1 -> RPC context.
arg3 -> Template of stack you want to create.
arg4 -> Params passed from API.
"""
auth.authenticate(context)
logger.info('validate_template')
if template is None:
msg = _("No Template provided.")
return webob.exc.HTTPBadRequest(explanation=msg)
tmpl = parser.Template(template)
resources = template.get('Resources', [])
if not resources:
return {'Error': 'At least one Resources member must be defined.'}
for res in resources.values():
if not res.get('Type'):
return {'Error':
'Every Resources object must contain a Type member.'}
parameters = []
for param_key, param in template.get('Parameters', {}).items():
parameters.append({
'NoEcho': param.get('NoEcho', 'false'),
'ParameterKey': param_key,
'Description': param.get('Description', '')
})
result = {
'Description': template.get('Description', ''),
'Parameters': parameters,
}
return {'ValidateTemplateResult': result}
def update_stack(self, context, stack_name, template, params, args):
"""
The update_stack method updates an existing stack based on the
provided template and parameters.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
auth.authenticate(context)
# Get the database representation of the existing stack
db_stack = db_api.stack_get_by_name(None, stack_name)
if not db_stack:
raise AttributeError('No stack exists with that name')
current_stack = parser.Stack.load(context, db_stack.id)
# Now parse the template and any parameters for the updated
# stack definition.
tmpl = parser.Template(template)
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
updated_stack = parser.Stack(context, stack_name, tmpl,
template_params, **common_params)
response = updated_stack.validate()
if response['Description'] != 'Successfully validated':
return response
greenpool.spawn_n(current_stack.update, updated_stack)
return {'StackName': current_stack.name, 'StackId': current_stack.id}
def show_stack(self, context, stack_name, params):
"""
The show_stack method returns the attributes of one stack.
arg1 -> RPC context.
arg2 -> Name of the stack you want to see, or None to see all
arg3 -> Dict of http request parameters passed in from API side.
"""
auth.authenticate(context)
if stack_name is not None:
s = db_api.stack_get_by_name(context, stack_name)
if s:
stacks = [s]
else:
raise AttributeError('Unknown stack name')
else:
stacks = db_api.stack_get_by_tenant(context) or []
def format_stack_detail(s):
stack = parser.Stack.load(context, s.id)
return api.format_stack(stack)
return {'stacks': [format_stack_detail(s) for s in stacks]}
def create_stack(self, context, stack_name, template, params, args):
"""
The create_stack method creates a new stack using the template
provided.
Note that at this stage the template has already been fetched from the
heat-api process if using a template-url.
arg1 -> RPC context.
arg2 -> Name of the stack you want to create.
arg3 -> Template of stack you want to create.
arg4 -> Stack Input Params
arg4 -> Request parameters/args passed from API
"""
logger.info('template is %s' % template)
auth.authenticate(context)
if db_api.stack_get_by_name(None, stack_name):
raise AttributeError('Stack already exists with that name')
tmpl = parser.Template(template)
# Extract the template parameters, and any common query parameters
template_params = parser.Parameters(stack_name, tmpl, params)
common_params = api.extract_args(args)
stack = parser.Stack(context, stack_name, tmpl, template_params,
**common_params)
response = stack.validate()
if response['Description'] != 'Successfully validated':
return response
stack_id = stack.store()
greenpool.spawn_n(stack.create)
return {'StackName': stack.name, 'StackId': stack.id}
