+++ /dev/null
-package org.openecomp.sdc.toscaparser.api;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-
-import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
-import org.openecomp.sdc.toscaparser.api.elements.*;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Constraint;
-import org.openecomp.sdc.toscaparser.api.elements.constraints.Schema;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
-import org.openecomp.sdc.toscaparser.api.utils.TOSCAVersionProperty;
-import org.openecomp.sdc.toscaparser.api.utils.ValidateUtils;
-
-public class DataEntity {
- // A complex data value entity
-
- private LinkedHashMap<String,Object> customDef;
- private DataType dataType;
- private LinkedHashMap<String,PropertyDef> schema;
- private Object value;
- private String propertyName;
-
- public DataEntity(String _dataTypeName,Object _valueDict,
- LinkedHashMap<String,Object> _customDef,String _propName) {
-
- customDef = _customDef;
- dataType = new DataType(_dataTypeName,_customDef);
- schema = dataType.getAllProperties();
- value = _valueDict;
- propertyName = _propName;
- }
-
- @SuppressWarnings("unchecked")
- public Object validate() {
- // Validate the value by the definition of the datatype
-
- // A datatype can not have both 'type' and 'properties' definitions.
- // If the datatype has 'type' definition
- if(dataType.getValueType() != null) {
- value = DataEntity.validateDatatype(dataType.getValueType(),value,null,customDef,null);
- Schema schemaCls = new Schema(propertyName,dataType.getDefs());
- for(Constraint constraint: schemaCls.getConstraints()) {
- constraint.validate(value);
- }
- }
- // If the datatype has 'properties' definition
- else {
- if(!(value instanceof LinkedHashMap)) {
- //ERROR under investigation
- ExceptionCollector.appendWarning(String.format(
- "TypeMismatchError: \"%s\" is not a map. The type is \"%s\"",
- value.toString(),dataType.getType()));
-<<<<<<< HEAD
- return value;
- }
- LinkedHashMap<String,Object> valueDict = (LinkedHashMap<String,Object>)value;
-=======
-
- if (value instanceof List)
- value = ((List) value).get(0);
-
- if (!(value instanceof LinkedHashMap))
- return value;
- }
-
-
-
- LinkedHashMap<String,Object> valueDict = (LinkedHashMap<String,Object>)value;
->>>>>>> master
- ArrayList<String> allowedProps = new ArrayList<>();
- ArrayList<String> requiredProps = new ArrayList<>();
- LinkedHashMap<String,Object> defaultProps = new LinkedHashMap<>();
- if(schema != null) {
- allowedProps.addAll(schema.keySet());
- for(String name: schema.keySet()) {
- PropertyDef propDef = schema.get(name);
- if(propDef.isRequired()) {
- requiredProps.add(name);
- }
- if(propDef.getDefault() != null) {
- defaultProps.put(name,propDef.getDefault());
- }
- }
- }
-
- // check allowed field
- for(String valueKey: valueDict.keySet()) {
- //1710 devlop JSON validation
- if(!("json").equals(dataType.getType()) && !allowedProps.contains(valueKey)) {
- ExceptionCollector.appendException(String.format(
- "UnknownFieldError: Data value of type \"%s\" contains unknown field \"%s\"",
- dataType.getType(),valueKey));
- }
- }
-
- // check default field
- for(String defKey: defaultProps.keySet()) {
- Object defValue = defaultProps.get(defKey);
- if(valueDict.get(defKey) == null) {
- valueDict.put(defKey, defValue);
- }
-
- }
-
- // check missing field
- ArrayList<String> missingProp = new ArrayList<>();
- for(String reqKey: requiredProps) {
- if(!valueDict.keySet().contains(reqKey)) {
- missingProp.add(reqKey);
- }
- }
- if(missingProp.size() > 0) {
- ExceptionCollector.appendWarning(String.format(
- "MissingRequiredFieldError: Data value of type \"%s\" is missing required field(s) \"%s\"",
- dataType.getType(),missingProp.toString()));
- }
-
- // check every field
- for(String vname: valueDict.keySet()) {
- Object vvalue = valueDict.get(vname);
- LinkedHashMap<String,Object> schemaName = _findSchema(vname);
- if(schemaName == null) {
- continue;
- }
- Schema propSchema = new Schema(vname,schemaName);
- // check if field value meets type defined
- DataEntity.validateDatatype(propSchema.getType(),
- vvalue,
- propSchema.getEntrySchema(),
- customDef,
- null);
-
- // check if field value meets constraints defined
- if(propSchema.getConstraints() != null) {
- for(Constraint constraint: propSchema.getConstraints()) {
- if(vvalue instanceof ArrayList) {
- for(Object val: (ArrayList<Object>)vvalue) {
- constraint.validate(val);
- }
- }
- else {
- constraint.validate(vvalue);
- }
- }
- }
- }
- }
- return value;
- }
-
- private LinkedHashMap<String,Object> _findSchema(String name) {
- if(schema != null && schema.get(name) != null) {
- return schema.get(name).getSchema();
- }
- return null;
- }
-
- public static Object validateDatatype(String type,
- Object value,
- LinkedHashMap<String,Object> entrySchema,
- LinkedHashMap<String,Object> customDef,
- String propName) {
- // Validate value with given type
-
- // If type is list or map, validate its entry by entry_schema(if defined)
- // If type is a user-defined complex datatype, custom_def is required.
-
- if(Function.isFunction(value)) {
- return value;
- }
- else if (type == null) {
- //NOT ANALYZED
- ExceptionCollector.appendWarning(String.format(
- "MissingType: Type is missing for value \"%s\"",
- value.toString()));
- return value;
- }
- else if(type.equals(Schema.STRING)) {
- return ValidateUtils.validateString(value);
- }
- else if(type.equals(Schema.INTEGER)) {
- return ValidateUtils.validateInteger(value);
- }
- else if(type.equals(Schema.FLOAT)) {
- return ValidateUtils.validateFloat(value);
- }
- else if(type.equals(Schema.NUMBER)) {
- return ValidateUtils.validateNumeric(value);
- }
- else if(type.equals(Schema.BOOLEAN)) {
- return ValidateUtils.validateBoolean(value);
- }
- else if(type.equals(Schema.RANGE)) {
- return ValidateUtils.validateRange(value);
- }
- else if(type.equals(Schema.TIMESTAMP)) {
- ValidateUtils.validateTimestamp(value);
- return value;
- }
- else if(type.equals(Schema.LIST)) {
- ValidateUtils.validateList(value);
- if(entrySchema != null) {
- DataEntity.validateEntry(value,entrySchema,customDef);
- }
- return value;
- }
- else if(type.equals(Schema.SCALAR_UNIT_SIZE)) {
- return (new ScalarUnitSize(value)).validateScalarUnit();
- }
- else if(type.equals(Schema.SCALAR_UNIT_FREQUENCY)) {
- return (new ScalarUnitFrequency(value)).validateScalarUnit();
- }
- else if(type.equals(Schema.SCALAR_UNIT_TIME)) {
- return (new ScalarUnitTime(value)).validateScalarUnit();
- }
- else if(type.equals(Schema.VERSION)) {
- return (new TOSCAVersionProperty(value)).getVersion();
- }
- else if(type.equals(Schema.MAP)) {
- ValidateUtils.validateMap(value);
- if(entrySchema != null) {
- DataEntity.validateEntry(value,entrySchema,customDef);
- }
- return value;
- }
- else if(type.equals(Schema.PORTSPEC)) {
- // tODO(TBD) bug 1567063, validate source & target as PortDef type
- // as complex types not just as integers
- PortSpec.validateAdditionalReq(value,propName,customDef);
- }
- else {
- DataEntity data = new DataEntity(type,value,customDef,null);
- return data.validate();
- }
-
- return value;
- }
-
- @SuppressWarnings("unchecked")
- public static Object validateEntry(Object value,
- LinkedHashMap<String,Object> entrySchema,
- LinkedHashMap<String,Object> customDef) {
-
- // Validate entries for map and list
- Schema schema = new Schema(null,entrySchema);
- Object valueob = value;
- ArrayList<Object> valueList = null;
- if(valueob instanceof LinkedHashMap) {
- valueList = new ArrayList<Object>(((LinkedHashMap<String,Object>)valueob).values());
- }
- else if(valueob instanceof ArrayList) {
- valueList = (ArrayList<Object>)valueob;
- }
- if(valueList != null) {
- for(Object v: valueList) {
- DataEntity.validateDatatype(schema.getType(),v,schema.getEntrySchema(),customDef,null);
- if(schema.getConstraints() != null) {
- for(Constraint constraint: schema.getConstraints()) {
- constraint.validate(v);
- }
- }
- }
- }
- return value;
- }
-
- @Override
- public String toString() {
- return "DataEntity{" +
- "customDef=" + customDef +
- ", dataType=" + dataType +
- ", schema=" + schema +
- ", value=" + value +
- ", propertyName='" + propertyName + '\'' +
- '}';
- }
-}
-
-/*python
-
-from toscaparser.common.exception import ExceptionCollector
-from toscaparser.common.exception import MissingRequiredFieldError
-from toscaparser.common.exception import TypeMismatchError
-from toscaparser.common.exception import UnknownFieldError
-from toscaparser.elements.constraints import Schema
-from toscaparser.elements.datatype import DataType
-from toscaparser.elements.portspectype import PortSpec
-from toscaparser.elements.scalarunit import ScalarUnit_Frequency
-from toscaparser.elements.scalarunit import ScalarUnit_Size
-from toscaparser.elements.scalarunit import ScalarUnit_Time
-from toscaparser.utils.gettextutils import _
-from toscaparser.utils import validateutils
-
-
-class DataEntity(object):
- '''A complex data value entity.'''
-
- def __init__(self, datatypename, value_dict, custom_def=None,
- prop_name=None):
- self.custom_def = custom_def
- self.datatype = DataType(datatypename, custom_def)
- self.schema = self.datatype.get_all_properties()
- self.value = value_dict
- self.property_name = prop_name
-
- def validate(self):
- '''Validate the value by the definition of the datatype.'''
-
- # A datatype can not have both 'type' and 'properties' definitions.
- # If the datatype has 'type' definition
- if self.datatype.value_type:
- self.value = DataEntity.validate_datatype(self.datatype.value_type,
- self.value,
- None,
- self.custom_def)
- schema = Schema(self.property_name, self.datatype.defs)
- for constraint in schema.constraints:
- constraint.validate(self.value)
- # If the datatype has 'properties' definition
- else:
- if not isinstance(self.value, dict):
- ExceptionCollector.appendException(
- TypeMismatchError(what=self.value,
- type=self.datatype.type))
- allowed_props = []
- required_props = []
- default_props = {}
- if self.schema:
- allowed_props = self.schema.keys()
- for name, prop_def in self.schema.items():
- if prop_def.required:
- required_props.append(name)
- if prop_def.default:
- default_props[name] = prop_def.default
-
- # check allowed field
- for value_key in list(self.value.keys()):
- if value_key not in allowed_props:
- ExceptionCollector.appendException(
- UnknownFieldError(what=(_('Data value of type "%s"')
- % self.datatype.type),
- field=value_key))
-
- # check default field
- for def_key, def_value in list(default_props.items()):
- if def_key not in list(self.value.keys()):
- self.value[def_key] = def_value
-
- # check missing field
- missingprop = []
- for req_key in required_props:
- if req_key not in list(self.value.keys()):
- missingprop.append(req_key)
- if missingprop:
- ExceptionCollector.appendException(
- MissingRequiredFieldError(
- what=(_('Data value of type "%s"')
- % self.datatype.type), required=missingprop))
-
- # check every field
- for name, value in list(self.value.items()):
- schema_name = self._find_schema(name)
- if not schema_name:
- continue
- prop_schema = Schema(name, schema_name)
- # check if field value meets type defined
- DataEntity.validate_datatype(prop_schema.type, value,
- prop_schema.entry_schema,
- self.custom_def)
- # check if field value meets constraints defined
- if prop_schema.constraints:
- for constraint in prop_schema.constraints:
- if isinstance(value, list):
- for val in value:
- constraint.validate(val)
- else:
- constraint.validate(value)
-
- return self.value
-
- def _find_schema(self, name):
- if self.schema and name in self.schema.keys():
- return self.schema[name].schema
-
- @staticmethod
- def validate_datatype(type, value, entry_schema=None, custom_def=None,
- prop_name=None):
- '''Validate value with given type.
-
- If type is list or map, validate its entry by entry_schema(if defined)
- If type is a user-defined complex datatype, custom_def is required.
- '''
- from toscaparser.functions import is_function
- if is_function(value):
- return value
- if type == Schema.STRING:
- return validateutils.validate_string(value)
- elif type == Schema.INTEGER:
- return validateutils.validate_integer(value)
- elif type == Schema.FLOAT:
- return validateutils.validate_float(value)
- elif type == Schema.NUMBER:
- return validateutils.validate_numeric(value)
- elif type == Schema.BOOLEAN:
- return validateutils.validate_boolean(value)
- elif type == Schema.RANGE:
- return validateutils.validate_range(value)
- elif type == Schema.TIMESTAMP:
- validateutils.validate_timestamp(value)
- return value
- elif type == Schema.LIST:
- validateutils.validate_list(value)
- if entry_schema:
- DataEntity.validate_entry(value, entry_schema, custom_def)
- return value
- elif type == Schema.SCALAR_UNIT_SIZE:
- return ScalarUnit_Size(value).validate_scalar_unit()
- elif type == Schema.SCALAR_UNIT_FREQUENCY:
- return ScalarUnit_Frequency(value).validate_scalar_unit()
- elif type == Schema.SCALAR_UNIT_TIME:
- return ScalarUnit_Time(value).validate_scalar_unit()
- elif type == Schema.VERSION:
- return validateutils.TOSCAVersionProperty(value).get_version()
- elif type == Schema.MAP:
- validateutils.validate_map(value)
- if entry_schema:
- DataEntity.validate_entry(value, entry_schema, custom_def)
- return value
- elif type == Schema.PORTSPEC:
- # tODO(TBD) bug 1567063, validate source & target as PortDef type
- # as complex types not just as integers
- PortSpec.validate_additional_req(value, prop_name, custom_def)
- else:
- data = DataEntity(type, value, custom_def)
- return data.validate()
-
- @staticmethod
- def validate_entry(value, entry_schema, custom_def=None):
- '''Validate entries for map and list.'''
- schema = Schema(None, entry_schema)
- valuelist = value
- if isinstance(value, dict):
- valuelist = list(value.values())
- for v in valuelist:
- DataEntity.validate_datatype(schema.type, v, schema.entry_schema,
- custom_def)
- if schema.constraints:
- for constraint in schema.constraints:
- constraint.validate(v)
- return value
-*/
\ No newline at end of file
+++ /dev/null
-package org.openecomp.sdc.toscaparser.api;
-
-import org.openecomp.sdc.toscaparser.api.common.JToscaError;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import org.openecomp.sdc.toscaparser.api.common.ValidationIssueCollector;
-import org.openecomp.sdc.toscaparser.api.elements.InterfacesDef;
-import org.openecomp.sdc.toscaparser.api.elements.NodeType;
-import org.openecomp.sdc.toscaparser.api.elements.RelationshipType;
-import org.openecomp.sdc.toscaparser.api.functions.Function;
-import org.openecomp.sdc.toscaparser.api.functions.GetAttribute;
-import org.openecomp.sdc.toscaparser.api.functions.GetInput;
-import org.openecomp.sdc.toscaparser.api.parameters.Input;
-import org.openecomp.sdc.toscaparser.api.parameters.Output;
-import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-
-public class TopologyTemplate {
-
- 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;
- LinkedHashMap<String,Object> 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() {
- //DumpUtils.dumpYaml(customDefs,0);
- ArrayList<Input> alInputs = new ArrayList<>();
- for(String name: _tplInputs().keySet()) {
- Object attrs = _tplInputs().get(name);
- Input input = new Input(name,(LinkedHashMap<String,Object>)attrs,customDefs);
- 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) {
- System.out.format("Log warning: The required parameter \"%s\" is not provided\n",input.getName());
- }
- alInputs.add(input);
- }
- return alInputs;
-
- }
-
- private LinkedHashMap<String,Object> _metaData() {
- if(tpl.get(METADATA) != null) {
- return (LinkedHashMap<String,Object>)tpl.get(METADATA);
- }
- else {
- return new LinkedHashMap<String,Object>();
- }
-
- }
-
- 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()) {
- ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE241", 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)) {
- ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE242", 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) {
- ThreadLocalsHolder.getCollector().appendError(new JToscaError("JE243", 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 LinkedHashMap<String,Object> 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;
- }
-}
-
-/*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
Code Review / sdc / sdc-tosca.git / commitdiff