def _relationship_templates(self):
rel_templates = []
tpls = self._tpl_relationship_templates()
for name in tpls:
tpl = RelationshipTemplate(tpls[name], name, self.custom_defs)
rel_templates.append(tpl)
return rel_templates
def _relationship_templates(self):
rel_templates = []
tpls = self._tpl_relationship_templates()
for name in tpls:
exception.TOSCAException.set_context("relationships", name)
tpl = RelationshipTemplate(tpls[name], name, self.custom_defs)
rel_templates.append(tpl)
exception.TOSCAException.reset_context()
return rel_templates
def _get_attachment_node(self, node, suffix, volume_name):
attach = False
ntpl = self.nodetemplates
for key_r, value_n in node.relationships.items():
if key_r.is_derived_from('tosca.relationships.AttachesTo'):
if value_n.is_derived_from('tosca.nodes.BlockStorage'):
if volume_name == value_n.name:
attach = True
if attach:
relationship_tpl = None
for req in node.requirements:
for key, val in req.items():
if isinstance(val, dict):
if value_n.name != val.get('node'):
continue
else:
if value_n.name != val:
continue
attach = val
relship = val.get('relationship')
for rkey, rval in val.items():
if relship and isinstance(relship, dict):
for rkey, rval in relship.items():
if rkey == 'type':
relationship_tpl = val
attach = rval
elif rkey == 'template':
rel_tpl_list = \
(self.tosca.topology_template.
_tpl_relationship_templates())
relationship_tpl = rel_tpl_list[rval]
attach = rval
else:
continue
elif isinstance(relship, str):
attach = relship
relationship_tpl = val
relationship_templates = \
self.tosca._tpl_relationship_templates()
if 'relationship' in relationship_tpl and \
attach not in \
self.tosca._tpl_relationship_types() and \
attach in relationship_templates:
relationship_tpl['relationship'] = \
relationship_templates[attach]
break
if relationship_tpl:
rval_new = attach + "_" + str(suffix)
att = RelationshipTemplate(
relationship_tpl, rval_new,
self.tosca._tpl_relationship_types())
hot_node = ToscaBlockStorageAttachment(att, ntpl,
node.name,
volume_name
)
return hot_node
def test_relationship_template_properties(self):
tpl_snippet = '''
relationship_templates:
storage_attachto:
type: AttachesTo
properties:
device: test_device
'''
expectedmessage = _('"properties" of template "storage_attachto" is '
'missing required field "[\'location\']".')
rel_template = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet)
)['relationship_templates']
name = list(rel_template.keys())[0]
rel_template = RelationshipTemplate(rel_template[name], name)
err = self.assertRaises(exception.MissingRequiredFieldError,
rel_template.validate)
self.assertEqual(expectedmessage, six.text_type(err))
def _add_relationship_template(self, requirement, rtype, source):
req = requirement.copy()
req['type'] = rtype
tpl = RelationshipTemplate(req, rtype, self.custom_def, self, source)
self.relationship_tpl.append(tpl)
def _get_explicit_relationship(self, req):
"""Handle explicit relationship
For example,
- req:
node: DBMS
relationship: tosca.relationships.HostedOn
Returns a requirements dict and either RelationshipTemplate or None if there was a validation error.
If no relationship was either assigned or defined by the node's type definition,
one with type "tosca.relationships.Root" will be returned.
"""
name, value = next(iter(req.items())) # list only has one item
typeReqDef = self._getRequirementDefinition(name)
reqDef = typeReqDef.copy()
if isinstance(value, dict):
# see 3.8.2 Requirement assignment p. 140 for value
reqDef.update(value)
else:
reqDef['node'] = value
relationship = reqDef['relationship']
relTpl = None
type = None
if isinstance(relationship, dict):
type = relationship.get('type')
if not type:
ExceptionCollector.appendException(
MissingRequiredFieldError(
what=_('"relationship" used in template '
'"%s"') % self.name,
required=self.TYPE))
return reqDef, None
elif (relationship in self.custom_def
or relationship in self.type_definition.RELATIONSHIP_TYPE):
type = relationship
relationship = dict(type=relationship) # it's the name of a type
else:
# it's the name of a relationship template
for tpl in self.available_rel_tpls:
if tpl.name == relationship:
type = tpl.type
relTpl = tpl
break
else:
ExceptionCollector.appendException(
ValidationError(
message=
_('Relationship template "%(relationship)s" was not found'
' for requirement "%(rname)s" of node "%(nname)s".')
% {
'relationship': relationship,
'rname': name,
'nname': self.name
}))
return reqDef, None
if not relTpl:
assert isinstance(
relationship,
dict) and relationship['type'] == type, (relationship, type)
relTpl = RelationshipTemplate(relationship, name, self.custom_def)
relTpl.source = self
node = reqDef.get('node')
node_filter = reqDef.get('node_filter')
related_node = None
related_capability = None
if node:
related_node = self.topology_template.node_templates.get(node)
if related_node:
capabilities = relTpl.get_matching_capabilities(
related_node, reqDef.get('capability'))
if not capabilities:
if 'capability' in reqDef:
ExceptionCollector.appendException(
ValidationError(
message=
_('No matching capability "%(cname)s" found'
' on target node "%(tname)s" for requirement "%(rname)s" of node "%(nname)s".'
) % {
'rname': name,
'nname': self.name,
'cname': reqDef['capability'],
'tname': related_node.name
}))
return reqDef, None
else:
ExceptionCollector.appendException(
ValidationError(
message=
_('No capability with a matching target type found'
' on target node "%(tname)s" for requirement "%(rname)s" of node "%(nname)s".'
) % {
'rname': name,
'nname': self.name,
'tname': related_node.name
}))
return reqDef, None
related_capability = capabilities[0] # first one is best match
elif 'capability' not in reqDef and not relTpl.type_definition.valid_target_types and not node_filter:
ExceptionCollector.appendException(
ValidationError(
message=
'requirement "%s" of node "%s" must specify a node_filter, a node or a capability'
% (name, self.name)))
return reqDef, None
if not related_node:
# check if "node" is a node type
for nodeTemplate in self.topology_template.node_templates.values():
found = None
found_cap = None
# check if node name is node type
if not node or nodeTemplate.is_derived_from(node):
capability = reqDef.get('capability')
# should have already returned an error if this assertion is false
if capability or relTpl.type_definition.valid_target_types:
capabilities = relTpl.get_matching_capabilities(
nodeTemplate, capability)
if capabilities:
found = nodeTemplate
found_cap = capabilities[0] # first is best match
else:
continue # didn't match capabilities, don't check node_filter
if node_filter:
if nodeTemplate.match_nodefilter(node_filter):
found = nodeTemplate
else:
continue
if found:
if related_node:
if "default" in found.directives:
continue
elif "default" in related_node.directives:
related_node = found
related_capability = found_cap
else:
ExceptionCollector.appendException(
ValidationError(
message=
'requirement "%s" of node ""%s" is ambiguous, targets more than one template: "%s" and "%s"'
% (name, self.name, related_node.name,
found.name)))
return reqDef, None
else:
related_node = found
related_capability = found_cap
if related_node:
# if relTpl is in available_rel_tpls what if target and source are already assigned?
relTpl.target = related_node
relTpl.capability = related_capability
related_node.relationship_tpl.append(relTpl)
else:
ExceptionCollector.appendException(
ValidationError(message=_(
'No matching target template found'
' for requirement "%(rname)s" of node "%(nname)s".') % {
'rname': name,
'nname': self.name
}))
return reqDef, None
return reqDef, relTpl
