def FnGetAtt(self, key, *path):
if key == self.CURRENT_SIZE:
return grouputils.get_size(self)
if path:
members = grouputils.get_members(self)
attrs = ((rsrc.name, rsrc.FnGetAtt(*path)) for rsrc in members)
if key == self.OUTPUTS:
return dict(attrs)
if key == self.OUTPUTS_LIST:
return [value for name, value in attrs]
if key.startswith("resource."):
return grouputils.get_nested_attrs(self, key, True, *path)
raise exception.InvalidTemplateAttribute(resource=self.name, key=key)
def FnGetAtt(self, key, *path):
stack = self.nested()
if stack is None:
return None
# first look for explicit resource.x.y
if key.startswith('resource.'):
return grouputils.get_nested_attrs(self, key, False, *path)
# then look for normal outputs
if key in stack.outputs:
return attributes.select_from_attribute(self.get_output(key), path)
# otherwise the key must be wrong.
raise exception.InvalidTemplateAttribute(resource=self.name, key=key)
def FnGetAtt(self, key):
if key == 'id':
return self.resource_id
attributes = [
'availability_zone', 'size', 'snapshot_id', 'display_name',
'display_description', 'volume_type', 'metadata', 'source_volid',
'status', 'created_at', 'bootable'
]
if key not in attributes:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
vol = self.cinder().volumes.get(self.resource_id)
if key == 'metadata':
return unicode(json.dumps(vol.metadata))
return unicode(getattr(vol, key))
def FnGetAtt(self, key, *path):
'''
For the intrinsic function Fn::GetAtt.
:param key: the attribute key.
:param path: a list of path components to select from the attribute.
:returns: the attribute value.
'''
try:
attribute = self.attributes[key]
except KeyError:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
else:
return attributes.select_from_attribute(attribute, path)
def get_output(self, op):
'''
Return the specified Output value from the nested stack.
If the output key does not exist, raise an InvalidTemplateAttribute
exception.
'''
stack = self.nested()
if stack is None:
return None
if op not in stack.outputs:
raise exception.InvalidTemplateAttribute(
resource=self.physical_resource_name(), key=op)
return stack.output(op)
def get_attribute(self, key, *path):
if self.resource_id is None:
return None
# first look for explicit resource.x.y
if key.startswith('resource.'):
return grouputils.get_nested_attrs(self, key, False, *path)
# then look for normal outputs
try:
return attributes.select_from_attribute(self.get_output(key),
path)
except exception.NotFound:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
def FnGetAtt(self, key):
'''
Resource attributes map to deployment outputs values
'''
sd = self.heat().software_deployments.get(self.resource_id)
if key in sd.output_values:
return sd.output_values.get(key)
# Since there is no value for this key yet, check the output schemas
# to find out if the key is valid
sc = self.heat().software_configs.get(self.properties[self.CONFIG])
output_keys = [output['name'] for output in sc.outputs]
if key not in output_keys and key not in self.DEPLOY_ATTRIBUTES:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
def _resolve_attribute(self, key):
"""Return the method that provides a given template attribute."""
attribute_function = {
'PublicIp': self.public_ip,
'PrivateIp': self.private_ip,
'PublicDnsName': self.public_ip,
'PrivateDnsName': self.public_ip
}
if key not in attribute_function:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
function = attribute_function[key]
logger.info('%s._resolve_attribute(%s) == %s' %
(self.name, key, function))
return unicode(function)
def FnGetAtt(self, key):
if key.startswith("resource."):
parts = key.split(".", 2)
attr_name = parts[-1]
try:
res = self.nested()[parts[1]]
except KeyError:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
else:
return res.FnGetAtt(attr_name)
else:
return [
self.nested()[str(v)].FnGetAtt(key)
for v in range(self.properties['count'])
]
def FnGetAtt(self, key):
res = None
if key == 'AvailabilityZone':
res = self.properties['AvailabilityZone']
elif key == 'PublicIp':
res = self._ipaddress()
elif key == 'PrivateDnsName':
res = self._ipaddress()
else:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
# TODO(asalkeld) PrivateDnsName, PublicDnsName & PrivateIp
logger.info('%s.GetAtt(%s) == %s' % (self.name, key, res))
return unicode(res)
def test_construct_input_data_exception(self):
expected_input_data = {
'attrs': {},
'id': mock.ANY,
'reference_id': 'A',
'name': 'A',
'uuid': mock.ANY,
'action': mock.ANY,
'status': mock.ANY
}
self.resource.get_attribute = mock.Mock(
side_effect=exception.InvalidTemplateAttribute(resource='A',
key='value'))
actual_input_data = worker.construct_input_data(
self.resource, self.stack)
self.assertEqual(expected_input_data, actual_input_data)
def FnGetAtt(self, key):
res = None
log_res = None
if key == 'UserName':
res = self.properties['UserName']
log_res = res
elif key == 'SecretAccessKey':
res = self._secret_accesskey()
log_res = "<SANITIZED>"
else:
raise exception.InvalidTemplateAttribute(
resource=self.physical_resource_name(), key=key)
logger.info('%s.GetAtt(%s) == %s' %
(self.physical_resource_name(), key, log_res))
return unicode(res)
def FnGetAtt(self, key):
res = None
if key == 'Data':
try:
meta = self.metadata
if meta and 'Data' in meta:
res = meta['Data']
except Exception as ex:
pass
else:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
logger.debug('%s.GetAtt(%s) == %s' % (self.name, key, res))
return unicode(res)
def validate(self):
super(GetAttThenSelect, self).validate()
res = self._resource()
if self._allow_without_attribute_name():
# if allow without attribute_name, then don't check
# when attribute_name is None
if self._attribute is None:
return
attr = function.resolve(self._attribute)
from heat.engine import resource
if (type(res).get_attribute == resource.Resource.get_attribute
and attr not in res.attributes_schema):
raise exception.InvalidTemplateAttribute(
resource=self._resource_name, key=attr)
def test_node_data_exception(self):
self.resource.action = self.resource.CREATE
expected_input_data = {
'attrs': {},
'id': mock.ANY,
'reference_id': 'A',
'name': 'A',
'uuid': mock.ANY,
'action': mock.ANY,
'status': mock.ANY
}
self.resource.get_attribute = mock.Mock(
side_effect=exception.InvalidTemplateAttribute(resource='A',
key='value'))
actual_input_data = self.resource.node_data()
self.assertEqual(expected_input_data, actual_input_data.as_dict())
def FnGetAtt(self, key):
'''
We don't really support any of these yet.
'''
allow = ('CanonicalHostedZoneName', 'CanonicalHostedZoneNameID',
'DNSName', 'SourceSecurityGroupName',
'SourceSecurityGroupOwnerAlias')
if not key in allow:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
if key == 'DNSName':
return self.get_output('PublicIp')
else:
return ''
def FnGetAtt(self, key, *path):
if key.startswith("resource."):
return grouputils.get_nested_attrs(self, key, False, *path)
names = self._resource_names()
if key == self.REFS:
return [grouputils.get_rsrc_id(self, key, False, n) for n in names]
if key == self.ATTR_ATTRIBUTES:
if not path:
raise exception.InvalidTemplateAttribute(
resource=self.name, key=key)
return dict((n, grouputils.get_rsrc_attr(
self, key, False, n, *path)) for n in names)
path = [key] + list(path)
return [grouputils.get_rsrc_attr(self, key, False, n, *path)
for n in names]
def _resolve_attribute(self, key):
if self.resource_id:
lb = self.clb.get(self.resource_id)
attribute_function = {
self.PUBLIC_IP: self._public_ip(lb),
self.VIPS: [{"id": vip.id,
"type": vip.type,
"ip_version": vip.ip_version}
for vip in lb.virtual_ips]
}
if key not in attribute_function:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
function = attribute_function[key]
LOG.info(_LI('%(name)s.GetAtt(%(key)s) == %(function)s'),
{'name': self.name, 'key': key, 'function': function})
return function
def FnGetAtt(self, key):
res = {}
handle_res_name = self._get_handle_resource_name()
handle = self.stack[handle_res_name]
if key == 'Data':
meta = handle.metadata
# Note, can't use a dict generator on python 2.6, hence:
res = dict([(k, meta[k]['Data']) for k in meta])
else:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
logger.debug(_('%(name)s.GetAtt(%(key)s) == %(res)s') %
{'name': self.name,
'key': key,
'res': res})
return unicode(json.dumps(res))
def get_attribute(self, key, *path):
"""Resource attributes map to deployment outputs values."""
sd = self.rpc_client().show_software_deployment(
self.context, self.resource_id)
ov = sd[rpc_api.SOFTWARE_DEPLOYMENT_OUTPUT_VALUES] or {}
if key in ov:
attribute = ov.get(key)
return attributes.select_from_attribute(attribute, path)
# Since there is no value for this key yet, check the output schemas
# to find out if the key is valid
sc = self.rpc_client().show_software_config(
self.context, self.properties[self.CONFIG])
outputs = sc[rpc_api.SOFTWARE_CONFIG_OUTPUTS] or []
output_keys = [output['name'] for output in outputs]
if key not in output_keys and key not in self.ATTRIBUTES:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
return None
def get_attribute(self, key, *path):
if key.startswith('resource.'):
return grouputils.get_nested_attrs(self, key, False, *path)
resource_types = self.properties[self.RESOURCES]
names = self._resource_names(resource_types)
if key == self.REFS:
vals = [grouputils.get_rsrc_id(self, key, False, n) for n in names]
return attributes.select_from_attribute(vals, path)
if key == self.ATTR_ATTRIBUTES:
if not path:
raise exception.InvalidTemplateAttribute(
resource=self.name, key=key)
return dict((n, grouputils.get_rsrc_attr(
self, key, False, n, *path)) for n in names)
path = [key] + list(path)
return [grouputils.get_rsrc_attr(self, key, False, n, *path)
for n in names]
def get_attribute(self, key, *path):
def _collect_cluster_attrs(attr_path):
parser = parse(attr_path)
cluster = self.client().get_cluster(self.resource_id)
nodes_attrs = []
for node_id in cluster.node_ids:
node = self.client().get_node(node_id, details=True)
node_info = node.to_dict()
matches = [m.value for m in parser.find(node_info)]
nodes_attrs.append(matches[0])
return nodes_attrs
if key == self.ATTR_COLLECT:
if not path:
raise exception.InvalidTemplateAttribute(
resource=self.name, key=key)
attrs = _collect_cluster_attrs(path[0])
return attributes.select_from_attribute(attrs, path[1:])
else:
return super(Cluster, self).get_attribute(key, *path)
def FnGetAtt(self, key, *path):
'''
For the intrinsic function Fn::GetAtt.
:param key: the attribute key.
:param path: a list of path components to select from the attribute.
:returns: the attribute value.
'''
if self.stack.has_cache_data():
# Load from cache for lightweight resources.
attribute = self.stack.cache_data_resource_attribute(
self.name, key)
else:
try:
attribute = self.attributes[key]
except KeyError:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
return attributes.select_from_attribute(attribute, path)
def get_attribute(self, key, *path):
if key == self.ATTR_ATTRIBUTES and not path:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
try:
output = self.get_output(self._attribute_output_name(key, *path))
except (exception.NotFound, exception.TemplateOutputError) as op_err:
resource_types = self.properties[self.RESOURCES]
names = self._resource_names(resource_types)
if key.startswith('resource.'):
target = key.split('.', 2)[1]
if target not in names:
raise exception.NotFound(
_("Member '%(mem)s' not "
"found in group resource "
"'%(grp)s'.") % {
'mem': target,
'grp': self.name
})
LOG.debug('Falling back to grouputils due to %s', op_err)
else:
if key == self.REFS:
return attributes.select_from_attribute(output, path)
return output
if key.startswith('resource.'):
return grouputils.get_nested_attrs(self, key, False, *path)
if key == self.REFS:
vals = [grouputils.get_rsrc_id(self, key, False, n) for n in names]
return attributes.select_from_attribute(vals, path)
if key == self.ATTR_ATTRIBUTES:
return dict(
(n, grouputils.get_rsrc_attr(self, key, False, n, *path))
for n in names)
path = [key] + list(path)
return [
grouputils.get_rsrc_attr(self, key, False, n, *path) for n in names
]
def handle_get_attr(args):
resource = args[0]
try:
r = resources[resource]
if r.state in ((r.CREATE, r.IN_PROGRESS), (r.CREATE,
r.COMPLETE),
(r.RESUME, r.IN_PROGRESS), (r.RESUME,
r.COMPLETE),
(r.UPDATE, r.IN_PROGRESS), (r.UPDATE,
r.COMPLETE)):
rsrc_attr = args[1]
attr = r.FnGetAtt(rsrc_attr)
try:
for inner_attr in args[2:]:
attr = attr[inner_attr]
return attr
except (KeyError, IndexError, TypeError):
return ''
except (KeyError, IndexError):
raise exception.InvalidTemplateAttribute(resource=resource,
key=rsrc_attr)
def get_attribute(self, key, *path):
if key.startswith("resource."):
return grouputils.get_nested_attrs(self, key, False, *path)
names = self._resource_names()
if key == self.REFS:
vals = [grouputils.get_rsrc_id(self, key, False, n) for n in names]
return attributes.select_from_attribute(vals, path)
if key == self.REFS_MAP:
refs_map = {n: grouputils.get_rsrc_id(self, key, False, n)
for n in names}
return refs_map
if key == self.ATTR_ATTRIBUTES:
if not path:
raise exception.InvalidTemplateAttribute(
resource=self.name, key=key)
return dict((n, grouputils.get_rsrc_attr(
self, key, False, n, *path)) for n in names)
path = [key] + list(path)
return [grouputils.get_rsrc_attr(self, key, False, n, *path)
for n in names]
def FnGetAtt(self, key):
if key.startswith("resource."):
parts = key.split(".", 2)
attr_name = parts[-1] if len(parts) > 2 else None
try:
res = self.nested()[parts[1]]
except KeyError:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
else:
return (res.FnGetRefId() if attr_name is None
else res.FnGetAtt(attr_name))
else:
def get_aggregated_attr(func, *args):
for n in range(self.properties[self.COUNT]):
resource_method = getattr(self.nested()[str(n)], func)
yield resource_method(*args)
method_name, method_call = (("FnGetRefId", []) if "refs" == key
else ("FnGetAtt", [key]))
return [val for val in get_aggregated_attr(method_name,
*method_call)]
def FnGetAtt(self, key, *path):
stack = self.nested()
if stack is None:
return None
def _get_inner_resource(resource_name):
if self.nested() is not None:
try:
return self.nested()[resource_name]
except KeyError:
raise exception.ResourceNotFound(
resource_name=resource_name,
stack_name=self.nested().name)
def get_rsrc_attr(resource_name, *attr_path):
resource = _get_inner_resource(resource_name)
return resource.FnGetAtt(*attr_path)
def get_rsrc_id(resource_name):
resource = _get_inner_resource(resource_name)
return resource.FnGetRefId()
# first look for explicit resource.x.y
if key.startswith('resource.'):
npath = key.split(".", 2)[1:] + list(path)
if len(npath) > 1:
return get_rsrc_attr(*npath)
else:
return get_rsrc_id(*npath)
# then look for normal outputs
if key in stack.outputs:
return attributes.select_from_attribute(stack.output(key), path)
# otherwise the key must be wrong.
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
def FnGetAtt(self, key, *path):
nested_stack = self.nested()
def get_resource(resource_name):
try:
return nested_stack[resource_name]
except KeyError:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
def get_rsrc_attr(resource_name, *attr_path):
resource = get_resource(resource_name)
return resource.FnGetAtt(*attr_path)
def get_rsrc_id(resource_name):
resource = get_resource(resource_name)
return resource.FnGetRefId()
if key.startswith("resource."):
path = key.split(".", 2)[1:] + list(path)
if len(path) > 1:
return get_rsrc_attr(*path)
else:
return get_rsrc_id(*path)
names = self._resource_names()
if key == self.REFS:
return [get_rsrc_id(n) for n in names]
if key == self.ATTR_ATTRIBUTES:
if not path:
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
return dict((n, get_rsrc_attr(n, *path)) for n in names)
path = [key] + list(path)
return [get_rsrc_attr(n, *path) for n in names]
def FnGetAtt(self, key):
if key and not key.startswith('Outputs.'):
raise exception.InvalidTemplateAttribute(resource=self.name,
key=key)
return self.get_output(key.partition('.')[-1])