def relationship(self):
'''Return a dictionary of relationships to other node types.
This method returns a dictionary of named relationships that nodes
of the current node type (self) can have to other nodes (of specific
types) in a TOSCA template.
'''
relationship = {}
requires = self.get_all_requirements()
if requires:
# NOTE(sdmonov): Check if requires is a dict.
# If it is a dict convert it to a list of dicts.
# This is needed because currently the code below supports only
# lists as requirements definition. The following check will
# make sure if a map (dict) was provided it will be converted to
# a list before proceeding to the parsing.
if isinstance(requires, dict):
requires = [{key: value} for key, value in requires.items()]
keyword = None
node_type = None
for req in requires:
#get all keys in requirement
if 'relationship' in req:
keys = req.keys()
for k in keys:
if k not in self.SECTIONS:
relation = req.get('relationship')
node_type = req.get(k)
keyword = k
break
else:
for key, value in req.items():
if key == 'type':
continue
if key == 'interfaces':
continue
else:
# If value is a dict and has a type key we need
# to lookup the node type using the capability type
if isinstance(value, dict) and \
'type' in value:
captype = value['type']
value = \
self._get_node_type_by_cap(key, captype)
relation = self._get_relation(key, value)
keyword = key
node_type = value
rtype = RelationshipType(relation, keyword, req)
relatednode = NodeType(node_type, self.custom_def)
relationship[rtype] = relatednode
return relationship
def __init__(self, name, template, entity_name, custom_def=None):
self.name = name
self.entity_tpl = template
self.custom_def = custom_def
self._validate_field(self.entity_tpl)
if entity_name == 'node_type':
self.type_definition = NodeType(self.entity_tpl['type'],
custom_def)
if entity_name == 'relationship_type':
self.type_definition = RelationshipType(self.entity_tpl['type'],
None, custom_def)
self._properties = None
self._interfaces = None
self._requirements = None
self._capabilities = None
def relationship(self):
'''returns a dictionary containing relationship to a particular
node type '''
relationship = {}
requirs = self.requirements
if requirs is None:
requirs = self._get_value(REQUIREMENTS, None, True)
if requirs:
for req in requirs:
for x, y in req.iteritems():
relation = self._get_relation(x, y)
rtype = RelationshipType(relation, x)
relatednode = NodeType(y)
relationship[rtype] = relatednode
return relationship
def _get_explicit_relationship(self, req, value):
"""Handle explicit relationship
For example,
- req:
node: DBMS
relationship: tosca.relationships.HostedOn
"""
explicit_relation = {}
node = value.get('node')
if node:
#TODO(spzala) implement look up once Glance meta data is available
#to find a matching TOSCA node using the TOSCA types
msg = _('Lookup by TOSCA types are not supported. '
'Requirement for %s can not be full-filled.') % self.name
if (node in list(self.type_definition.TOSCA_DEF.keys())
or node in self.custom_def):
raise NotImplementedError(msg)
related_tpl = NodeTemplate(node, self.templates, self.custom_def)
relationship = value.get('relationship')
if relationship:
found_relationship_tpl = False
#apply available relationship templates if found
for tpl in self.available_rel_tpls:
if tpl.name == relationship:
rtype = RelationshipType(tpl.type)
explicit_relation[rtype] = related_tpl
self.relationship_tpl.append(tpl)
found_relationship_tpl = True
#create relationship template object.
if not found_relationship_tpl:
if isinstance(relationship, dict):
relationship = relationship.get('type')
for rtype in self.type_definition.relationship.keys():
if rtype.type == relationship:
explicit_relation[rtype] = related_tpl
related_tpl._add_relationship_template(
req, rtype.type)
return explicit_relation
