def _instatiateWithType(self, node_type):
self.type = node_type.name
self.type_obj = node_type
self.properties = {}
for prop in node_type.properties.keys():
self.properties[prop] = PropertyItem(node_type.properties[prop])
self.attributes = {}
for attr in node_type.attributes.keys():
self.attributes[attr] = PropertyItem(node_type.attributes[attr])
self.requirements = []
for req in node_type.requirements:
self.requirements.append(RequirementItem(req))
self.capabilities = {}
for cap in node_type.capabilities.keys():
self.capabilities[cap] = CapabilityItem(
node_type.capabilities[cap])
self.interfaces = {}
for intf in node_type.interfaces.keys():
self.interfaces[intf] = InterfaceItem(node_type.interfaces[intf])
# if node_type.mapping_template is not None:
# from toscalib.templates.topology import ToscaTopology
# self.mapping_template = copy.deepcopy(node_type.mapping_template)
# self.mapping_template._update_prefix(self.name + '_')
# self.mapping_template._verify_substitution(self)
# # for sub_rule in node_type.mapping_template.sub_rules:
# # sub_rule._update_pointer(self, self.mapping_template)
self._update_parent_node()
def __init__(self, definition):
self.name = definition.name
self.type = definition.type
self.definition = definition
self.properties = {}
self.id = PropertyItem(definition.id)
self.sub_pointer = None
self.parent_node = None
for prop in definition.properties.keys():
self.properties[prop] = PropertyItem(definition.properties[prop])
def _parse_pre_defined_content(self, content):
if content is None:
return
for key_name in content.keys():
if key_name == 'type':
if self.type is not None and self.type != content[key_name]:
logging.warning('interface: ' + self.name +
'type is different in definition: ' +
self.type + ' overwritten here to ' +
self.raw_content[key_name])
self.type = content[key_name]
continue
if key_name == 'inputs':
input_sec = content['inputs']
for input_item in input_sec.keys():
self.inputs[input_item] = PropertyItem(
PropertyDefinition(input_item))
self.inputs[input_item]._assign(input_sec[input_item])
continue
# if self.operations.has_key(key_name):
if key_name in self.operations:
self.operations[key_name]._parse_pre_defined_content(
content[key_name])
else:
self.operations[key_name] = OperationItem(
None, key_name, content[key_name])
def _parse_output(self, db, output_sec):
for output_name in output_sec.keys():
output_def = PropertyDefinition(output_name)
# output_def._parse_content(db)
self.outputs[output_name] = PropertyItem(output_def)
# if output_sec[output_name].has_key('value'):
if 'value' in output_sec[output_name]:
self.outputs[output_name]._assign(
output_sec[output_name]['value'])
def __init__(self, template, node_name, node_type):
self.template = template
self.name = node_name
self.id = PropertyItem(node_type.id)
self_id_str = {}
self_id_str['get_attribute'] = [node_name, 'id']
self.id._assign(self_id_str)
self.mapping_template = None
self.tran_template = None
self.fe_json = None
self.fe_nid = None
if node_type is None:
logging.warning('Empty node type')
return
elif isinstance(node_type, NodeType) is False:
logging.warning('Invalid NodeType passed to Node: ' + node_name +
'construction')
return
else:
self._instatiateWithType(node_type)
def _parse_pre_defined_content(self, content):
if content is None:
return
if type(content) is not dict:
self.implementation = content
return
for key_name in content.keys():
if key_name == 'implementation':
self.implementation = content[key_name]
if key_name == 'inputs':
input_sec = content['inputs']
for input_item in input_sec.keys():
self.inputs[input_item] = PropertyItem(PropertyDefinition(input_item))
self.inputs[input_item]._assign(input_sec[input_item])
def _auto_generate_aux_inputs(self):
for node_name in self.node_dict.keys():
node = self.node_dict[node_name]
for prop_name in node.properties.keys():
prop_item = node.properties[prop_name]
if prop_item.value is None or prop_item.filled is False:
new_input_name = node_name + '_' + prop_name
# while self.inputs.has_key(new_input_name) or self.aux_inputs.has_key(new_input_name):
while new_input_name in self.inputs or new_input_name in self.aux_inputs:
new_input_name = new_input_name + '_'
def_item = copy.deepcopy(prop_item.definition)
def_item.name = new_input_name
self.aux_inputs[new_input_name] = PropertyItem(def_item)
fun_item = {}
fun_item['get_input'] = new_input_name
prop_item._assign(fun_item)
prop_item.value._update_function_reference(self)
def __init__(self, definition, name = None, content = None):
if definition is not None:
self.name = definition.name
self.implementation = definition.implementation
self.definition = definition
self.inputs = {}
self.parent_node = None
for prop in definition.inputs.keys():
self.inputs[prop] = PropertyItem(definition.inputs[prop])
else:
self.name = name
self.implementation = None
self.definition = None
self.inputs = {}
self.parent_node = None
if content is not None:
self._parse_pre_defined_content(content)
def __init__(self, definition, name=None, content=None):
if definition is not None:
self.name = definition.name
self.type = definition.type
self.definition = definition
self.inputs = {}
self.operations = {}
self.parent_node = None
for prop in definition.inputs.keys():
self.inputs[prop] = PropertyItem(definition.inputs[prop])
for oper in definition.operations.keys():
self.operations[oper] = OperationItem(
definition.operations[oper])
else:
self.name = name
self.type = None
self.definition = None
self.inputs = {}
self.operations = {}
self.parent_node = None
self._parse_pre_defined_content(content)
class CapabilityItem(object):
def __init__(self, definition):
self.name = definition.name
self.type = definition.type
self.definition = definition
self.properties = {}
self.id = PropertyItem(definition.id)
self.sub_pointer = None
self.parent_node = None
for prop in definition.properties.keys():
self.properties[prop] = PropertyItem(definition.properties[prop])
def _parse_pre_defined_content(self, content):
if content is None:
return
# if content.has_key(CAP_PROPERTIES):
if CAP_PROPERTIES in content:
prop_sec = content[CAP_PROPERTIES]
for prop_name in prop_sec.keys():
prop_item = self._get_property_item(prop_name)
if prop_item is not None:
prop_item._assign(prop_sec[prop_name])
def _propagate_substitution_value(self):
converge = True
for prop_item in iter(self.properties.values()):
converge = converge and prop_item._propagate_substitution_value()
if self.sub_pointer is None:
return converge
if self.id.value is None:
old_val = None
else:
old_val = self.id.value._get_value()[0]
if isinstance(self.sub_pointer, PropertyItem):
if self.sub_pointer.value is None:
logging.warning(
'Something is wrong, the cap id mapping target' +
self.sub_pointer.name + ' should have a value!')
return converge
self.id._direct_assign(self.sub_pointer.value)
from toscalib.templates.node import Node
if isinstance(self.sub_pointer, Node):
if self.sub_pointer.id is None or self.sub_pointer.id.value is None:
logging.warning(
'Something is wrong, the cap id mapping target' +
self.sub_pointer.name + ' should have a value!')
return converge
self.id._direct_assign(self.sub_pointer.id.value)
if self.id.value is None:
new_val = None
else:
new_val = self.id.value._get_value()[0]
return converge and (old_val == new_val)
def _get_property_item(self, prop_name):
# if self.properties.has_key(prop_name):
if prop_name in self.properties:
return self.properties[prop_name]
else:
logging.warning('Capability: ' + self.name + ' of type: ' +
self.type + ' has no property: ' + prop_name)
return None
def _validate_capability(self, cap_name):
return self.definition._validate_capability(cap_name)
def _update_parent_node(self, parent):
self.parent_node = parent
for prop in iter(self.properties.values()):
prop._update_parent_node(parent)
class Node(object):
def __init__(self, template, node_name, node_type):
self.template = template
self.name = node_name
self.id = PropertyItem(node_type.id)
self_id_str = {}
self_id_str['get_attribute'] = [node_name, 'id']
self.id._assign(self_id_str)
self.mapping_template = None
self.tran_template = None
self.fe_json = None
self.fe_nid = None
if node_type is None:
logging.warning('Empty node type')
return
elif isinstance(node_type, NodeType) is False:
logging.warning('Invalid NodeType passed to Node: ' + node_name +
'construction')
return
else:
self._instatiateWithType(node_type)
#Instantiate the node type, when substitution mapping is attached, create the new template for it
def _instatiateWithType(self, node_type):
self.type = node_type.name
self.type_obj = node_type
self.properties = {}
for prop in node_type.properties.keys():
self.properties[prop] = PropertyItem(node_type.properties[prop])
self.attributes = {}
for attr in node_type.attributes.keys():
self.attributes[attr] = PropertyItem(node_type.attributes[attr])
self.requirements = []
for req in node_type.requirements:
self.requirements.append(RequirementItem(req))
self.capabilities = {}
for cap in node_type.capabilities.keys():
self.capabilities[cap] = CapabilityItem(
node_type.capabilities[cap])
self.interfaces = {}
for intf in node_type.interfaces.keys():
self.interfaces[intf] = InterfaceItem(node_type.interfaces[intf])
# if node_type.mapping_template is not None:
# from toscalib.templates.topology import ToscaTopology
# self.mapping_template = copy.deepcopy(node_type.mapping_template)
# self.mapping_template._update_prefix(self.name + '_')
# self.mapping_template._verify_substitution(self)
# # for sub_rule in node_type.mapping_template.sub_rules:
# # sub_rule._update_pointer(self, self.mapping_template)
self._update_parent_node()
#used to parse node template structure written in a template
#Assign values if needed
#For requirement fulfillment, add pending mode to check whether the value is a node template or type
def _parse_pre_defined_content(self, content):
# if content.has_key(NOD_PROPERTIES):
if NOD_PROPERTIES in content:
prop_sec = content[NOD_PROPERTIES]
if prop_sec is not None:
for prop_name in prop_sec.keys():
prop_item = self._get_property_item(prop_name)
if prop_item is not None:
prop_item._assign(prop_sec[prop_name])
# if prop_sec[prop_name] == '__GET_NODE_NAME__':
# prop_item._assign(self.name)
# if content.has_key(NOD_REQUIREMENTS):
if NOD_REQUIREMENTS in content:
req_sec = content[NOD_REQUIREMENTS]
if req_sec is not None:
for req in req_sec:
req_item_name, req_item_value = tosca_import._parse_requirement_name_and_value(
req)
#TODO: the same requirement name can only appear once!!
req_item = self._get_requirement_item_first(req_item_name)
if req_item is not None:
req_item._parse_pre_defined_content(req_item_value)
else:
logging.warning('Requirement ' + req_item_name +
'not defined in Node ' + self.name +
' of type ' + self.type)
# if content.has_key(NOD_CAPABILITIES):
if NOD_CAPABILITIES in content:
cap_sec = content[NOD_CAPABILITIES]
if cap_sec is not None:
for cap_name in cap_sec.keys():
cap_item = self._get_capability_item(cap_name)
if cap_item is not None:
cap_item._parse_pre_defined_content(cap_sec[cap_name])
# if content.has_key(NOD_INTERFACES):
if NOD_INTERFACES in content:
interface_sec = content[NOD_INTERFACES]
if interface_sec is not None:
for interface_name in interface_sec.keys():
interface_item = self._get_interface_item(interface_name)
if interface_item is not None:
interface_item._parse_pre_defined_content(
interface_sec[interface_name])
else:
self.interfaces[interface_name] = InterfaceItem(
None, interface_name,
interface_sec[interface_name])
self._update_parent_node()
def _get_property_item(self, prop_name):
# if self.properties.has_key(prop_name):
if prop_name in self.properties:
return self.properties[prop_name]
else:
logging.warning('Node: ' + self.name + ' of type: ' + self.type +
' has no property: ' + prop_name)
return None
def _get_attribute_item(self, attr_name):
# if self.attributes.has_key(attr_name):
if attr_name in self.attributes:
return self.attributes[attr_name]
else:
logging.warning('Node: ' + self.name + ' of type: ' + self.type +
' has no attribute: ' + attr_name)
return None
def _get_interface_item(self, interface_name):
# if self.interfaces.has_key(interface_name):
if interface_name in self.interfaces:
return self.interfaces[interface_name]
else:
logging.warning('Node: ' + self.name + ' of type: ' + self.type +
' has no interface: ' + interface_name)
return None
def _get_capability_item(self, cap_name):
# if self.capabilities.has_key(cap_name):
if cap_name in self.capabilities:
return self.capabilities[cap_name]
else:
#logging.debug('Node: '+ self.name+ ' of type: '+ self.type+ ' has no capability: '+ cap_name)
return None
def _get_capability_property(self, cap_name, prop_name):
cap_item = self._get_capability_item(cap_name)
if cap_item is not None:
return cap_item._get_property_item(prop_name)
else:
#logging.debug( 'Node: '+ self.name+ ' of type: '+ self.type+ ' has no capability: '+ cap_name)
return None
def _get_requirement_item_first(self, req_name):
for req_item in self.requirements:
if req_item.name == req_name:
return req_item
logging.warning('Node: ' + self.name + ' of type: ' + self.type +
' has no requirement: ' + req_name)
return None
def _verify_requirements(self, node_dict):
for req in self.requirements:
req._verify_requirement(node_dict)
def _verify_functions(self, parent_temp=None):
if parent_temp is not None:
temp = parent_temp
else:
temp = self.template
if self.id.value is not None:
self.id.value._update_function_reference(temp, self, self.id)
for prop_item in iter(self.properties.values()):
if prop_item.value is not None:
prop_item.value._update_function_reference(
temp, self, prop_item)
for cap_item in iter(self.capabilities.values()):
for cap_item_prop in iter(cap_item.properties.values()):
if cap_item_prop.value is not None:
cap_item_prop.value._update_function_reference(
temp, self, cap_item_prop)
for interface_item in iter(self.interfaces.values()):
for interface_item_input in iter(interface_item.inputs.values()):
if interface_item_input.value is not None:
interface_item_input.value._update_function_reference(
temp, self, interface_item_input)
for operation_item in iter(interface_item.operations.values()):
for input_item in iter(operation_item.inputs.values()):
if input_item.value is not None:
input_item.value._update_function_reference(
temp, self, input_item)
def _update_parent_node(self):
for prop in iter(self.properties.values()):
prop._update_parent_node(self)
for cap in iter(self.capabilities.values()):
cap._update_parent_node(self)
for req in self.requirements:
req._update_parent_node(self)
for interface in iter(self.interfaces.values()):
interface._update_parent_node(self)
def _update_get_node_name(self):
for prop_item in iter(self.properties.values()):
if prop_item.value is not None:
if prop_item.value.value == '__GET_NODE_NAME__':
prop_item._assign(self.name)
for cap_item in iter(self.capabilities.values()):
for cap_item_prop in iter(cap_item.properties.values()):
if cap_item_prop.value is not None:
if cap_item_prop.value.value == '__GET_NODE_NAME__':
cap_item_prop._assign(self.name)
def _update_template(self, template):
self.template = template
def _update_prefix(self, prefix):
if self.name == 'NO_PREFIX':
self.name = prefix[:len(prefix) - 1]
else:
self.name = prefix + self.name
self.id.value._update_prefix(prefix)
for prop_item in iter(self.properties.values()):
if prop_item.value is not None:
prop_item.value._update_prefix(prefix)
for cap_item in iter(self.capabilities.values()):
for cap_item_prop in iter(cap_item.properties.values()):
if cap_item_prop.value is not None:
cap_item_prop.value._update_prefix(prefix)
for interface_item in iter(self.interfaces.values()):
for interface_item_input in iter(interface_item.inputs.values()):
if interface_item_input.value is not None:
interface_item_input.value._update_prefix(prefix)
for operation_item in iter(interface_item.operations.values()):
for input_item in iter(operation_item.inputs.values()):
if input_item.value is not None:
input_item.value._update_prefix(prefix)
for req in self.requirements:
req._update_prefix(prefix)
self._update_parent_node()
def _verify_req_node(self, req_type, req_cap, req_filter):
if req_type is not None and self.type_obj._verify_req_type(
req_type) is False:
logging.warning('Type matching failed')
return False
if req_cap is not None:
cap_found = None
for cap_item in iter(self.capabilities.values()):
if cap_item._validate_capability(req_cap) is True:
cap_found = cap_item
break
if cap_found is None:
logging.warning('Capability matching failed')
return False
return self._verify_node_filter(req_filter)
def _verify_node_filter(self, req_filter):
return True
def _propagate_substitution_value(self):
converge = True
for prop_item in iter(self.properties.values()):
converge = converge and prop_item._propagate_substitution_value()
for req_item in self.requirements:
converge = converge and req_item._propagate_substitution_value()
for cap_item in iter(self.capabilities.values()):
converge = converge and cap_item._propagate_substitution_value()
for attr_item in iter(self.attributes.values()):
converge = converge and attr_item._propagate_attr_substitution_value(
)
if self.mapping_template is not None:
self.mapping_template._propagate_substitution_value()
if self.tran_template is not None:
self.tran_template._propagate_substitution_value()
return converge
def _prepare_extra_imports(self, tags=''):
if 'noexpand' in tags:
return []
if self.tran_template is not None:
return self.tran_template._prepare_extra_imports(tags)
if self.mapping_template is not None:
return self.mapping_template._prepare_extra_imports(tags)
return []
def _prepare_output(self, tags=''):
if 'noexpand' not in tags:
newtags = tags.replace('main', 'part')
if self.tran_template is not None:
return self.tran_template._prepare_output(newtags)
if self.mapping_template is not None:
return self.mapping_template._prepare_output(newtags)
output = {}
if 'heat' in tags:
heat_type = re.sub('tosca.heat.', '', self.type)
heat_type = re.sub('\.', '::', heat_type)
output[YMO_NOD_TYPE] = heat_type
else:
output[YMO_NOD_TYPE] = self.type
prop_out = {}
for prop in self.properties.keys():
prop_item = self.properties[prop]
# if prop_item.required is False and prop_item.used is not True and prop_item.filled is not True:
if prop_item.required is False and prop_item.filled is not True:
continue
if prop_item.filled is not True or prop_item.value is None:
prop_value = None
else:
prop_value = prop_item.value._get_value(tags)[0]
if prop_item.required is False and prop_value in [None, [], {}]:
continue
else:
prop_out[prop] = prop_value
cap_out = {}
for cap in iter(self.capabilities.values()):
cap_item = {}
for cap_prop in iter(cap.properties.values()):
if cap_prop.filled is True:
cap_item[cap_prop.name] = cap_prop.value._get_value(
tags)[0]
if len(cap_item) > 0:
cap_out[cap.name] = {'properties': cap_item}
req_out = []
for req in self.requirements:
if req.filled is True:
req_item = dict()
if 'cloudify' in tags:
if req.relationship is not None:
req_item['type'] = req.relationship
else:
req_item[
'type'] = 'cloudify.relationships.connected_to'
req_item['target'] = req.str_value
else:
req_item[req.name] = req.str_value
req_out.append(req_item)
elif req.filter is not None and 'cloudify' not in tags:
req_item = {}
if req.req_capability is not None:
req_item[YMO_REQ_CAPABILITY] = req.req_capability
if req.req_type is not None:
req_item[YMO_REQ_NODE] = req.req_type
if req.relationship is not None:
req_item[YMO_REQ_RELATIONSHIP] = req.relationship
req_item[YMO_REQ_FILTER] = req.filter
req_out.append({req.name: req_item})
int_out = {}
for interface_name in self.interfaces.keys():
int_out[interface_name] = self.interfaces[
interface_name]._prepare_output(tags)
if len(prop_out) > 0:
output[YMO_NOD_PROPERTIES] = prop_out
if len(req_out) > 0 and 'java_sim' not in tags:
if 'cloudify' in tags:
output[YMO_NOD_RELATIONSHIPS] = req_out
else:
output[YMO_NOD_REQUIREMENTS] = req_out
if len(cap_out) > 0 and 'cloudify' not in tags:
output[YMO_NOD_CAPABILITIES] = cap_out
if len(int_out) > 0:
output[YMO_NOD_INTERFACES] = int_out
final_out = {}
final_out[self.name] = output
return final_out
def _prepare_heat_output(self, parameters_type, parameters_val):
if self.mapping_template is not None:
return self.mapping_template._prepare_heat_output(
parameters_type, parameters_val, True)
else:
if tosca_heat._type_validate(self.type) is not True:
return None
output = {}
output[YMO_NOD_TYPE] = tosca_heat._type_translate(self.type)
prop_out = {}
for prop_item in iter(self.properties.values()):
if prop_item.filled:
prop_out[prop_item.name] = prop_item.value
else:
input_name = self.name + '_' + prop_item.name
prop_out[
prop_item.name] = '{ get_param: ' + input_name + ' }'
input_type = {}
input_type[input_name] = prop_item.type
input_val = {}
input_val[input_name] = prop_item.value
parameters_type.update(input_type)
parameters_val.udpate(input_val)
if len(prop_out) > 0:
output[YMO_NOD_PROPERTIES] = prop_out
final_out = {}
final_out[self.name] = output
return final_out
def toJson(self):
return self.fe_json
def _parse_input(self, db, input_sec):
for input_name in input_sec.keys():
input_def = PropertyDefinition(input_name, input_sec[input_name])
input_def._parse_content(db)
self.inputs[input_name] = PropertyItem(input_def)