diff options
Diffstat (limited to 'jtosca/src/main/java/org/openecomp/sdc/toscaparser/TopologyTemplate.java')
-rw-r--r-- | jtosca/src/main/java/org/openecomp/sdc/toscaparser/TopologyTemplate.java | 882 |
1 files changed, 882 insertions, 0 deletions
diff --git a/jtosca/src/main/java/org/openecomp/sdc/toscaparser/TopologyTemplate.java b/jtosca/src/main/java/org/openecomp/sdc/toscaparser/TopologyTemplate.java new file mode 100644 index 0000000..0726e49 --- /dev/null +++ b/jtosca/src/main/java/org/openecomp/sdc/toscaparser/TopologyTemplate.java @@ -0,0 +1,882 @@ +package org.openecomp.sdc.toscaparser; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.openecomp.sdc.toscaparser.common.ExceptionCollector; +import org.openecomp.sdc.toscaparser.elements.InterfacesDef; +import org.openecomp.sdc.toscaparser.elements.Metadata; +import org.openecomp.sdc.toscaparser.elements.NodeType; +import org.openecomp.sdc.toscaparser.elements.RelationshipType; +import org.openecomp.sdc.toscaparser.SubstitutionMappings; +import org.openecomp.sdc.toscaparser.ToscaGraph; +import org.openecomp.sdc.toscaparser.parameters.Input; +import org.openecomp.sdc.toscaparser.parameters.Output; +import org.openecomp.sdc.toscaparser.functions.Function; +import org.openecomp.sdc.toscaparser.functions.GetAttribute; +import org.openecomp.sdc.toscaparser.functions.GetInput; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class TopologyTemplate { + + private static Logger log = LoggerFactory.getLogger(TopologyTemplate.class.getName()); + private static final String DESCRIPTION = "description"; + private static final String INPUTS = "inputs"; + private static final String NODE_TEMPLATES = "node_templates"; + private static final String RELATIONSHIP_TEMPLATES = "relationship_templates"; + private static final String OUTPUTS = "outputs"; + private static final String GROUPS = "groups"; + private static final String SUBSTITUTION_MAPPINGS = "substitution_mappings"; + private static final String POLICIES = "policies"; + private static final String METADATA = "metadata"; + + private static String SECTIONS[] = { + DESCRIPTION, INPUTS, NODE_TEMPLATES, RELATIONSHIP_TEMPLATES, + OUTPUTS, GROUPS, SUBSTITUTION_MAPPINGS, POLICIES, METADATA + }; + + private LinkedHashMap<String,Object> tpl; + Metadata metaData; + private ArrayList<Input> inputs; + private ArrayList<Output> outputs; + private ArrayList<RelationshipTemplate> relationshipTemplates; + private ArrayList<NodeTemplate> nodeTemplates; + private LinkedHashMap<String,Object> customDefs; + private LinkedHashMap<String,Object> relTypes;//TYPE + private NodeTemplate subMappedNodeTemplate; + private ArrayList<Group> groups; + private ArrayList<Policy> policies; + private LinkedHashMap<String,Object> parsedParams = null;//TYPE + private String description; + private ToscaGraph graph; + private SubstitutionMappings substitutionMappings; + + public TopologyTemplate( + LinkedHashMap<String,Object> _template, + LinkedHashMap<String,Object> _customDefs, + LinkedHashMap<String,Object> _relTypes,//TYPE + LinkedHashMap<String, Object> _parsedParams, + NodeTemplate _subMappedNodeTemplate) { + + tpl = _template; + if(tpl != null) { + subMappedNodeTemplate = _subMappedNodeTemplate; + metaData = _metaData(); + customDefs = _customDefs; + relTypes = _relTypes; + parsedParams = _parsedParams; + _validateField(); + description = _tplDescription(); + inputs = _inputs(); + relationshipTemplates =_relationshipTemplates(); + nodeTemplates = _nodeTemplates(); + outputs = _outputs(); + if(nodeTemplates != null) { + graph = new ToscaGraph(nodeTemplates); + } + groups = _groups(); + policies = _policies(); + _processIntrinsicFunctions(); + substitutionMappings = _substitutionMappings(); + } + } + + @SuppressWarnings("unchecked") + private ArrayList<Input> _inputs() { + ArrayList<Input> alInputs = new ArrayList<>(); + for(String name: _tplInputs().keySet()) { + Object attrs = _tplInputs().get(name); + Input input = new Input(name,(LinkedHashMap<String,Object>)attrs); + if(parsedParams != null && parsedParams.get(name) != null) { + input.validate(parsedParams.get(name)); + } + else { + Object _default = input.getDefault(); + if(_default != null) { + input.validate(_default); + } + } + if((parsedParams != null && parsedParams.get(input.getName()) == null || parsedParams == null) + && input.isRequired() && input.getDefault() == null) { + log.error("Log warning: TopologyTemplate - _inputs - The required parameter {} is not provided", input.getName()); + } + alInputs.add(input); + } + return alInputs; + + } + + private Metadata _metaData() { + if(tpl.get(METADATA) != null) { + return (Metadata)tpl.get(METADATA); + } + else { + return new Metadata(new LinkedHashMap<>()); + } + + } + + private ArrayList<NodeTemplate> _nodeTemplates() { + ArrayList<NodeTemplate> alNodeTemplates = new ArrayList<>(); + LinkedHashMap<String,Object> tpls = _tplNodeTemplates(); + if(tpls != null) { + for(String name: tpls.keySet()) { + NodeTemplate tpl = new NodeTemplate(name, + tpls, + customDefs, + relationshipTemplates, + relTypes); + if(tpl.getTypeDefinition() != null) { + boolean b = NodeType.TOSCA_DEF.get(tpl.getType()) != null; + if(b || (tpl.getCustomDef() != null && !tpl.getCustomDef().isEmpty())) { + tpl.validate(); + alNodeTemplates.add(tpl); + } + } + } + } + return alNodeTemplates; + } + + @SuppressWarnings("unchecked") + private ArrayList<RelationshipTemplate> _relationshipTemplates() { + ArrayList<RelationshipTemplate> alRelationshipTemplates = new ArrayList<>(); + LinkedHashMap<String,Object> tpls = _tplRelationshipTemplates(); + if(tpls != null) { + for(String name: tpls.keySet()) { + RelationshipTemplate tpl = new RelationshipTemplate( + (LinkedHashMap<String,Object>)tpls.get(name),name,customDefs,null,null); + + alRelationshipTemplates.add(tpl); + } + } + return alRelationshipTemplates; + } + + private ArrayList<Output> _outputs() { + ArrayList<Output> alOutputs = new ArrayList<>(); + for(Map.Entry<String,Object> me: _tplOutputs().entrySet()) { + String oname = me.getKey(); + LinkedHashMap<String,Object> oattrs = (LinkedHashMap<String,Object>)me.getValue(); + Output o = new Output(oname,oattrs); + o.validate(); + alOutputs.add(o); + } + return alOutputs; + } + + private SubstitutionMappings _substitutionMappings() { + LinkedHashMap<String,Object> tplSubstitutionMapping = (LinkedHashMap<String,Object>) _tplSubstitutionMappings(); + + //*** the commenting-out below and the weaker condition are in the Python source + // #if tpl_substitution_mapping and self.sub_mapped_node_template: + if(tplSubstitutionMapping != null && tplSubstitutionMapping.size() > 0) { + return new SubstitutionMappings(tplSubstitutionMapping, + nodeTemplates, + inputs, + outputs, + groups, + subMappedNodeTemplate, + customDefs); + } + return null; + + } + + @SuppressWarnings("unchecked") + private ArrayList<Policy> _policies() { + ArrayList<Policy> alPolicies = new ArrayList<>(); + for(Object po: _tplPolicies()) { + LinkedHashMap<String,Object> policy = (LinkedHashMap<String,Object>)po; + for(Map.Entry<String,Object> me: policy.entrySet()) { + String policyName = me.getKey(); + LinkedHashMap<String,Object> policyTpl = (LinkedHashMap<String,Object>)me.getValue(); + ArrayList<String> targetList = (ArrayList<String>)policyTpl.get("targets"); + //ArrayList<Object> targetObjects = new ArrayList<>(); + ArrayList<NodeTemplate> targetNodes = new ArrayList<>(); + ArrayList<Object> targetObjects = new ArrayList<>(); + ArrayList<Group> targetGroups = new ArrayList<>(); + String targetsType = "groups"; + if(targetList != null && targetList.size() >= 1) { + targetGroups = _getPolicyGroups(targetList); + if(targetGroups == null) { + targetsType = "node_templates"; + targetNodes = _getGroupMembers(targetList); + for(NodeTemplate nt: targetNodes) { + targetObjects.add(nt); + } + } + else { + for(Group gr: targetGroups) { + targetObjects.add(gr); + } + } + } + Policy policyObj = new Policy(policyName, + policyTpl, + targetObjects, + targetsType, + customDefs); + alPolicies.add(policyObj); + } + } + return alPolicies; + } + + private ArrayList<Group> _groups() { + ArrayList<Group> groups = new ArrayList<>(); + ArrayList<NodeTemplate> memberNodes = null; + for(Map.Entry<String,Object> me: _tplGroups().entrySet()) { + String groupName = me.getKey(); + LinkedHashMap<String,Object> groupTpl = (LinkedHashMap<String,Object>)me.getValue(); + ArrayList<String> memberNames = (ArrayList<String>)groupTpl.get("members"); + if(memberNames != null) { + DataEntity.validateDatatype("list", memberNames,null,null,null); + if(memberNames.size() < 1 || + (new HashSet<String>(memberNames)).size() != memberNames.size()) { + ExceptionCollector.appendException(String.format( + "InvalidGroupTargetException: Member nodes \"%s\" should be >= 1 and not repeated", + memberNames.toString())); + } + else { + memberNodes = _getGroupMembers(memberNames); + } + } + Group group = new Group(groupName, + groupTpl, + memberNodes, + customDefs); + groups.add(group); + } + return groups; + } + + private ArrayList<NodeTemplate> _getGroupMembers(ArrayList<String> memberNames) { + ArrayList<NodeTemplate> memberNodes = new ArrayList<>(); + _validateGroupMembers(memberNames); + for(String member: memberNames) { + for(NodeTemplate node: nodeTemplates) { + if(member.equals(node.getName())) { + memberNodes.add(node); + } + } + } + return memberNodes; + } + + private ArrayList<Group> _getPolicyGroups(ArrayList<String> memberNames) { + ArrayList<Group> memberGroups = new ArrayList<>(); + for(String member: memberNames) { + for(Group group: groups) { + if(member.equals(group.getName())) { + memberGroups.add(group); + } + } + } + return memberGroups; + } + + private void _validateGroupMembers(ArrayList<String> members) { + ArrayList<String> nodeNames = new ArrayList<>(); + for(NodeTemplate node: nodeTemplates) { + nodeNames.add(node.getName()); + } + for(String member: members) { + if(!nodeNames.contains(member)) { + ExceptionCollector.appendException(String.format( + "InvalidGroupTargetException: Target member \"%s\" is not found in \"nodeTemplates\"",member)); + } + } + } + + // topology template can act like node template + // it is exposed by substitution_mappings. + + public String nodetype() { + return substitutionMappings.getNodeType(); + } + + public LinkedHashMap<String,Object> capabilities() { + return substitutionMappings.getCapabilities(); + } + + public LinkedHashMap<String,Object> requirements() { + return substitutionMappings.getRequirements(); + } + + private String _tplDescription() { + return (String)tpl.get(DESCRIPTION); + //if description: + // return description.rstrip() + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplInputs() { + if(tpl.get(INPUTS) != null) { + return (LinkedHashMap<String,Object>)tpl.get(INPUTS); + } + else { + return new LinkedHashMap<String,Object>(); + } + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplNodeTemplates() { + return (LinkedHashMap<String,Object>)tpl.get(NODE_TEMPLATES); + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplRelationshipTemplates() { + if(tpl.get(RELATIONSHIP_TEMPLATES) != null) { + return (LinkedHashMap<String,Object>)tpl.get(RELATIONSHIP_TEMPLATES); + } + else { + return new LinkedHashMap<String,Object>(); + } + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplOutputs() { + if(tpl.get(OUTPUTS) != null) { + return (LinkedHashMap<String,Object>)tpl.get(OUTPUTS); + } + else { + return new LinkedHashMap<String,Object>(); + } + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplSubstitutionMappings() { + if(tpl.get(SUBSTITUTION_MAPPINGS) != null) { + return (LinkedHashMap<String,Object>)tpl.get(SUBSTITUTION_MAPPINGS); + } + else { + return new LinkedHashMap<String,Object>(); + } + } + + @SuppressWarnings("unchecked") + private LinkedHashMap<String,Object> _tplGroups() { + if(tpl.get(GROUPS) != null) { + return (LinkedHashMap<String,Object>)tpl.get(GROUPS); + } + else { + return new LinkedHashMap<String,Object>(); + } + } + + @SuppressWarnings("unchecked") + private ArrayList<Object> _tplPolicies() { + if(tpl.get(POLICIES) != null) { + return (ArrayList<Object>)tpl.get(POLICIES); + } + else { + return new ArrayList<Object>(); + } + } + + private void _validateField() { + for(String name: tpl.keySet()) { + boolean bFound = false; + for(String section: SECTIONS) { + if(name.equals(section)) { + bFound = true; + break; + } + } + if(!bFound) { + ExceptionCollector.appendException(String.format( + "UnknownFieldError: TopologyTemplate contains unknown field \"%s\"",name)); + } + } + } + + @SuppressWarnings("unchecked") + private void _processIntrinsicFunctions() { + // Process intrinsic functions + + // Current implementation processes functions within node template + // properties, requirements, interfaces inputs and template outputs. + + if(nodeTemplates != null) { + for(NodeTemplate nt: nodeTemplates) { + for(Property prop: nt.getPropertiesObjects()) { + prop.setValue(Function.getFunction(this,nt,prop.getValue())); + } + for(InterfacesDef ifd: nt.getInterfaces()) { + LinkedHashMap<String,Object> ifin = ifd.getInputs(); + if(ifin != null) { + for(Map.Entry<String,Object> me: ifin.entrySet()) { + String name = me.getKey(); + Object value = Function.getFunction(this,nt,me.getValue()); + ifd.setInput(name,value); + } + } + } + if(nt.getRequirements() != null && + nt.getRequirements() instanceof ArrayList) { + for(Object oreq: nt.getRequirements()) { + LinkedHashMap<String,Object> req = (LinkedHashMap<String,Object>)oreq; + LinkedHashMap<String,Object> rel = req; + for(String reqName: req.keySet()) { + Object reqItem = req.get(reqName); + if(reqItem instanceof LinkedHashMap) { + Object t = ((LinkedHashMap<String,Object>)reqItem).get("relationship"); + // it can be a string or a LHM... + if(t instanceof LinkedHashMap) { + rel = (LinkedHashMap<String,Object>)t; + } + else { + // we set it to null to fail the next test + // and avoid the get("proprties") + rel = null; + } + break; + } + } + if(rel != null && rel.get("properties") != null) { + LinkedHashMap<String,Object> relprops = + (LinkedHashMap<String,Object>)rel.get("properties"); + for(String key: relprops.keySet()) { + Object value = relprops.get(key); + Object func = Function.getFunction(this,req,value); + relprops.put(key,func); + } + } + } + } + if(nt.getCapabilitiesObjects() != null) { + for(Capability cap: nt.getCapabilitiesObjects()) { + if(cap.getPropertiesObjects() != null) { + for(Property prop: cap.getPropertiesObjects()) { + Object propvalue = Function.getFunction(this,nt,prop.getValue()); + if(propvalue instanceof GetInput) { + propvalue = ((GetInput)propvalue).result(); + for(String p: cap.getProperties().keySet()) { + //Object v = cap.getProperties().get(p); + if(p.equals(prop.getName())) { + cap.setProperty(p,propvalue); + } + } + } + } + } + } + } + for(RelationshipType rel: nt.getRelationships().keySet()) { + NodeTemplate node = nt.getRelationships().get(rel); + ArrayList<RelationshipTemplate> relTpls = node.getRelationshipTemplate(); + if(relTpls != null) { + for(RelationshipTemplate relTpl: relTpls) { + // TT 5 + for(InterfacesDef iface: relTpl.getInterfaces()) { + if(iface.getInputs() != null) { + for(String name: iface.getInputs().keySet()) { + Object value = iface.getInputs().get(name); + Object func = Function.getFunction( + this, + relTpl, + value); + iface.setInput(name,func); + } + } + } + } + } + } + } + } + for(Output output: outputs) { + Object func = Function.getFunction(this,outputs,output.getValue()); + if(func instanceof GetAttribute) { + output.setAttr(Output.VALUE,func); + } + } + } + + public static String getSubMappingNodeType(LinkedHashMap<String,Object> topologyTpl) { + if(topologyTpl != null && topologyTpl instanceof LinkedHashMap) { + Object submapTpl = topologyTpl.get(SUBSTITUTION_MAPPINGS); + return SubstitutionMappings.stGetNodeType((LinkedHashMap<String,Object>)submapTpl); + } + return null; + } + + // getters + + public LinkedHashMap<String,Object> getTpl() { + return tpl; + } + + public Metadata getMetadata() { + return metaData; + } + + public ArrayList<Input> getInputs() { + return inputs; + } + + public ArrayList<Output> getOutputs() { + return outputs; + } + + public ArrayList<Policy> getPolicies() { + return policies; + } + + public ArrayList<RelationshipTemplate> getRelationshipTemplates() { + return relationshipTemplates; + } + + public ArrayList<NodeTemplate> getNodeTemplates() { + return nodeTemplates; + } + + public ArrayList<Group> getGroups() { + return groups; + } + + public SubstitutionMappings getSubstitutionMappings() { + return substitutionMappings; + } + + public LinkedHashMap<String,Object> getParsedParams() { + return parsedParams; + } + + @Override + public String toString() { + return "TopologyTemplate{" + + "tpl=" + tpl + + ", metaData=" + metaData + + ", inputs=" + inputs + + ", outputs=" + outputs + + ", relationshipTemplates=" + relationshipTemplates + + ", nodeTemplates=" + nodeTemplates + + ", customDefs=" + customDefs + + ", relTypes=" + relTypes + + ", subMappedNodeTemplate=" + subMappedNodeTemplate + + ", groups=" + groups + + ", policies=" + policies + + ", parsedParams=" + parsedParams + + ", description='" + description + '\'' + + ", graph=" + graph + + ", substitutionMappings=" + substitutionMappings + + '}'; + } +} + +/*python + +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + + +import logging + +from toscaparser.common import exception +from toscaparser.dataentity import DataEntity +from toscaparser import functions +from toscaparser.groups import Group +from toscaparser.nodetemplate import NodeTemplate +from toscaparser.parameters import Input +from toscaparser.parameters import Output +from toscaparser.policy import Policy +from toscaparser.relationship_template import RelationshipTemplate +from toscaparser.substitution_mappings import SubstitutionMappings +from toscaparser.tpl_relationship_graph import ToscaGraph +from toscaparser.utils.gettextutils import _ + + +# Topology template key names +SECTIONS = (DESCRIPTION, INPUTS, NODE_TEMPLATES, + RELATIONSHIP_TEMPLATES, OUTPUTS, GROUPS, + SUBSTITUION_MAPPINGS, POLICIES) = \ + ('description', 'inputs', 'node_templates', + 'relationship_templates', 'outputs', 'groups', + 'substitution_mappings', 'policies') + +log = logging.getLogger("tosca.model") + + +class TopologyTemplate(object): + + '''Load the template data.''' + def __init__(self, template, custom_defs, + rel_types=None, parsed_params=None, + sub_mapped_node_template=None): + self.tpl = template + self.sub_mapped_node_template = sub_mapped_node_template + if self.tpl: + self.custom_defs = custom_defs + self.rel_types = rel_types + self.parsed_params = parsed_params + self._validate_field() + self.description = self._tpl_description() + self.inputs = self._inputs() + self.relationship_templates = self._relationship_templates() + self.nodetemplates = self._nodetemplates() + self.outputs = self._outputs() + if hasattr(self, 'nodetemplates'): + self.graph = ToscaGraph(self.nodetemplates) + self.groups = self._groups() + self.policies = self._policies() + self._process_intrinsic_functions() + self.substitution_mappings = self._substitution_mappings() + + def _inputs(self): + inputs = [] + for name, attrs in self._tpl_inputs().items(): + input = Input(name, attrs) + if self.parsed_params and name in self.parsed_params: + input.validate(self.parsed_params[name]) + else: + default = input.default + if default: + input.validate(default) + if (self.parsed_params and input.name not in self.parsed_params + or self.parsed_params is None) and input.required \ + and input.default is None: + log.warning(_('The required parameter %s ' + 'is not provided') % input.name) + + inputs.append(input) + return inputs + + def _nodetemplates(self): + nodetemplates = [] + tpls = self._tpl_nodetemplates() + if tpls: + for name in tpls: + tpl = NodeTemplate(name, tpls, self.custom_defs, + self.relationship_templates, + self.rel_types) + if (tpl.type_definition and + (tpl.type in tpl.type_definition.TOSCA_DEF or + (tpl.type not in tpl.type_definition.TOSCA_DEF and + bool(tpl.custom_def)))): + tpl.validate(self) + nodetemplates.append(tpl) + return nodetemplates + + 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 _outputs(self): + outputs = [] + for name, attrs in self._tpl_outputs().items(): + output = Output(name, attrs) + output.validate() + outputs.append(output) + return outputs + + def _substitution_mappings(self): + tpl_substitution_mapping = self._tpl_substitution_mappings() + # if tpl_substitution_mapping and self.sub_mapped_node_template: + if tpl_substitution_mapping: + return SubstitutionMappings(tpl_substitution_mapping, + self.nodetemplates, + self.inputs, + self.outputs, + self.sub_mapped_node_template, + self.custom_defs) + + def _policies(self): + policies = [] + for policy in self._tpl_policies(): + for policy_name, policy_tpl in policy.items(): + target_list = policy_tpl.get('targets') + if target_list and len(target_list) >= 1: + target_objects = [] + targets_type = "groups" + target_objects = self._get_policy_groups(target_list) + if not target_objects: + targets_type = "node_templates" + target_objects = self._get_group_members(target_list) + policyObj = Policy(policy_name, policy_tpl, + target_objects, targets_type, + self.custom_defs) + policies.append(policyObj) + return policies + + def _groups(self): + groups = [] + member_nodes = None + for group_name, group_tpl in self._tpl_groups().items(): + member_names = group_tpl.get('members') + if member_names is not None: + DataEntity.validate_datatype('list', member_names) + if len(member_names) < 1 or \ + len(member_names) != len(set(member_names)): + exception.ExceptionCollector.appendException( + exception.InvalidGroupTargetException( + message=_('Member nodes "%s" should be >= 1 ' + 'and not repeated') % member_names)) + else: + member_nodes = self._get_group_members(member_names) + group = Group(group_name, group_tpl, + member_nodes, + self.custom_defs) + groups.append(group) + return groups + + def _get_group_members(self, member_names): + member_nodes = [] + self._validate_group_members(member_names) + for member in member_names: + for node in self.nodetemplates: + if node.name == member: + member_nodes.append(node) + return member_nodes + + def _get_policy_groups(self, member_names): + member_groups = [] + for member in member_names: + for group in self.groups: + if group.name == member: + member_groups.append(group) + return member_groups + + def _validate_group_members(self, members): + node_names = [] + for node in self.nodetemplates: + node_names.append(node.name) + for member in members: + if member not in node_names: + exception.ExceptionCollector.appendException( + exception.InvalidGroupTargetException( + message=_('Target member "%s" is not found in ' + 'node_templates') % member)) + + # topology template can act like node template + # it is exposed by substitution_mappings. + def nodetype(self): + return self.substitution_mappings.node_type \ + if self.substitution_mappings else None + + def capabilities(self): + return self.substitution_mappings.capabilities \ + if self.substitution_mappings else None + + def requirements(self): + return self.substitution_mappings.requirements \ + if self.substitution_mappings else None + + def _tpl_description(self): + description = self.tpl.get(DESCRIPTION) + if description: + return description.rstrip() + + def _tpl_inputs(self): + return self.tpl.get(INPUTS) or {} + + def _tpl_nodetemplates(self): + return self.tpl.get(NODE_TEMPLATES) + + def _tpl_relationship_templates(self): + return self.tpl.get(RELATIONSHIP_TEMPLATES) or {} + + def _tpl_outputs(self): + return self.tpl.get(OUTPUTS) or {} + + def _tpl_substitution_mappings(self): + return self.tpl.get(SUBSTITUION_MAPPINGS) or {} + + def _tpl_groups(self): + return self.tpl.get(GROUPS) or {} + + def _tpl_policies(self): + return self.tpl.get(POLICIES) or {} + + def _validate_field(self): + for name in self.tpl: + if name not in SECTIONS: + exception.ExceptionCollector.appendException( + exception.UnknownFieldError(what='Template', field=name)) + + def _process_intrinsic_functions(self): + """Process intrinsic functions + + Current implementation processes functions within node template + properties, requirements, interfaces inputs and template outputs. + """ + if hasattr(self, 'nodetemplates'): + for node_template in self.nodetemplates: + for prop in node_template.get_properties_objects(): + prop.value = functions.get_function(self, + node_template, + prop.value) + for interface in node_template.interfaces: + if interface.inputs: + for name, value in interface.inputs.items(): + interface.inputs[name] = functions.get_function( + self, + node_template, + value) + if node_template.requirements and \ + isinstance(node_template.requirements, list): + for req in node_template.requirements: + rel = req + for req_name, req_item in req.items(): + if isinstance(req_item, dict): + rel = req_item.get('relationship') + break + if rel and 'properties' in rel: + for key, value in rel['properties'].items(): + rel['properties'][key] = \ + functions.get_function(self, + req, + value) + if node_template.get_capabilities_objects(): + for cap in node_template.get_capabilities_objects(): + if cap.get_properties_objects(): + for prop in cap.get_properties_objects(): + propvalue = functions.get_function( + self, + node_template, + prop.value) + if isinstance(propvalue, functions.GetInput): + propvalue = propvalue.result() + for p, v in cap._properties.items(): + if p == prop.name: + cap._properties[p] = propvalue + for rel, node in node_template.relationships.items(): + rel_tpls = node.relationship_tpl + if rel_tpls: + for rel_tpl in rel_tpls: + for interface in rel_tpl.interfaces: + if interface.inputs: + for name, value in \ + interface.inputs.items(): + interface.inputs[name] = \ + functions.get_function(self, + rel_tpl, + value) + for output in self.outputs: + func = functions.get_function(self, self.outputs, output.value) + if isinstance(func, functions.GetAttribute): + output.attrs[output.VALUE] = func + + @classmethod + def get_sub_mapping_node_type(cls, topology_tpl): + if topology_tpl and isinstance(topology_tpl, dict): + submap_tpl = topology_tpl.get(SUBSTITUION_MAPPINGS) + return SubstitutionMappings.get_node_type(submap_tpl) +*/
\ No newline at end of file |