}
}
if (_entityName.equals("relationship_type")) {
- Object relationship = _template.get("relationship");
+ Object relationship = _template.get(RELATIONSHIP);
type = null;
if (relationship != null && relationship instanceof LinkedHashMap) {
type = (String) ((LinkedHashMap<String, Object>) relationship).get("type");
} else if (relationship instanceof String) {
- type = (String) entityTpl.get("relationship");
+ type = (String) entityTpl.get(RELATIONSHIP);
} else {
type = (String) entityTpl.get("type");
}
for (String reqName : req.keySet()) {
Object reqItem = req.get(reqName);
if (reqItem instanceof LinkedHashMap) {
- Object rel = ((LinkedHashMap<String, Object>) reqItem).get("relationship");
-// LinkedHashMap relationship = rel instanceof LinkedHashMap ? (LinkedHashMap) rel : null;
+ Object rel = ((LinkedHashMap<String, Object>) reqItem).get(RELATIONSHIP);
String nodeName = ((LinkedHashMap<String, Object>) reqItem).get("node").toString();
- Object capability = ((LinkedHashMap<String, Object>) reqItem).get("capability");
+ Object capability = ((LinkedHashMap<String, Object>) reqItem).get(CAPABILITY);
String capabilityString = capability != null ? capability.toString() : null;
reqs.add(new RequirementAssignment(reqName, nodeName, capabilityString, rel));
}
}
// then update (if available) with the node properties
- LinkedHashMap<String, Object> pp = (LinkedHashMap<String, Object>) props.get("properties");
+ LinkedHashMap<String, Object> pp = (LinkedHashMap<String, Object>) props.get(PROPERTIES);
if (pp != null) {
properties.putAll(pp);
}
LinkedHashMap<String, Object> capabilities = (LinkedHashMap<String, Object>)
((EntityType) typeDefinition).getValue(CAPABILITIES, entityTpl, false);
if (capabilities != null) {
- _commonValidateField(capabilities, allowedCaps, "capabilities");
+ _commonValidateField(capabilities, allowedCaps, CAPABILITIES);
_validateCapabilitiesProperties(capabilities);
}
}
int maxInstances = (int) propDict.get("max_instances");
int defaultInstances = (int) propDict.get("default_instances");
if (defaultInstances < minInstances || defaultInstances > maxInstances) {
- //err_msg = ('"properties" of template "%s": '
+ //err_msg = ('PROPERTIES of template "%s": '
// '"default_instances" value is not between '
// '"min_instances" and "max_instances".' %
// self.name)
// validate all required properties have values
if (properties != null) {
ArrayList<String> reqPropsNoValueOrDefault = new ArrayList<String>();
- _commonValidateField(properties, allowedProps, "properties");
+ _commonValidateField(properties, allowedProps, PROPERTIES);
// make sure it's not missing any property required by a tosca type
for (String r : requiredProps) {
if (properties.get(r) == null) {
return;//???
}
boolean bBad = false;
- Object relationship = ((LinkedHashMap<String, Object>) template).get("relationship");
+ Object relationship = ((LinkedHashMap<String, Object>) template).get(RELATIONSHIP);
if (relationship != null) {
if (!(relationship instanceof String)) {
bBad = (((LinkedHashMap<String, Object>) relationship).get(TYPE) == null);
} else if (relationship instanceof String) {
- bBad = (template.get("relationship") == null);
+ bBad = (template.get(RELATIONSHIP) == null);
}
} else {
bBad = (template.get(TYPE) == null);
Object relDef = relValue;
LinkedHashMap<String, Object> rel = null;
if (relDef instanceof LinkedHashMap) {
- Object relob = ((LinkedHashMap<String, Object>) relDef).get("relationship");
+ Object relob = ((LinkedHashMap<String, Object>) relDef).get(RELATIONSHIP);
if (relob instanceof LinkedHashMap) {
rel = (LinkedHashMap<String, Object>) relob;
}
'}';
}
}
-
-/*python
-
-class EntityTemplate(object):
- '''Base class for TOSCA templates.'''
-
- SECTIONS = (DERIVED_FROM, PROPERTIES, REQUIREMENTS,
- INTERFACES, CAPABILITIES, TYPE, DESCRIPTION, DIRECTIVES,
- ATTRIBUTES, ARTIFACTS, NODE_FILTER, COPY) = \
- ('derived_from', 'properties', 'requirements', 'interfaces',
- 'capabilities', 'type', 'description', 'directives',
- 'attributes', 'artifacts', 'node_filter', 'copy')
- REQUIREMENTS_SECTION = (NODE, CAPABILITY, RELATIONSHIP, OCCURRENCES, NODE_FILTER) = \
- ('node', 'capability', 'relationship',
- 'occurrences', 'node_filter')
- # Special key names
- SPECIAL_SECTIONS = (METADATA) = ('metadata')
-
- 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)
- type = self.entity_tpl.get('type')
- UnsupportedType.validate_type(type)
- if entity_name == 'node_type':
- self.type_definition = NodeType(type, custom_def) \
- if type is not None else None
- if entity_name == 'relationship_type':
- relationship = template.get('relationship')
- type = None
- if relationship and isinstance(relationship, dict):
- type = relationship.get('type')
- elif isinstance(relationship, str):
- type = self.entity_tpl['relationship']
- else:
- type = self.entity_tpl['type']
- UnsupportedType.validate_type(type)
- self.type_definition = RelationshipType(type,
- None, custom_def)
- if entity_name == 'policy_type':
- if not type:
- msg = (_('Policy definition of "%(pname)s" must have'
- ' a "type" ''attribute.') % dict(pname=name))
- ValidationIssueCollector.appendException(
- ValidationError(msg))
-
- self.type_definition = PolicyType(type, custom_def)
- if entity_name == 'group_type':
- self.type_definition = GroupType(type, custom_def) \
- if type is not None else None
- self._properties = None
- self._interfaces = None
- self._requirements = None
- self._capabilities = None
-
- @property
- def type(self):
- if self.type_definition:
- return self.type_definition.type
-
- @property
- def parent_type(self):
- if self.type_definition:
- return self.type_definition.parent_type
-
- @property
- def requirements(self):
- if self._requirements is None:
- self._requirements = self.type_definition.get_value(
- self.REQUIREMENTS,
- self.entity_tpl) or []
- return self._requirements
-
- def get_properties_objects(self):
- '''Return properties objects for this template.'''
- if self._properties is None:
- self._properties = self._create_properties()
- return self._properties
-
- def get_properties(self):
- '''Return a dictionary of property name-object pairs.'''
- return {prop.name: prop
- for prop in self.get_properties_objects()}
-
- def get_property_value(self, name):
- '''Return the value of a given property name.'''
- props = self.get_properties()
- if props and name in props.keys():
- return props[name].value
-
- @property
- def interfaces(self):
- if self._interfaces is None:
- self._interfaces = self._create_interfaces()
- return self._interfaces
-
- def get_capabilities_objects(self):
- '''Return capabilities objects for this template.'''
- if not self._capabilities:
- self._capabilities = self._create_capabilities()
- return self._capabilities
-
- def get_capabilities(self):
- '''Return a dictionary of capability name-object pairs.'''
- return {cap.name: cap
- for cap in self.get_capabilities_objects()}
-
- def is_derived_from(self, type_str):
- '''Check if object inherits from the given type.
-
- Returns true if this object is derived from 'type_str'.
- False otherwise.
- '''
- if not self.type:
- return False
- elif self.type == type_str:
- return True
- elif self.parent_type:
- return self.parent_type.is_derived_from(type_str)
- else:
- return False
-
- def _create_capabilities(self):
- capability = []
- caps = self.type_definition.get_value(self.CAPABILITIES,
- self.entity_tpl, True)
- if caps:
- for name, props in caps.items():
- capabilities = self.type_definition.get_capabilities()
- if name in capabilities.keys():
- c = capabilities[name]
- properties = {}
- # first use the definition default value
- if c.properties:
- for property_name in c.properties.keys():
- prop_def = c.properties[property_name]
- if 'default' in prop_def:
- properties[property_name] = prop_def['default']
- # then update (if available) with the node properties
- if 'properties' in props and props['properties']:
- properties.update(props['properties'])
-
- cap = CapabilityAssignment(name, properties, c)
- capability.append(cap)
- return capability
-
- def _validate_properties(self, template, entitytype):
- properties = entitytype.get_value(self.PROPERTIES, template)
- self._common_validate_properties(entitytype, properties)
-
- def _validate_capabilities(self):
- type_capabilities = self.type_definition.get_capabilities()
- allowed_caps = \
- type_capabilities.keys() if type_capabilities else []
- capabilities = self.type_definition.get_value(self.CAPABILITIES,
- self.entity_tpl)
- if capabilities:
- self._common_validate_field(capabilities, allowed_caps,
- 'capabilities')
- self._validate_capabilities_properties(capabilities)
-
- def _validate_capabilities_properties(self, capabilities):
- for cap, props in capabilities.items():
- capability = self.get_capability(cap)
- if not capability:
- continue
- capabilitydef = capability.definition
- self._common_validate_properties(capabilitydef,
- props[self.PROPERTIES])
-
- # validating capability properties values
- for prop in self.get_capability(cap).get_properties_objects():
- prop.validate()
-
- # tODO(srinivas_tadepalli): temporary work around to validate
- # default_instances until standardized in specification
- if cap == "scalable" and prop.name == "default_instances":
- prop_dict = props[self.PROPERTIES]
- min_instances = prop_dict.get("min_instances")
- max_instances = prop_dict.get("max_instances")
- default_instances = prop_dict.get("default_instances")
- if not (min_instances <= default_instances
- <= max_instances):
- err_msg = ('"properties" of template "%s": '
- '"default_instances" value is not between '
- '"min_instances" and "max_instances".' %
- self.name)
- ValidationIssueCollector.appendException(
- ValidationError(message=err_msg))
-
- def _common_validate_properties(self, entitytype, properties):
- allowed_props = []
- required_props = []
- for p in entitytype.get_properties_def_objects():
- allowed_props.append(p.name)
- # If property is 'required' and has no 'default' value then record
- if p.required and p.default is None:
- required_props.append(p.name)
- # validate all required properties have values
- if properties:
- req_props_no_value_or_default = []
- self._common_validate_field(properties, allowed_props,
- 'properties')
- # make sure it's not missing any property required by a tosca type
- for r in required_props:
- if r not in properties.keys():
- req_props_no_value_or_default.append(r)
- # Required properties found without value or a default value
- if req_props_no_value_or_default:
- ValidationIssueCollector.appendException(
- MissingRequiredFieldError(
- what='"properties" of template "%s"' % self.name,
- required=req_props_no_value_or_default))
- else:
- # Required properties in schema, but not in template
- if required_props:
- ValidationIssueCollector.appendException(
- MissingRequiredFieldError(
- what='"properties" of template "%s"' % self.name,
- required=required_props))
-
- def _validate_field(self, template):
- if not isinstance(template, dict):
- ValidationIssueCollector.appendException(
- MissingRequiredFieldError(
- what='Template "%s"' % self.name, required=self.TYPE))
- try:
- relationship = template.get('relationship')
- if relationship and not isinstance(relationship, str):
- relationship[self.TYPE]
- elif isinstance(relationship, str):
- template['relationship']
- else:
- template[self.TYPE]
- except KeyError:
- ValidationIssueCollector.appendException(
- MissingRequiredFieldError(
- what='Template "%s"' % self.name, required=self.TYPE))
-
- def _common_validate_field(self, schema, allowedlist, section):
- for name in schema:
- if name not in allowedlist:
- ValidationIssueCollector.appendException(
- UnknownFieldError(
- what=('"%(section)s" of template "%(nodename)s"'
- % {'section': section, 'nodename': self.name}),
- field=name))
-
- def _create_properties(self):
- props = []
- properties = self.type_definition.get_value(self.PROPERTIES,
- self.entity_tpl) or {}
- for name, value in properties.items():
- props_def = self.type_definition.get_properties_def()
- if props_def and name in props_def:
- prop = Property(name, value,
- props_def[name].schema, self.custom_def)
- props.append(prop)
- for p in self.type_definition.get_properties_def_objects():
- if p.default is not None and p.name not in properties.keys():
- prop = Property(p.name, p.default, p.schema, self.custom_def)
- props.append(prop)
- return props
-
- def _create_interfaces(self):
- interfaces = []
- type_interfaces = None
- if isinstance(self.type_definition, RelationshipType):
- if isinstance(self.entity_tpl, dict):
- if self.INTERFACES in self.entity_tpl:
- type_interfaces = self.entity_tpl[self.INTERFACES]
- else:
- for rel_def, value in self.entity_tpl.items():
- if rel_def != 'type':
- rel_def = self.entity_tpl.get(rel_def)
- rel = None
- if isinstance(rel_def, dict):
- rel = rel_def.get('relationship')
- if rel:
- if self.INTERFACES in rel:
- type_interfaces = rel[self.INTERFACES]
- break
- else:
- type_interfaces = self.type_definition.get_value(self.INTERFACES,
- self.entity_tpl)
- if type_interfaces:
- for interface_type, value in type_interfaces.items():
- for op, op_def in value.items():
- iface = InterfacesDef(self.type_definition,
- interfacetype=interface_type,
- node_template=self,
- name=op,
- value=op_def)
- interfaces.append(iface)
- return interfaces
-
- def get_capability(self, name):
- """Provide named capability
-
- :param name: name of capability
- :return: capability object if found, None otherwise
- """
- caps = self.get_capabilities()
- if caps and name in caps.keys():
- return caps[name]
-*/
package org.onap.sdc.toscaparser.api;
+import static org.onap.sdc.toscaparser.api.elements.EntityType.TOSCA_DEF;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
+import org.onap.sdc.toscaparser.api.elements.ArtifactDef;
import org.onap.sdc.toscaparser.api.elements.EntityType;
import org.onap.sdc.toscaparser.api.elements.InterfacesDef;
import org.onap.sdc.toscaparser.api.elements.Metadata;
import org.onap.sdc.toscaparser.api.utils.CopyUtils;
import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.onap.sdc.toscaparser.api.elements.EntityType.TOSCA_DEF;
-
public class NodeTemplate extends EntityTemplate {
+ private static final String METADATA = "metadata";
private LinkedHashMap<String, Object> templates;
- private LinkedHashMap<String, Object> customDef;
private ArrayList<RelationshipTemplate> availableRelTpls;
private LinkedHashMap<String, Object> availableRelTypes;
private LinkedHashMap<NodeTemplate, RelationshipType> related;
private ArrayList<RelationshipTemplate> relationshipTpl;
private LinkedHashMap<RelationshipType, NodeTemplate> _relationships;
+ @Getter
+ @Setter
private SubstitutionMappings subMappingToscaTemplate;
+ @Getter
+ @Setter
private TopologyTemplate originComponentTemplate;
+ @Getter
+ @Setter
private Metadata metadata;
-
- private static final String METADATA = "metadata";
+ @Getter
+ private Map<String, ArtifactDef> artifacts;
public NodeTemplate(String name,
LinkedHashMap<String, Object> ntnodeTemplates,
LinkedHashMap<String, Object> ntcustomDef,
ArrayList<RelationshipTemplate> ntavailableRelTpls,
LinkedHashMap<String, Object> ntavailableRelTypes) {
- this(name, ntnodeTemplates, ntcustomDef, ntavailableRelTpls,
- ntavailableRelTypes, null);
+ this(name, ntnodeTemplates, ntcustomDef, ntavailableRelTpls, ntavailableRelTypes, null);
}
@SuppressWarnings("unchecked")
LinkedHashMap<String, Object> ntavailableRelTypes,
NodeTemplate parentNodeTemplate) {
- super(name, (LinkedHashMap<String, Object>) ntnodeTemplates.get(name),
- "node_type", ntcustomDef, parentNodeTemplate);
+ super(name, (LinkedHashMap<String, Object>) ntnodeTemplates.get(name), "node_type", ntcustomDef, parentNodeTemplate);
templates = ntnodeTemplates;
_validateFields((LinkedHashMap<String, Object>) templates.get(name));
_relationships = new LinkedHashMap<RelationshipType, NodeTemplate>();
subMappingToscaTemplate = null;
metadata = _metaData();
+ artifacts = readArtifacts((Map<String, Object>) templates.get(name));
+ }
+
+ private Map<String, ArtifactDef> readArtifacts(final Map<String, Object> nodetemplate) {
+ if (nodetemplate.get("artifacts") != null) {
+ final Map<String, ArtifactDef> artifactsMap = new HashMap<>();
+ ((Map<String, Object>) nodetemplate.get("artifacts")).forEach((name, value) -> {
+ artifactsMap.put(name, new ArtifactDef((Map<String, Object>) value));
+ });
+ return artifactsMap;
+ }
+ return null;
}
@SuppressWarnings("unchecked")
}
if (bFound || customDef.get(node) != null) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE205", String.format(
- "NotImplementedError: Lookup by TOSCA types is not supported. Requirement for \"%s\" can not be full-filled",
- getName())));
+ "NotImplementedError: Lookup by TOSCA types is not supported. Requirement for \"%s\" can not be full-filled",
+ getName())));
return null;
}
if (templates.get(node) == null) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE206", String.format(
- "KeyError: Node template \"%s\" was not found", node)));
+ "KeyError: Node template \"%s\" was not found", node)));
return null;
}
NodeTemplate relatedTpl = new NodeTemplate(node, templates, customDef, null, null);
if (relationship == null) {
ArrayList<Object> parentReqs = ((NodeType) typeDefinition).getAllRequirements();
if (parentReqs == null) {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE207", "ValidationError: parent_req is null"));
+ ThreadLocalsHolder.getCollector()
+ .appendValidationIssue(new JToscaValidationIssue("JE207", "ValidationError: parent_req is null"));
} else {
// for(String key: req.keySet()) {
// boolean bFoundRel = false;
relationshipString = (String) ((LinkedHashMap<String, Object>) relationship).get("type");
if (relationshipString != null) {
if (availableRelTypes != null && !availableRelTypes.isEmpty() &&
- availableRelTypes.get(relationshipString) != null) {
+ availableRelTypes.get(relationshipString) != null) {
;
} else if (!(relationshipString).startsWith(relPrfx)) {
relationshipString = relPrfx + relationshipString;
}
} else {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE208", String.format(
- "MissingRequiredFieldError: \"relationship\" used in template \"%s\" is missing required field \"type\"",
- relatedTpl.getName())));
+ "MissingRequiredFieldError: \"relationship\" used in template \"%s\" is missing required field \"type\"",
+ relatedTpl.getName())));
}
}
for (RelationshipType rtype : ((NodeType) typeDefinition).getRelationship().keySet()) {
if (requires != null) {
if (!(requires instanceof ArrayList)) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE209", String.format(
- "TypeMismatchError: \"requirements\" of template \"%s\" are not of type \"list\"", name)));
+ "TypeMismatchError: \"requirements\" of template \"%s\" are not of type \"list\"", name)));
} else {
for (Object ro : requires) {
LinkedHashMap<String, Object> req = (LinkedHashMap<String, Object>) ro;
DataEntity.validateDatatype("Integer", val, null, null, null);
}
if (occurrences.size() != 2 ||
- !(0 <= (int) occurrences.get(0) && (int) occurrences.get(0) <= (int) occurrences.get(1)) ||
- (int) occurrences.get(1) == 0) {
+ !(0 <= (int) occurrences.get(0) && (int) occurrences.get(0) <= (int) occurrences.get(1)) ||
+ (int) occurrences.get(1) == 0) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE210", String.format(
- "InvalidPropertyValueError: property has invalid value %s", occurrences.toString())));
+ "InvalidPropertyValueError: property has invalid value %s", occurrences.toString())));
}
}
}
if (!bFound) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE211", String.format(
- "UnknownFieldError: \"requirements\" of template \"%s\" contains unknown field \"%s\"", name, key)));
+ "UnknownFieldError: \"requirements\" of template \"%s\" contains unknown field \"%s\"", name, key)));
}
}
}
@SuppressWarnings("unchecked")
private void _validateInterfaces() {
- LinkedHashMap<String, Object> ifaces = (LinkedHashMap<String, Object>)
- ((NodeType) typeDefinition).getValue(INTERFACES, entityTpl, false);
+ LinkedHashMap<String, Object> ifaces = (LinkedHashMap<String, Object>) ((NodeType) typeDefinition).getValue(INTERFACES, entityTpl, false);
if (ifaces != null) {
for (Map.Entry<String, Object> me : ifaces.entrySet()) {
String iname = me.getKey();
_commonValidateField(value, _collectCustomIfaceOperations(iname), "interfaces");
} else {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE212", String.format(
- "UnknownFieldError: \"interfaces\" of template \"%s\" contains unknown field %s", name, iname)));
+ "UnknownFieldError: \"interfaces\" of template \"%s\" contains unknown field %s", name, iname)));
}
}
}
@SuppressWarnings("unchecked")
private ArrayList<String> _collectCustomIfaceOperations(String iname) {
ArrayList<String> allowedOperations = new ArrayList<>();
- LinkedHashMap<String, Object> nodetypeIfaceDef = (LinkedHashMap<String, Object>) ((NodeType)
- typeDefinition).getInterfaces().get(iname);
+ LinkedHashMap<String, Object> nodetypeIfaceDef = (LinkedHashMap<String, Object>) ((NodeType) typeDefinition).getInterfaces().get(iname);
allowedOperations.addAll(nodetypeIfaceDef.keySet());
String ifaceType = (String) nodetypeIfaceDef.get("type");
if (ifaceType != null) {
}
if (!bFound) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE213", String.format(
- "UnknownFieldError: Node template \"%s\" has unknown field \"%s\"", name, ntname)));
+ "UnknownFieldError: Node template \"%s\" has unknown field \"%s\"", name, ntname)));
}
}
}
- // getter/setter
-
- // multilevel nesting
- public SubstitutionMappings getSubMappingToscaTemplate() {
- return subMappingToscaTemplate;
- }
-
- public void setSubMappingToscaTemplate(SubstitutionMappings sm) {
- subMappingToscaTemplate = sm;
- }
-
- public Metadata getMetaData() {
- return metadata;
- }
-
- public void setMetaData(Metadata metadata) {
- this.metadata = metadata;
- }
-
@Override
public String toString() {
return getName();
}
- public TopologyTemplate getOriginComponentTemplate() {
- return originComponentTemplate;
- }
-
- public void setOriginComponentTemplate(TopologyTemplate originComponentTemplate) {
- this.originComponentTemplate = originComponentTemplate;
- }
-
}
-
-/*python
-
-from toscaparser.common.exception import ValidationIssueCollector
-from toscaparser.common.exception import InvalidPropertyValueError
-from toscaparser.common.exception import MissingRequiredFieldError
-from toscaparser.common.exception import TypeMismatchError
-from toscaparser.common.exception import UnknownFieldError
-from toscaparser.common.exception import ValidationError
-from toscaparser.dataentity import DataEntity
-from toscaparser.elements.interfaces import CONFIGURE
-from toscaparser.elements.interfaces import CONFIGURE_SHORTNAME
-from toscaparser.elements.interfaces import INTERFACE_DEF_RESERVED_WORDS
-from toscaparser.elements.interfaces import InterfacesDef
-from toscaparser.elements.interfaces import LIFECYCLE
-from toscaparser.elements.interfaces import LIFECYCLE_SHORTNAME
-from toscaparser.elements.relationshiptype import RelationshipType
-from toscaparser.entity_template import EntityTemplate
-from toscaparser.relationship_template import RelationshipTemplate
-from toscaparser.utils.gettextutils import _
-
-log = logging.getLogger('tosca')
-
-
-class NodeTemplate(EntityTemplate):
- '''Node template from a Tosca profile.'''
- def __init__(self, name, node_templates, custom_def=None,
- available_rel_tpls=None, available_rel_types=None):
- super(NodeTemplate, self).__init__(name, node_templates[name],
- 'node_type',
- custom_def)
- self.templates = node_templates
- self._validate_fields(node_templates[name])
- self.custom_def = custom_def
- self.related = {}
- self.relationship_tpl = []
- self.available_rel_tpls = available_rel_tpls
- self.available_rel_types = available_rel_types
- self._relationships = {}
- self.sub_mapping_tosca_template = None
-
- @property
- def relationships(self):
- if not self._relationships:
- requires = self.requirements
- if requires and isinstance(requires, list):
- for r in requires:
- for r1, value in r.items():
- explicit = self._get_explicit_relationship(r, value)
- if explicit:
- for key, value in explicit.items():
- self._relationships[key] = value
- return self._relationships
-
- 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 isinstance(value, dict) else value
-
- if node:
- # TO-DO(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 is 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):
- ValidationIssueCollector.appendException(NotImplementedError(msg))
- return
-
- if node not in self.templates:
- ValidationIssueCollector.appendException(
- KeyError(_('Node template "%s" was not found.') % node))
- return
-
- related_tpl = NodeTemplate(node, self.templates, self.custom_def)
- relationship = value.get('relationship') \
- if isinstance(value, dict) else None
- # check if it's type has relationship defined
- if not relationship:
- parent_reqs = self.type_definition.get_all_requirements()
- if parent_reqs is None:
- ValidationIssueCollector.appendException(
- ValidationError(message='parent_req is ' +
- str(parent_reqs)))
- else:
- for key in req.keys():
- for req_dict in parent_reqs:
- if key in req_dict.keys():
- relationship = (req_dict.get(key).
- get('relationship'))
- break
- if relationship:
- found_relationship_tpl = False
- # apply available relationship templates if found
- if self.available_rel_tpls:
- for tpl in self.available_rel_tpls:
- if tpl.name == relationship:
- rtype = RelationshipType(tpl.type, None,
- self.custom_def)
- explicit_relation[rtype] = related_tpl
- tpl.target = related_tpl
- tpl.source = self
- self.relationship_tpl.append(tpl)
- found_relationship_tpl = True
- # create relationship template object.
- rel_prfx = self.type_definition.RELATIONSHIP_PREFIX
- if not found_relationship_tpl:
- if isinstance(relationship, dict):
- relationship = relationship.get('type')
- if relationship:
- if self.available_rel_types and \
- relationship in self.available_rel_types.keys():
- pass
- elif not relationship.startswith(rel_prfx):
- relationship = rel_prfx + relationship
- else:
- ValidationIssueCollector.appendException(
- MissingRequiredFieldError(
- what=_('"relationship" used in template '
- '"%s"') % related_tpl.name,
- required=self.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,
- self)
- elif self.available_rel_types:
- if relationship in self.available_rel_types.keys():
- rel_type_def = self.available_rel_types.\
- get(relationship)
- if 'derived_from' in rel_type_def:
- super_type = \
- rel_type_def.get('derived_from')
- if not super_type.startswith(rel_prfx):
- super_type = rel_prfx + super_type
- if rtype.type == super_type:
- explicit_relation[rtype] = related_tpl
- related_tpl.\
- _add_relationship_template(
- req, rtype.type, self)
- return explicit_relation
-
- def _add_relationship_template(self, requirement, rtype, source):
- req = requirement.copy()
- req['type'] = rtype
- tpl = RelationshipTemplate(req, rtype, self.custom_def, self, source)
- self.relationship_tpl.append(tpl)
-
- def get_relationship_template(self):
- return self.relationship_tpl
-
- def _add_next(self, nodetpl, relationship):
- self.related[nodetpl] = relationship
-
- @property
- def related_nodes(self):
- if not self.related:
- for relation, node in self.type_definition.relationship.items():
- for tpl in self.templates:
- if tpl == node.type:
- self.related[NodeTemplate(tpl)] = relation
- return self.related.keys()
-
- def validate(self, tosca_tpl=None):
- self._validate_capabilities()
- self._validate_requirements()
- self._validate_properties(self.entity_tpl, self.type_definition)
- self._validate_interfaces()
- for prop in self.get_properties_objects():
- prop.validate()
-
- def _validate_requirements(self):
- type_requires = self.type_definition.get_all_requirements()
- allowed_reqs = ["template"]
- if type_requires:
- for treq in type_requires:
- for key, value in treq.items():
- allowed_reqs.append(key)
- if isinstance(value, dict):
- for key in value:
- allowed_reqs.append(key)
-
- requires = self.type_definition.get_value(self.REQUIREMENTS,
- self.entity_tpl)
- if requires:
- if not isinstance(requires, list):
- ValidationIssueCollector.appendException(
- TypeMismatchError(
- what='"requirements" of template "%s"' % self.name,
- type='list'))
- else:
- for req in requires:
- for r1, value in req.items():
- if isinstance(value, dict):
- self._validate_requirements_keys(value)
- self._validate_requirements_properties(value)
- allowed_reqs.append(r1)
- self._common_validate_field(req, allowed_reqs,
- 'requirements')
-
- def _validate_requirements_properties(self, requirements):
- # TO-DO(anyone): Only occurrences property of the requirements is
- # validated here. Validation of other requirement properties are being
- # validated in different files. Better to keep all the requirements
- # properties validation here.
- for key, value in requirements.items():
- if key == 'occurrences':
- self._validate_occurrences(value)
- break
-
- def _validate_occurrences(self, occurrences):
- DataEntity.validate_datatype('list', occurrences)
- for value in occurrences:
- DataEntity.validate_datatype('integer', value)
- if len(occurrences) != 2 or not (0 <= occurrences[0] <= occurrences[1]) \
- or occurrences[1] == 0:
- ValidationIssueCollector.appendException(
- InvalidPropertyValueError(what=(occurrences)))
-
- def _validate_requirements_keys(self, requirement):
- for key in requirement.keys():
- if key not in self.REQUIREMENTS_SECTION:
- ValidationIssueCollector.appendException(
- UnknownFieldError(
- what='"requirements" of template "%s"' % self.name,
- field=key))
-
- def _validate_interfaces(self):
- ifaces = self.type_definition.get_value(self.INTERFACES,
- self.entity_tpl)
- if ifaces:
- for name, value in ifaces.items():
- if name in (LIFECYCLE, LIFECYCLE_SHORTNAME):
- self._common_validate_field(
- value, InterfacesDef.
- interfaces_node_lifecycle_operations,
- 'interfaces')
- elif name in (CONFIGURE, CONFIGURE_SHORTNAME):
- self._common_validate_field(
- value, InterfacesDef.
- interfaces_relationship_configure_operations,
- 'interfaces')
- elif name in self.type_definition.interfaces.keys():
- self._common_validate_field(
- value,
- self._collect_custom_iface_operations(name),
- 'interfaces')
- else:
- ValidationIssueCollector.appendException(
- UnknownFieldError(
- what='"interfaces" of template "%s"' %
- self.name, field=name))
-
- def _collect_custom_iface_operations(self, name):
- allowed_operations = []
- nodetype_iface_def = self.type_definition.interfaces[name]
- allowed_operations.extend(nodetype_iface_def.keys())
- if 'type' in nodetype_iface_def:
- iface_type = nodetype_iface_def['type']
- if iface_type in self.type_definition.custom_def:
- iface_type_def = self.type_definition.custom_def[iface_type]
- else:
- iface_type_def = self.type_definition.TOSCA_DEF[iface_type]
- allowed_operations.extend(iface_type_def.keys())
- allowed_operations = [op for op in allowed_operations if
- op not in INTERFACE_DEF_RESERVED_WORDS]
- return allowed_operations
-
- def _validate_fields(self, nodetemplate):
- for name in nodetemplate.keys():
- if name not in self.SECTIONS and name not in self.SPECIAL_SECTIONS:
- ValidationIssueCollector.appendException(
- UnknownFieldError(what='Node template "%s"' % self.name,
- field=name))*/
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;
-
import org.onap.sdc.toscaparser.api.common.JToscaException;
import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.onap.sdc.toscaparser.api.common.ValidationIssueCollector;
-import org.onap.sdc.toscaparser.api.elements.EntityType;
import org.onap.sdc.toscaparser.api.elements.DataType;
+import org.onap.sdc.toscaparser.api.elements.EntityType;
import org.onap.sdc.toscaparser.api.elements.Metadata;
import org.onap.sdc.toscaparser.api.extensions.ExtTools;
import org.onap.sdc.toscaparser.api.parameters.Input;
public class ToscaTemplate extends Object {
public static final int MAX_LEVELS = 20;
- private static Logger log = LoggerFactory.getLogger(ToscaTemplate.class.getName());
-
+ private static final Logger log = LoggerFactory.getLogger(ToscaTemplate.class.getName());
// TOSCA template key names
private static final String DEFINITION_VERSION = "tosca_definitions_version";
private static final String DEFAULT_NAMESPACE = "tosca_default_namespace";
private static final String POLICY_TYPES = "policy_types";
private static final String GROUP_TYPES = "group_types";
private static final String REPOSITORIES = "repositories";
-
- private static String SECTIONS[] = {
- DEFINITION_VERSION, DEFAULT_NAMESPACE, TEMPLATE_NAME,
- TOPOLOGY_TEMPLATE, TEMPLATE_AUTHOR, TEMPLATE_VERSION,
- DESCRIPTION, IMPORTS, DSL_DEFINITIONS, NODE_TYPES,
- RELATIONSHIP_TYPES, RELATIONSHIP_TEMPLATES,
- CAPABILITY_TYPES, ARTIFACT_TYPES, DATA_TYPES,
- INTERFACE_TYPES, POLICY_TYPES, GROUP_TYPES, REPOSITORIES
- };
-
// Sections that are specific to individual template definitions
private static final String METADATA = "metadata";
+ private static String SECTIONS[] = {
+ DEFINITION_VERSION, DEFAULT_NAMESPACE, TEMPLATE_NAME,
+ TOPOLOGY_TEMPLATE, TEMPLATE_AUTHOR, TEMPLATE_VERSION,
+ DESCRIPTION, IMPORTS, DSL_DEFINITIONS, NODE_TYPES,
+ RELATIONSHIP_TYPES, RELATIONSHIP_TEMPLATES,
+ CAPABILITY_TYPES, ARTIFACT_TYPES, DATA_TYPES,
+ INTERFACE_TYPES, POLICY_TYPES, GROUP_TYPES, REPOSITORIES
+ };
private static ArrayList<String> SPECIAL_SECTIONS;
private ExtTools exttools = new ExtTools();
VALID_TEMPLATE_VERSIONS = new ArrayList<>();
VALID_TEMPLATE_VERSIONS.add("tosca_simple_yaml_1_0");
VALID_TEMPLATE_VERSIONS.add("tosca_simple_yaml_1_1");
+ VALID_TEMPLATE_VERSIONS.add("tosca_simple_yaml_1_2");
+ VALID_TEMPLATE_VERSIONS.add("tosca_simple_yaml_1_3");
VALID_TEMPLATE_VERSIONS.addAll(exttools.getVersions());
ADDITIONAL_SECTIONS = new LinkedHashMap<>();
SPECIAL_SECTIONS = new ArrayList<>();
SPECIAL_SECTIONS.add(METADATA);
ADDITIONAL_SECTIONS.put("tosca_simple_yaml_1_0", SPECIAL_SECTIONS);
ADDITIONAL_SECTIONS.put("tosca_simple_yaml_1_1", SPECIAL_SECTIONS);
+ ADDITIONAL_SECTIONS.put("tosca_simple_yaml_1_2", SPECIAL_SECTIONS);
+ ADDITIONAL_SECTIONS.put("tosca_simple_yaml_1_3", SPECIAL_SECTIONS);
ADDITIONAL_SECTIONS.putAll(exttools.getSections());
- //long startTime = System.nanoTime();
-
-
isFile = aFile;
inputPath = null;
path = null;
if (path != null && !path.isEmpty()) {
try (InputStream input = new FileInputStream(new File(path));) {
//System.out.println("Loading YAML file " + path);
- log.debug("ToscaTemplate Loading YAMEL file {}", path);
+ log.debug("ToscaTemplate Loading YAML file {}", path);
Yaml yaml = new Yaml();
Object data = yaml.load(input);
this.tpl = (LinkedHashMap<String, Object>) data;
log.error("ToscaTemplate - Exception loading yaml: {}", e.getMessage());
log.error("Exception", e);
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE275",
- "ToscaTemplate - Exception loading yaml: -> " + e.getMessage()));
+ "ToscaTemplate - Exception loading yaml: -> " + e.getMessage()));
return;
} catch (Exception e) {
log.error("ToscaTemplate - Error loading yaml, aborting -> ", e.getMessage());
log.error("Exception", e);
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE275",
- "ToscaTemplate - Error loading yaml, aborting -> " + e.getMessage()));
+ "ToscaTemplate - Error loading yaml, aborting -> " + e.getMessage()));
return;
}
tpl = yamlDictTpl;
} else {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE244",
- "ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse"));
+ "ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse"));
log.debug("ToscaTemplate ValueError: No path or yaml_dict_tpl was provided. There is nothing to parse");
}
private TopologyTemplate _topologyTemplate() {
return new TopologyTemplate(
- _tplTopologyTemplate(),
- _getAllCustomDefs(imports),
- relationshipTypes,
- parsedParams,
- null,
- resolveGetInput);
+ _tplTopologyTemplate(),
+ _getAllCustomDefs(imports),
+ relationshipTypes,
+ parsedParams,
+ null,
+ resolveGetInput);
}
private ArrayList<Input> _inputs() {
@SuppressWarnings("unchecked")
private ArrayList<Repository> _tplRepositories() {
LinkedHashMap<String, Object> repositories =
- (LinkedHashMap<String, Object>) tpl.get(REPOSITORIES);
+ (LinkedHashMap<String, Object>) tpl.get(REPOSITORIES);
ArrayList<Repository> reposit = new ArrayList<>();
if (repositories != null) {
for (Map.Entry<String, Object> me : repositories.entrySet()) {
@SuppressWarnings("unchecked")
private HashSet<DataType> getTopologyDataTypes() {
LinkedHashMap<String, Object> value =
- (LinkedHashMap<String, Object>) tpl.get(DATA_TYPES);
+ (LinkedHashMap<String, Object>) tpl.get(DATA_TYPES);
HashSet<DataType> datatypes = new HashSet<>();
if (value != null) {
customDefsFinal.putAll(value);
}
}
-
return datatypes;
}
@SuppressWarnings("unchecked")
private LinkedHashMap<String, Object> _getAllCustomDefs(Object alImports) {
-
String types[] = {
- IMPORTS, NODE_TYPES, CAPABILITY_TYPES, RELATIONSHIP_TYPES,
- DATA_TYPES, INTERFACE_TYPES, POLICY_TYPES, GROUP_TYPES
+ IMPORTS, NODE_TYPES, CAPABILITY_TYPES, RELATIONSHIP_TYPES, ARTIFACT_TYPES,
+ DATA_TYPES, INTERFACE_TYPES, POLICY_TYPES, GROUP_TYPES
};
List<Map<String, Object>> imports = (List<Map<String, Object>>) alImports;
*/
private String getPath(String path, String importFileName) {
String tempFullPath = (Paths.get(path).toAbsolutePath().getParent()
- .toString() + File.separator + importFileName.replace("../", "")).replace('\\', '/');
+ .toString() + File.separator + importFileName.replace("../", "")).replace('\\', '/');
String tempPartialPath = (Paths.get(path).toAbsolutePath().getParent().toString()).replace('\\', '/');
- if (Files.exists(Paths.get(tempFullPath)))
+ if (Files.exists(Paths.get(tempFullPath))) {
return tempFullPath;
- else
+ } else {
return getPath(tempPartialPath, importFileName);
+ }
}
/**
Map.Entry<String, String> val = it.next();
if (val.getValue().contains("/")) {
importFileName = (Paths.get(rootPath).toAbsolutePath().getParent().toString() + File
- .separator + val.getValue().replace("../", "")).replace('\\', '/');
+ .separator + val.getValue().replace("../", "")).replace('\\', '/');
} else {
importFileName = (Paths.get(path).toAbsolutePath().getParent().toString() + File
- .separator + val.getValue().replace("../", "")).replace('\\', '/');
+ .separator + val.getValue().replace("../", "")).replace('\\', '/');
}
retMap.put("importFileName", importFileName);
retMap.put("importRelativeName", val.getValue());
* @return the list containing filtered imports
*/
private List<Map<String, Object>> filterImportsForRecursion(List<Map<String, Object>>
- customImports, Map<String,
- String> importNameDetails) {
+ customImports, Map<String,
+ String> importNameDetails) {
for (Map<String, Object> map1 : customImports) {
for (Map.Entry<String, Object> entry : map1.entrySet()) {
Map innerMostMap = (Map) entry.getValue();
this.processedImports = new HashSet<>();
for (Map.Entry<String, Object> me : nestedToscaTplsWithTopology.entrySet()) {
LinkedHashMap<String, Object> toscaTpl =
- (LinkedHashMap<String, Object>) me.getValue();
+ (LinkedHashMap<String, Object>) me.getValue();
for (NodeTemplate nt : tt.getNodeTemplates()) {
if (_isSubMappedNode(nt, toscaTpl)) {
parsedParams = _getParamsForNestedTemplate(nt);
ArrayList<Object> alim = (ArrayList<Object>) toscaTpl.get(IMPORTS);
LinkedHashMap<String, Object> topologyTpl =
- (LinkedHashMap<String, Object>) toscaTpl.get(TOPOLOGY_TEMPLATE);
+ (LinkedHashMap<String, Object>) toscaTpl.get(TOPOLOGY_TEMPLATE);
TopologyTemplate topologyWithSubMapping =
- new TopologyTemplate(topologyTpl,
- _getAllCustomDefs(alim),
- relationshipTypes,
- parsedParams,
- nt,
- resolveGetInput);
+ new TopologyTemplate(topologyTpl,
+ _getAllCustomDefs(alim),
+ relationshipTypes,
+ parsedParams,
+ nt,
+ resolveGetInput);
nt.setOriginComponentTemplate(topologyWithSubMapping);
if (topologyWithSubMapping.getSubstitutionMappings() != null) {
// Record nested topology templates in top level template
//nestedToscaTemplatesWithTopology.add(topologyWithSubMapping);
// Set substitution mapping object for mapped node
nt.setSubMappingToscaTemplate(
- topologyWithSubMapping.getSubstitutionMappings());
+ topologyWithSubMapping.getSubstitutionMappings());
_handleNestedToscaTemplatesWithTopology(topologyWithSubMapping);
}
}
String sVersion = _tplVersion();
if (sVersion == null) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE245", String.format(
- "MissingRequiredField: Template is missing required field \"%s\"", DEFINITION_VERSION)));
+ "MissingRequiredField: Template is missing required field \"%s\"", DEFINITION_VERSION)));
} else {
_validateVersion(sVersion);
this.version = sVersion;
// check ADDITIONAL_SECTIONS
if (!bFound) {
if (ADDITIONAL_SECTIONS.get(version) != null &&
- ADDITIONAL_SECTIONS.get(version).contains(sKey)) {
+ ADDITIONAL_SECTIONS.get(version).contains(sKey)) {
bFound = true;
}
}
if (!bFound) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE246", String.format(
- "UnknownFieldError: Template contains unknown field \"%s\"",
- sKey)));
+ "UnknownFieldError: Template contains unknown field \"%s\"",
+ sKey)));
}
}
}
}
if (!bFound) {
ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE247", String.format(
- "InvalidTemplateVersion: \"%s\" is invalid. Valid versions are %s",
- sVersion, VALID_TEMPLATE_VERSIONS.toString())));
- } else if ((!sVersion.equals("tosca_simple_yaml_1_0") && !sVersion.equals("tosca_simple_yaml_1_1"))) {
+ "InvalidTemplateVersion: \"%s\" is invalid. Valid versions are %s", sVersion, VALID_TEMPLATE_VERSIONS.toString())));
+ } else if (!sVersion.startsWith("tosca_simple_yaml_1_")) {
EntityType.updateDefinitions(sVersion);
-
}
}
return csar.getTempDir() + File.separator + csar.getMainTemplate();
}
} else {
- ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE248", "ValueError: " + _path + " is not a valid file"));
+ ThreadLocalsHolder.getCollector()
+ .appendValidationIssue(new JToscaValidationIssue("JE248", "ValueError: " + _path + " is not a valid file"));
return null;
}
return null;
if (validationIssuesCaught > 0) {
List<String> validationIssueStrings = ThreadLocalsHolder.getCollector().getValidationIssueReport();
log.trace("####################################################################################################");
- log.trace("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", validationIssuesCaught, (validationIssuesCaught > 1 ? "s" : ""));
+ log.trace("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", validationIssuesCaught,
+ (validationIssuesCaught > 1 ? "s" : ""));
for (String s : validationIssueStrings) {
log.trace("{}. CSAR name - {}", s, inputPath);
}
private boolean _isSubMappedNode(NodeTemplate nt, LinkedHashMap<String, Object> toscaTpl) {
// Return True if the nodetemple is substituted
if (nt != null && nt.getSubMappingToscaTemplate() == null &&
- getSubMappingNodeType(toscaTpl).equals(nt.getType()) &&
- nt.getInterfaces().size() < 1) {
+ getSubMappingNodeType(toscaTpl).equals(nt.getType()) &&
+ nt.getInterfaces().size() < 1) {
return true;
}
return false;
// Return substitution mappings node type
if (toscaTpl != null) {
return TopologyTemplate.getSubMappingNodeType(
- (LinkedHashMap<String, Object>) toscaTpl.get(TOPOLOGY_TEMPLATE));
+ (LinkedHashMap<String, Object>) toscaTpl.get(TOPOLOGY_TEMPLATE));
}
return null;
}
public boolean hasNestedTemplates() {
// Return True if the tosca template has nested templates
return nestedToscaTemplatesWithTopology != null &&
- nestedToscaTemplatesWithTopology.size() >= 1;
+ nestedToscaTemplatesWithTopology.size() >= 1;
}
@Override
public String toString() {
return "ToscaTemplate{" +
- "exttools=" + exttools +
- ", VALID_TEMPLATE_VERSIONS=" + VALID_TEMPLATE_VERSIONS +
- ", ADDITIONAL_SECTIONS=" + ADDITIONAL_SECTIONS +
- ", isFile=" + isFile +
- ", path='" + path + '\'' +
- ", inputPath='" + inputPath + '\'' +
- ", parsedParams=" + parsedParams +
- ", tpl=" + tpl +
- ", version='" + version + '\'' +
- ", imports=" + imports +
- ", relationshipTypes=" + relationshipTypes +
- ", metaData=" + metaData +
- ", description='" + description + '\'' +
- ", topologyTemplate=" + topologyTemplate +
- ", repositories=" + repositories +
- ", inputs=" + inputs +
- ", relationshipTemplates=" + relationshipTemplates +
- ", nodeTemplates=" + nodeTemplates +
- ", outputs=" + outputs +
- ", policies=" + policies +
- ", nestedToscaTplsWithTopology=" + nestedToscaTplsWithTopology +
- ", nestedToscaTemplatesWithTopology=" + nestedToscaTemplatesWithTopology +
- ", graph=" + graph +
- ", csarTempDir='" + csarTempDir + '\'' +
- ", nestingLoopCounter=" + nestingLoopCounter +
- ", dataTypes=" + dataTypes +
- '}';
+ "exttools=" + exttools +
+ ", VALID_TEMPLATE_VERSIONS=" + VALID_TEMPLATE_VERSIONS +
+ ", ADDITIONAL_SECTIONS=" + ADDITIONAL_SECTIONS +
+ ", isFile=" + isFile +
+ ", path='" + path + '\'' +
+ ", inputPath='" + inputPath + '\'' +
+ ", parsedParams=" + parsedParams +
+ ", tpl=" + tpl +
+ ", version='" + version + '\'' +
+ ", imports=" + imports +
+ ", relationshipTypes=" + relationshipTypes +
+ ", metaData=" + metaData +
+ ", description='" + description + '\'' +
+ ", topologyTemplate=" + topologyTemplate +
+ ", repositories=" + repositories +
+ ", inputs=" + inputs +
+ ", relationshipTemplates=" + relationshipTemplates +
+ ", nodeTemplates=" + nodeTemplates +
+ ", outputs=" + outputs +
+ ", policies=" + policies +
+ ", nestedToscaTplsWithTopology=" + nestedToscaTplsWithTopology +
+ ", nestedToscaTemplatesWithTopology=" + nestedToscaTemplatesWithTopology +
+ ", graph=" + graph +
+ ", csarTempDir='" + csarTempDir + '\'' +
+ ", nestingLoopCounter=" + nestingLoopCounter +
+ ", dataTypes=" + dataTypes +
+ '}';
}
public List<Input> getInputs(boolean annotationsRequired) {
--- /dev/null
+/*
+ * -
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2022 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.sdc.toscaparser.api.elements;
+
+import java.util.Map;
+import lombok.Getter;
+import lombok.NonNull;
+
+@Getter
+public class ArtifactDef {
+
+ @NonNull
+ private final String type;
+ @NonNull
+ private final String file;
+ private final String repository;
+ private final String description;
+ private final String deploy_path;
+ private final String artifact_version;
+ private final String checksum;
+ private final String checksum_algorithm;
+ private final Map<String, Object> properties;
+
+ public ArtifactDef(final Map<String, Object> mapDef) {
+ type = (String) mapDef.get("type");
+ file = (String) mapDef.get("file");
+ repository = (String) mapDef.get("repository");
+ description = (String) mapDef.get("description");
+ deploy_path = (String) mapDef.get("deploy_path");
+ artifact_version = (String) mapDef.get("artifact_version");
+ checksum = (String) mapDef.get("checksum");
+ checksum_algorithm = (String) mapDef.get("checksum_algorithm");
+ properties = (Map<String, Object>) mapDef.get("properties");
+ }
+
+}
package org.onap.sdc.toscaparser.api.elements;
import java.util.LinkedHashMap;
+import lombok.Getter;
+@Getter
public class ArtifactTypeDef extends StatefulEntityType {
private String type;
private LinkedHashMap<String, Object> properties;
private LinkedHashMap<String, Object> parentArtifacts;
-
public ArtifactTypeDef(String type, LinkedHashMap<String, Object> customDef) {
super(type, ARTIFACT_PREFIX, customDef);
return null;
}
- public String getType() {
- return type;
- }
-
}
-
-/*python
-class ArtifactTypeDef(StatefulEntityType):
- '''TOSCA built-in artifacts type.'''
-
- def __init__(self, atype, custom_def=None):
- super(ArtifactTypeDef, self).__init__(atype, self.ARTIFACT_PREFIX,
- custom_def)
- self.type = atype
- self.custom_def = custom_def
- self.properties = None
- if self.PROPERTIES in self.defs:
- self.properties = self.defs[self.PROPERTIES]
- self.parent_artifacts = self._get_parent_artifacts()
-
- def _get_parent_artifacts(self):
- artifacts = {}
- parent_artif = self.parent_type.type if self.parent_type else None
- if parent_artif:
- while parent_artif != 'tosca.artifacts.Root':
- artifacts[parent_artif] = self.TOSCA_DEF[parent_artif]
- parent_artif = artifacts[parent_artif]['derived_from']
- return artifacts
-
- @property
- def parent_type(self):
- '''Return a artifact entity from which this entity is derived.'''
- if not hasattr(self, 'defs'):
- return None
- partifact_entity = self.derived_from(self.defs)
- if partifact_entity:
- return ArtifactTypeDef(partifact_entity, self.custom_def)
-
- def get_artifact(self, name):
- '''Return the definition of an artifact field by name.'''
- if name in self.defs:
- return self.defs[name]
-*/
ArrayList<String> vtv = new ArrayList<>();
vtv.add("tosca_simple_yaml_1_0");
vtv.add("tosca_simple_yaml_1_1");
+ vtv.add("tosca_simple_yaml_1_2");
+ vtv.add("tosca_simple_yaml_1_3");
ExtTools exttools = new ExtTools();
vtv.addAll(exttools.getVersions());
return vtv;
import org.onap.sdc.toscaparser.api.*;
import org.onap.sdc.toscaparser.api.parameters.Input;
-import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
List<NodeTemplate> children =((NodeTemplate) ((NodeTemplateEntityDetails)member).getEntityTemplate())
.getSubMappingToscaTemplate().getNodeTemplates();
List<NodeTemplate> vfcChildren = children.stream()
- .filter(c -> SdcTypes.VFC.getValue().equals(c.getMetaData().getValue(TYPE)))
+ .filter(c -> SdcTypes.VFC.getValue().equals(c.getMetadata().getValue(TYPE)))
.collect(toList());
return !vfcChildren.isEmpty();
}
@Override
public Metadata getMetadata() {
- return nodeTemplate.getMetaData();
+ return nodeTemplate.getMetadata();
}
@Override
private Stream<NodeTemplate> filter(final List<NodeTemplate> nodeTemplateList) {
return nodeTemplateList.stream()
- .filter(nt -> isSearchCriteriaMatched(nt.getMetaData(), nt.getType()))
+ .filter(nt -> isSearchCriteriaMatched(nt.getMetadata(), nt.getType()))
.filter(nt -> getNodeTemplateType() == null ||
- isStringMatchingOrNull(nt.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE),
+ isStringMatchingOrNull(nt.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE),
getNodeTemplateType().getValue()));
}
}
public Boolean isMatchingSearchCriteria(NodeTemplate nodeTemplate) {
- boolean isMatched = Objects.nonNull(nodeTemplate.getMetaData()) && isSearchedTemplate(nodeTemplate.getMetaData());
+ boolean isMatched = Objects.nonNull(nodeTemplate.getMetadata()) && isSearchedTemplate(nodeTemplate.getMetadata());
if(logger.isDebugEnabled()) {
logger.debug("Node template {} is{} matching search criteria", nodeTemplate.getName(), isMatched ? "" : " not");
}
final List<NodeTemplate> topologyTemplateList = Collections.emptyList();
boolean isTopologyTemplateFound = isRecursive ?
- SdcTypes.isComplex(current.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))
+ SdcTypes.isComplex(current.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))
: topologyTemplateQuery.isMatchingSearchCriteria(current);
if (isTopologyTemplateFound) {
topologyTemplateList.add(current);
return topologyTemplateList;
}
}
- if (SdcTypes.isComplex(current.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)) &&
+ if (SdcTypes.isComplex(current.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)) &&
current.getSubMappingToscaTemplate() != null) {
//search the node template inside a given topology template
topologyTemplateList.addAll(current.getSubMappingToscaTemplate().getNodeTemplates()
* 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.
package org.onap.sdc.tosca.parser.impl;
-import java.util.List;
+import static java.util.stream.Collectors.toList;
+
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Map;
-import java.util.Map.Entry;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
-import java.util.Optional;
-import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Optional;
import java.util.stream.Collectors;
-import static java.util.stream.Collectors.toList;
-
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
private static final String PATH_DELIMITER = "#";
private static final String CUSTOMIZATION_UUID = "customizationUUID";
private static final String GROUPS_VF_MODULE = "org.openecomp.groups.VfModule";
+ private static final Logger log = LoggerFactory.getLogger(SdcCsarHelperImpl.class.getName());
private ToscaTemplate toscaTemplate;
private ConfigurationManager configurationManager;
- private static Logger log = LoggerFactory.getLogger(SdcCsarHelperImpl.class.getName());
public SdcCsarHelperImpl(ToscaTemplate toscaTemplate) {
this.toscaTemplate = toscaTemplate;
this.toscaTemplate = toscaTemplate;
this.configurationManager = configurationManager;
}
-
+
@Override
public List<Policy> getPoliciesOfTarget(NodeTemplate nodeTemplate) {
- return getPoliciesOfNodeTemplate(nodeTemplate.getName())
- .stream()
- .sorted(Policy::compareTo)
- .collect(toList());
+ return getPoliciesOfNodeTemplate(nodeTemplate.getName())
+ .stream()
+ .sorted(Policy::compareTo)
+ .collect(toList());
}
-
+
@Override
-
public List<Policy> getPoliciesOfOriginOfNodeTemplate(NodeTemplate nodeTemplate) {
- if(StringUtils.isNotEmpty(nodeTemplate.getName())){
- return getNodeTemplateByName(nodeTemplate.getName()).getOriginComponentTemplate().getPolicies();
- }
- return new ArrayList<>();
+ public List<Policy> getPoliciesOfOriginOfNodeTemplate(NodeTemplate nodeTemplate) {
+ if (StringUtils.isNotEmpty(nodeTemplate.getName())) {
+ return getNodeTemplateByName(nodeTemplate.getName()).getOriginComponentTemplate().getPolicies();
+ }
+ return new ArrayList<>();
}
-
+
@Override
public List<Policy> getPoliciesOfTargetByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName) {
- return getPoliciesOfNodeTemplate(nodeTemplate.getName())
- .stream()
- .filter(p->p.getType().equals(policyTypeName))
- .sorted(Policy::compareTo)
- .collect(toList());
+ return getPoliciesOfNodeTemplate(nodeTemplate.getName())
+ .stream()
+ .filter(p -> p.getType().equals(policyTypeName))
+ .sorted(Policy::compareTo)
+ .collect(toList());
}
-
+
@Override
public List<Policy> getPoliciesOfOriginOfNodeTemplateByToscaPolicyType(NodeTemplate nodeTemplate, String policyTypeName) {
- return getPoliciesOfOriginOfNodeTemplate(nodeTemplate)
- .stream()
- .filter(p->p.getType().equals(policyTypeName))
- .sorted(Policy::compareTo)
- .collect(toList());
+ return getPoliciesOfOriginOfNodeTemplate(nodeTemplate)
+ .stream()
+ .filter(p -> p.getType().equals(policyTypeName))
+ .sorted(Policy::compareTo)
+ .collect(toList());
}
@Override
public List<NodeTemplate> getPolicyTargetsFromTopologyTemplate(String policyName) {
- if(toscaTemplate.getNodeTemplates() == null){
- return new ArrayList<>();
- }
- List<String> targetNames = getPolicyTargets(policyName);
- return toscaTemplate.getNodeTemplates().stream()
- .filter(nt->targetNames.contains(nt.getName()))
- .collect(toList());
- }
-
- @Override
- public List<NodeTemplate> getPolicyTargetsFromOrigin(NodeTemplate nodeTemplate, String policyName) {
- if(StringUtils.isNotEmpty(nodeTemplate.getName())){
+ if (toscaTemplate.getNodeTemplates() == null) {
+ return new ArrayList<>();
+ }
+ List<String> targetNames = getPolicyTargets(policyName);
+ return toscaTemplate.getNodeTemplates().stream()
+ .filter(nt -> targetNames.contains(nt.getName()))
+ .collect(toList());
+ }
+
+ @Override
+ public List<NodeTemplate> getPolicyTargetsFromOrigin(NodeTemplate nodeTemplate, String policyName) {
+ if (StringUtils.isNotEmpty(nodeTemplate.getName())) {
Optional<Policy> policyOpt = getNodeTemplateByName(nodeTemplate.getName())
- .getOriginComponentTemplate()
- .getPolicies()
- .stream()
- .filter(p -> p.getName()
- .equals(policyName))
- .findFirst();
- if(policyOpt.isPresent()){
+ .getOriginComponentTemplate()
+ .getPolicies()
+ .stream()
+ .filter(p -> p.getName()
+ .equals(policyName))
+ .findFirst();
+ if (policyOpt.isPresent()) {
List<String> targets = policyOpt.get().getTargets();
if (targets != null) {
return nodeTemplate.getOriginComponentTemplate().getNodeTemplates()
- .stream()
- .filter(nt -> targets.contains(nt.getName())).collect(Collectors.toList());
+ .stream()
+ .filter(nt -> targets.contains(nt.getName())).collect(Collectors.toList());
}
}
- }
- return new ArrayList<>();
- }
-
- @Override
- public List<Policy> getPoliciesOfTopologyTemplate(){
- if(toscaTemplate.getPolicies() == null)
- return new ArrayList<>();
- return toscaTemplate.getPolicies()
- .stream()
- .sorted(Policy::compareTo)
- .collect(toList());
- }
-
- @Override
- public List<Policy> getPoliciesOfTopologyTemplateByToscaPolicyType(String policyTypeName){
- if(toscaTemplate.getPolicies() == null)
- return new ArrayList<>();
- return toscaTemplate.getPolicies()
- .stream()
- .filter(p->p.getType().equals(policyTypeName))
- .sorted(Policy::compareTo)
- .collect(toList());
- }
-
+ }
+ return new ArrayList<>();
+ }
+
+ @Override
+ public List<Policy> getPoliciesOfTopologyTemplate() {
+ if (toscaTemplate.getPolicies() == null) {
+ return new ArrayList<>();
+ }
+ return toscaTemplate.getPolicies()
+ .stream()
+ .sorted(Policy::compareTo)
+ .collect(toList());
+ }
+
+ @Override
+ public List<Policy> getPoliciesOfTopologyTemplateByToscaPolicyType(String policyTypeName) {
+ if (toscaTemplate.getPolicies() == null) {
+ return new ArrayList<>();
+ }
+ return toscaTemplate.getPolicies()
+ .stream()
+ .filter(p -> p.getType().equals(policyTypeName))
+ .sorted(Policy::compareTo)
+ .collect(toList());
+ }
+
+ @Override
public NodeTemplate getNodeTemplateByName(String nodeTemplateName) {
- if(toscaTemplate.getNodeTemplates() == null)
- return null;
- return toscaTemplate.getNodeTemplates()
- .stream()
- .filter(nt -> nt.getName().equals(nodeTemplateName))
- .findFirst().orElse(null);
- }
-
+ if (toscaTemplate.getNodeTemplates() == null) {
+ return null;
+ }
+ return toscaTemplate.getNodeTemplates()
+ .stream()
+ .filter(nt -> nt.getName().equals(nodeTemplateName))
+ .findFirst().orElse(null);
+ }
+
private List<Policy> getPoliciesOfNodeTemplate(String nodeTemplateName) {
- if(toscaTemplate.getPolicies() == null)
- return new ArrayList<>();
- return toscaTemplate.getPolicies()
- .stream()
- .filter(p -> p.getTargets()!= null && p.getTargets().contains(nodeTemplateName))
- .collect(toList());
- }
-
+ if (toscaTemplate.getPolicies() == null) {
+ return new ArrayList<>();
+ }
+ return toscaTemplate.getPolicies()
+ .stream()
+ .filter(p -> p.getTargets() != null && p.getTargets().contains(nodeTemplateName))
+ .collect(toList());
+ }
+
private List<String> getPolicyTargets(String policyName) {
- return getPolicyByName(policyName).map(Policy::getTargets).orElse(new ArrayList<>());
+ return getPolicyByName(policyName).map(Policy::getTargets).orElse(new ArrayList<>());
}
-
+
private List<String> getGroupMembers(String groupName) {
- return getGroupByName(groupName).map(Group::getMembers).orElse(new ArrayList<>());
+ return getGroupByName(groupName).map(Group::getMembers).orElse(new ArrayList<>());
}
-
+
private Optional<Policy> getPolicyByName(String policyName) {
- if(toscaTemplate.getPolicies() == null)
- return Optional.empty();
- return toscaTemplate.getPolicies()
- .stream()
- .filter(p -> p.getName().equals(policyName)).findFirst();
+ if (toscaTemplate.getPolicies() == null) {
+ return Optional.empty();
+ }
+ return toscaTemplate.getPolicies()
+ .stream()
+ .filter(p -> p.getName().equals(policyName)).findFirst();
}
-
+
private Optional<Group> getGroupByName(String groupName) {
- if(toscaTemplate.getGroups() == null)
- return Optional.empty();
- return toscaTemplate.getGroups()
- .stream()
- .filter(g -> g.getName().equals(groupName)).findFirst();
+ if (toscaTemplate.getGroups() == null) {
+ return Optional.empty();
+ }
+ return toscaTemplate.getGroups()
+ .stream()
+ .filter(g -> g.getName().equals(groupName)).findFirst();
}
-
+
@Override
//Sunny flow - covered with UT, flat and nested
public String getNodeTemplatePropertyLeafValue(NodeTemplate nodeTemplate, String leafValuePath) {
LinkedHashMap<String, Property> properties = nodeTemplate.getProperties();
return PropertyUtils.processProperties(split, properties);
}
-
+
+ @Override
public Map<String, Map<String, Object>> getCpPropertiesFromVfcAsObject(NodeTemplate vfc) {
if (vfc == null) {
log.error("getCpPropertiesFromVfc - vfc is null");
return cps;
}
- private void findPutAllPortsProperties(Map<String, Map<String, Object>> cps, Map<String, Property> props) {
- if (!cps.isEmpty()) {
- for (Entry<String, Map<String, Object>> port : cps.entrySet()) {
- for (Map.Entry<String, Property> property: props.entrySet()) {
- if (property.getKey().startsWith(port.getKey())) {
- String portProperty = property.getKey().replaceFirst(port.getKey() + "_", "");
- if (property.getValue() != null) {
- cps.get(port.getKey()).put(portProperty, property.getValue().getValue());
- }
- }
- }
- }
- }
- }
+ private void findPutAllPortsProperties(Map<String, Map<String, Object>> cps, Map<String, Property> props) {
+ if (!cps.isEmpty()) {
+ for (Entry<String, Map<String, Object>> port : cps.entrySet()) {
+ for (Map.Entry<String, Property> property : props.entrySet()) {
+ if (property.getKey().startsWith(port.getKey())) {
+ String portProperty = property.getKey().replaceFirst(port.getKey() + "_", "");
+ if (property.getValue() != null) {
+ cps.get(port.getKey()).put(portProperty, property.getValue().getValue());
+ }
+ }
+ }
+ }
+ }
+ }
+ @Override
public Map<String, Map<String, Object>> getCpPropertiesFromVfc(NodeTemplate vfc) {
if (vfc == null) {
return cps;
}
- private void findBuildPutAllPortsProperties(Map<String, Map<String, Object>> cps, Map<String, Property> props) {
- if (!cps.isEmpty()) {
- for (Entry<String, Map<String, Object>> port : cps.entrySet()) {
- for (Map.Entry<String, Property> property: props.entrySet()) {
- if (property.getKey().startsWith(port.getKey())) {
- Map<String, Object> portPaths = new HashMap<>();
- String portProperty = property.getKey().replaceFirst(port.getKey() + "_", "");
- buildPathMappedToValue(portProperty, property.getValue().getValue(), portPaths);
- cps.get(port.getKey()).putAll(portPaths);
- }
- }
- }
- }
- }
+ private void findBuildPutAllPortsProperties(Map<String, Map<String, Object>> cps, Map<String, Property> props) {
+ if (!cps.isEmpty()) {
+ for (Entry<String, Map<String, Object>> port : cps.entrySet()) {
+ for (Map.Entry<String, Property> property : props.entrySet()) {
+ if (property.getKey().startsWith(port.getKey())) {
+ Map<String, Object> portPaths = new HashMap<>();
+ String portProperty = property.getKey().replaceFirst(port.getKey() + "_", "");
+ buildPathMappedToValue(portProperty, property.getValue().getValue(), portPaths);
+ cps.get(port.getKey()).putAll(portPaths);
+ }
+ }
+ }
+ }
+ }
@SuppressWarnings("unchecked")
private void buildPathMappedToValue(String path, Object property, Map<String, Object> pathsMap) {
}
}
} else if (property instanceof List) {
- for (Object item: (List<Object>)property) {
+ for (Object item : (List<Object>) property) {
buildPathMappedToValue(path, item, pathsMap);
}
} else {
return metadata.getValue(metadataPropertyName);
}
-
@Override
//Sunny flow - covered with UT
public List<NodeTemplate> getServiceNodeTemplatesByType(String nodeType) {
return res;
}
-
@Override
public List<NodeTemplate> getServiceNodeTemplates() {
return toscaTemplate.getNodeTemplates();
String name = nodeTemplateByCustomizationUuid.getName();
String normaliseComponentInstanceName = SdcToscaUtility.normaliseComponentInstanceName(name);
List<Group> serviceLevelGroups = toscaTemplate.getTopologyTemplate().getGroups();
- log.debug("getVfModulesByVf - VF node template name {}, normalized name {}. Searching groups on service level starting with VF normalized name...", name, normaliseComponentInstanceName);
+ log.debug(
+ "getVfModulesByVf - VF node template name {}, normalized name {}. Searching groups on service level starting with VF normalized name...",
+ name, normaliseComponentInstanceName);
if (serviceLevelGroups != null) {
return serviceLevelGroups
- .stream()
- .filter(x -> GROUPS_VF_MODULE.equals(x.getTypeDefinition().getType()) && x.getName().startsWith(normaliseComponentInstanceName))
- .collect(toList());
+ .stream()
+ .filter(x -> GROUPS_VF_MODULE.equals(x.getTypeDefinition().getType()) && x.getName().startsWith(normaliseComponentInstanceName))
+ .collect(toList());
}
}
return new ArrayList<>();
Input input = findFirst.get();
Object current = input.getDefault();
Object property = PropertyUtils.iterateProcessPath(2, current, split);
- return property == null || property instanceof Function? null : String.valueOf(property);
+ return property == null || property instanceof Function ? null : String.valueOf(property);
}
}
log.error("getServiceInputLeafValue - value not found");
String[] split = getSplittedPath(inputLeafValuePath);
if (split.length < 2 || !split[1].equals("default")) {
- log.error("getServiceInputLeafValueOfDefaultAsObject - inputLeafValuePath should be of format <input name>#default[optionally #<rest of path>] ");
+ log.error(
+ "getServiceInputLeafValueOfDefaultAsObject - inputLeafValuePath should be of format <input name>#default[optionally #<rest of path>] ");
return null;
}
return leafValuePath.split(PATH_DELIMITER);
}
-
@Override
//Sunny flow - covered with UT
public String getServiceSubstitutionMappingsTypeName() {
@Override
//Sunny flow - covered with UT
public Map<String, Object> getServiceMetadataProperties() {
- if (toscaTemplate.getMetaData() == null){
+ if (toscaTemplate.getMetaData() == null) {
return null;
}
return new HashMap<>(toscaTemplate.getMetaData().getAllProperties());
@Override
public Map<String, String> getServiceMetadataAllProperties() {
- if (toscaTemplate.getMetaData() == null){
+ if (toscaTemplate.getMetaData() == null) {
return null;
}
return toscaTemplate.getMetaData().getAllProperties();
String[] split = getSplittedPath(leafValuePath);
LinkedHashMap<String, Property> properties = group.getProperties();
Object property = PropertyUtils.processProperties(split, properties);
- return property == null || property instanceof Function? null : String.valueOf(property);
+ return property == null || property instanceof Function ? null : String.valueOf(property);
}
@Override
return cpList;
}
cpList = getNodeTemplateBySdcType(vfInstance, SdcTypes.CP);
- if (cpList == null || cpList.isEmpty())
+ if (cpList == null || cpList.isEmpty()) {
log.debug("getCpListByVf cps not exist for vfCustomizationId {}", vfCustomizationId);
+ }
return cpList;
}
return new ArrayList<>();
}
- if (serviceLevelVfModule == null || serviceLevelVfModule.getMetadata() == null || serviceLevelVfModule.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID) == null) {
- log.error("getMembersOfVfModule - vfModule or its metadata is null. Cannot match a VF group based on invariantUuid from missing metadata.");
+ if (serviceLevelVfModule == null || serviceLevelVfModule.getMetadata() == null
+ || serviceLevelVfModule.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID) == null) {
+ log.error(
+ "getMembersOfVfModule - vfModule or its metadata is null. Cannot match a VF group based on invariantUuid from missing metadata.");
return new ArrayList<>();
}
-
SubstitutionMappings substitutionMappings = vf.getSubMappingToscaTemplate();
if (substitutionMappings != null) {
List<Group> groups = substitutionMappings.getGroups();
if (groups != null) {
Optional<Group> findFirst = groups
- .stream()
- .filter(x -> (x.getMetadata() != null && serviceLevelVfModule.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID).equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)))).findFirst();
+ .stream()
+ .filter(x -> (x.getMetadata() != null && serviceLevelVfModule.getMetadata()
+ .getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)
+ .equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)))).findFirst();
if (findFirst.isPresent()) {
List<String> members = findFirst.get().getMembers();
if (members != null) {
@Override
public List<Pair<NodeTemplate, NodeTemplate>> getNodeTemplatePairsByReqName(
- List<NodeTemplate> listOfReqNodeTemplates, List<NodeTemplate> listOfCapNodeTemplates, String reqName) {
+ List<NodeTemplate> listOfReqNodeTemplates, List<NodeTemplate> listOfCapNodeTemplates, String reqName) {
if (listOfReqNodeTemplates == null) {
log.error("getNodeTemplatePairsByReqName - listOfReqNodeTemplates is null");
log.error("getAllottedResources nodeTemplates not exist");
}
nodeTemplates = nodeTemplates.stream().filter(
- x -> x.getMetaData() != null && x.getMetaData().getValue("category").equals("Allotted Resource"))
- .collect(toList());
+ x -> x.getMetadata() != null && x.getMetadata().getValue("category").equals("Allotted Resource"))
+ .collect(toList());
if (nodeTemplates.isEmpty()) {
log.debug("getAllottedResources - allotted resources not exist");
}
*/
@Override
public String getConformanceLevel() {
- LinkedHashMap<String, Object> csarMeta = toscaTemplate.getMetaProperties("csar.meta");
- if (csarMeta == null){
- log.warn("No csar.meta file is found in CSAR - this file should hold the conformance level of the CSAR. This might be OK for older CSARs.");
- if (configurationManager != null && !configurationManager.getErrorConfiguration()
- .getErrorInfo("CONFORMANCE_LEVEL_ERROR").getFailOnError()){
- String csarConLevel = configurationManager.getConfiguration().getConformanceLevel().getMaxVersion();
- log.warn("csarConformanceLevel is not found in input csar; defaulting to max version {}" , csarConLevel);
- return csarConLevel;
- }
- else {
- log.warn("csarConformanceLevel is not found in input csar; returning null as no defaults defined in error configuration");
- return null;
- }
- }
-
- Object conformanceLevel = csarMeta.get("SDC-TOSCA-Definitions-Version");
- if (conformanceLevel != null){
- String confLevelStr = conformanceLevel.toString();
- log.debug("CSAR conformance level is {}", confLevelStr);
- return confLevelStr;
- } else {
- log.error("Invalid csar.meta file - no entry found for SDC-TOSCA-Definitions-Version key. This entry should hold the conformance level.");
- return null;
- }
- }
-
-
- @Override
- public String getNodeTemplateCustomizationUuid(NodeTemplate nt) {
- String res = null;
- if (nt != null && nt.getMetaData() != null){
- res = nt.getMetaData().getValue(CUSTOMIZATION_UUID);
- } else {
- log.error("Node template or its metadata is null");
- }
- return res;
- }
+ LinkedHashMap<String, Object> csarMeta = toscaTemplate.getMetaProperties("csar.meta");
+ if (csarMeta == null) {
+ log.warn(
+ "No csar.meta file is found in CSAR - this file should hold the conformance level of the CSAR. This might be OK for older CSARs.");
+ if (configurationManager != null && !configurationManager.getErrorConfiguration()
+ .getErrorInfo("CONFORMANCE_LEVEL_ERROR").getFailOnError()) {
+ String csarConLevel = configurationManager.getConfiguration().getConformanceLevel().getMaxVersion();
+ log.warn("csarConformanceLevel is not found in input csar; defaulting to max version {}", csarConLevel);
+ return csarConLevel;
+ } else {
+ log.warn("csarConformanceLevel is not found in input csar; returning null as no defaults defined in error configuration");
+ return null;
+ }
+ }
+ Object conformanceLevel = csarMeta.get("SDC-TOSCA-Definitions-Version");
+ if (conformanceLevel != null) {
+ String confLevelStr = conformanceLevel.toString();
+ log.debug("CSAR conformance level is {}", confLevelStr);
+ return confLevelStr;
+ } else {
+ log.error("Invalid csar.meta file - no entry found for SDC-TOSCA-Definitions-Version key. This entry should hold the conformance level.");
+ return null;
+ }
+ }
+
+
+ @Override
+ public String getNodeTemplateCustomizationUuid(NodeTemplate nt) {
+ String res = null;
+ if (nt != null && nt.getMetadata() != null) {
+ res = nt.getMetadata().getValue(CUSTOMIZATION_UUID);
+ } else {
+ log.error("Node template or its metadata is null");
+ }
+ return res;
+ }
+
+ @Override
public List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType) {
- return getNodeTemplateBySdcType(parentNodeTemplate, sdcType, false);
+ return getNodeTemplateBySdcType(parentNodeTemplate, sdcType, false);
}
+ @Override
public boolean isNodeTypeSupported(NodeTemplate nodeTemplate) {
SdcTypes[] supportedTypes = SdcTypes.values();
return Arrays.stream(supportedTypes)
- .anyMatch(v->nodeTemplate.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)
- .equals(v.getValue()));
+ .anyMatch(v -> nodeTemplate.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)
+ .equals(v.getValue()));
}
-
- private List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType, boolean isVNF) {
-
- if (parentNodeTemplate == null) {
+
+ private List<NodeTemplate> getNodeTemplateBySdcType(NodeTemplate parentNodeTemplate, SdcTypes sdcType, boolean isVNF) {
+
+ if (parentNodeTemplate == null) {
log.error("getNodeTemplateBySdcType - nodeTemplate is null or empty");
return new ArrayList<>();
}
if (substitutionMappings != null) {
List<NodeTemplate> nodeTemplates = substitutionMappings.getNodeTemplates();
if (nodeTemplates != null && !nodeTemplates.isEmpty()) {
- if (sdcType.equals(SdcTypes.VFC) && isVNF) {
- return nodeTemplates.stream()
- .filter(x -> (x.getMetaData() != null &&
- sdcType.getValue().equals(x.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))) && isVNFType(x))
- .collect(toList());
- }
- else {
+ if (sdcType.equals(SdcTypes.VFC) && isVNF) {
return nodeTemplates.stream()
- .filter(x -> (x.getMetaData() != null &&
- sdcType.getValue().equals(x.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))) && !isVNFType(x))
- .collect(toList());
- }
- }
- else {
+ .filter(x -> (x.getMetadata() != null &&
+ sdcType.getValue().equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))) && isVNFType(x))
+ .collect(toList());
+ } else {
+ return nodeTemplates.stream()
+ .filter(x -> (x.getMetadata() != null &&
+ sdcType.getValue().equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))) && !isVNFType(x))
+ .collect(toList());
+ }
+ } else {
log.debug("getNodeTemplateBySdcType - SubstitutionMappings' node Templates not exist");
}
- } else
+ } else {
log.debug("getNodeTemplateBySdcType - SubstitutionMappings not exist");
+ }
return new ArrayList<>();
}
return filterMap;
}
-
- public NodeTemplate getVnfConfig(String vfCustomizationUuid) {
-
- if (GeneralUtility.isEmptyString(vfCustomizationUuid)) {
+
+ public NodeTemplate getVnfConfig(String vfCustomizationUuid) {
+
+ if (GeneralUtility.isEmptyString(vfCustomizationUuid)) {
log.error("getVnfConfig - vfCustomizationId - is null or empty");
return null;
}
List<NodeTemplate> serviceVfList = getServiceVfList();
NodeTemplate vfInstance = getNodeTemplateByCustomizationUuid(serviceVfList, vfCustomizationUuid);
return getNodeTemplateBySdcType(vfInstance, SdcTypes.VFC, true).stream().findAny().orElse(null);
- }
+ }
@Override
public boolean hasTopology(NodeTemplate nodeTemplate) {
return false;
}
- if (nodeTemplate.getMetaData() != null) {
- String type = nodeTemplate.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE);
+ if (nodeTemplate.getMetadata() != null) {
+ String type = nodeTemplate.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE);
log.debug("hasTopology - node template {} is a {} type", nodeTemplate.getName(), type);
return SdcTypes.isComplex(type);
}
if (nodeTemplates != null && !nodeTemplates.isEmpty()) {
return nodeTemplates.stream()
- .filter(x -> !isVNFType(x))
- .collect(toList());
- }
- else {
+ .filter(x -> !isVNFType(x))
+ .collect(toList());
+ } else {
log.debug("getNodeTemplateChildren - SubstitutionMappings' node Templates not exist");
}
- } else
+ } else {
log.debug("getNodeTemplateChildren - SubstitutionMappings not exist");
+ }
return new ArrayList<>();
}
}
List<NodeTemplate> nodeTemplates = getServiceNodeTemplates();
- Optional<NodeTemplate> findFirst = nodeTemplates.stream().filter(nt -> nt.getName().equals(nodeName)).findFirst();
+ Optional<NodeTemplate> findFirst = nodeTemplates.stream().filter(nt -> nt.getName().equals(nodeName)).findFirst();
return findFirst.isPresent() ? findFirst.get() : null;
}
return null;
}
- return nt.getMetaData();
+ return nt.getMetadata();
}
@Override
Object property = PropertyUtils.processProperties(split, properties);
return property == null || property instanceof Function ? null : String.valueOf(property);
}
-
+
@Override
public ArrayList<Group> getGroupsOfOriginOfNodeTemplate(NodeTemplate nodeTemplate) {
- if(StringUtils.isNotEmpty(nodeTemplate.getName())){
- return getNodeTemplateByName(nodeTemplate.getName()).getSubMappingToscaTemplate().getGroups();
- }
- return new ArrayList<>();
+ if (StringUtils.isNotEmpty(nodeTemplate.getName())) {
+ return getNodeTemplateByName(nodeTemplate.getName()).getSubMappingToscaTemplate().getGroups();
+ }
+ return new ArrayList<>();
}
@Override
public ArrayList<Group> getGroupsOfTopologyTemplateByToscaGroupType(String groupType) {
- if(toscaTemplate.getGroups() == null)
- return new ArrayList<>();
- return (ArrayList<Group>) toscaTemplate.getGroups()
- .stream()
- .filter(g->g.getType().equals(groupType))
- .sorted(Group::compareTo)
- .collect(toList());
- }
-
+ if (toscaTemplate.getGroups() == null) {
+ return new ArrayList<>();
+ }
+ return (ArrayList<Group>) toscaTemplate.getGroups()
+ .stream()
+ .filter(g -> g.getType().equals(groupType))
+ .sorted(Group::compareTo)
+ .collect(toList());
+ }
+
@Override
public ArrayList<Group> getGroupsOfTopologyTemplate() {
- return toscaTemplate.getGroups() == null ? new ArrayList<>() : toscaTemplate.getGroups();
+ return toscaTemplate.getGroups() == null ? new ArrayList<>() : toscaTemplate.getGroups();
}
-
+
@Override
public ArrayList<Group> getGroupsOfOriginOfNodeTemplateByToscaGroupType(NodeTemplate nodeTemplate, String groupType) {
- return (ArrayList<Group>) getGroupsOfOriginOfNodeTemplate(nodeTemplate)
- .stream()
- .filter(g->g.getType().equals(groupType))
- .sorted(Group::compareTo)
- .collect(toList());
+ return (ArrayList<Group>) getGroupsOfOriginOfNodeTemplate(nodeTemplate)
+ .stream()
+ .filter(g -> g.getType().equals(groupType))
+ .sorted(Group::compareTo)
+ .collect(toList());
}
@Override
public List<NodeTemplate> getGroupMembersFromTopologyTemplate(String groupName) {
- if(toscaTemplate.getNodeTemplates() == null){
- return new ArrayList<>();
- }
- List<String> membersNames = getGroupMembers(groupName);
- return toscaTemplate.getNodeTemplates().stream()
- .filter(nt->membersNames.contains(nt.getName()))
- .collect(toList());
+ if (toscaTemplate.getNodeTemplates() == null) {
+ return new ArrayList<>();
+ }
+ List<String> membersNames = getGroupMembers(groupName);
+ return toscaTemplate.getNodeTemplates().stream()
+ .filter(nt -> membersNames.contains(nt.getName()))
+ .collect(toList());
}
-
+
@Override
public List<NodeTemplate> getGroupMembersOfOriginOfNodeTemplate(NodeTemplate nodeTemplate, String groupName) {
- ArrayList<Group> groups = getGroupsOfOriginOfNodeTemplate(nodeTemplate);
- if(!groups.isEmpty()){
- Optional<Group> group = groups.stream().filter(g -> g.getName().equals(groupName)).findFirst();
- if(group.isPresent()){
- return nodeTemplate.getSubMappingToscaTemplate().getNodeTemplates().stream()
- .filter(nt -> group.get().getMembers().contains(nt.getName()))
- .collect(toList());
- }
- }
- return new ArrayList<>();
- }
-
+ ArrayList<Group> groups = getGroupsOfOriginOfNodeTemplate(nodeTemplate);
+ if (!groups.isEmpty()) {
+ Optional<Group> group = groups.stream().filter(g -> g.getName().equals(groupName)).findFirst();
+ if (group.isPresent()) {
+ return nodeTemplate.getSubMappingToscaTemplate().getNodeTemplates().stream()
+ .filter(nt -> group.get().getMembers().contains(nt.getName()))
+ .collect(toList());
+ }
+ }
+ return new ArrayList<>();
+ }
+
+ @Override
public List<NodeTemplate> getServiceNodeTemplateBySdcType(SdcTypes sdcType) {
- if (sdcType == null) {
- log.error("getServiceNodeTemplateBySdcType - sdcType is null or empty");
- return new ArrayList<>();
- }
-
- TopologyTemplate topologyTemplate = toscaTemplate.getTopologyTemplate();
- return getNodeTemplateBySdcType(topologyTemplate, sdcType);
+ if (sdcType == null) {
+ log.error("getServiceNodeTemplateBySdcType - sdcType is null or empty");
+ return new ArrayList<>();
+ }
+
+ TopologyTemplate topologyTemplate = toscaTemplate.getTopologyTemplate();
+ return getNodeTemplateBySdcType(topologyTemplate, sdcType);
}
- /************************************* helper functions ***********************************/
+ /************************************* helper functions ***********************************/
private boolean isVNFType(NodeTemplate nt) {
return nt.getType().endsWith("VnfConfiguration");
}
private Map<String, String> filterProperties(Object property, String path, FilterType filterType, String pattern, Map<String, String> filterMap) {
if (property instanceof Map) {
- for (Map.Entry<String, Object> item: ((Map<String, Object>) property).entrySet()) {
+ for (Map.Entry<String, Object> item : ((Map<String, Object>) property).entrySet()) {
String itemPath = path + PATH_DELIMITER + item.getKey();
filterProperties(item.getValue(), itemPath, filterType, pattern, filterMap);
}
} else if (property instanceof List) {
- for (Object item: (List<Object>)property) {
+ for (Object item : (List<Object>) property) {
filterProperties(item, path, filterType, pattern, filterMap);
}
} else {
return filterMap;
}
-
+
/************************************* helper functions ***********************************/
private List<NodeTemplate> getNodeTemplateBySdcType(TopologyTemplate topologyTemplate, SdcTypes sdcType) {
if (sdcType == null) {
List<NodeTemplate> nodeTemplates = topologyTemplate.getNodeTemplates();
- if (nodeTemplates != null && !nodeTemplates.isEmpty())
- return nodeTemplates.stream().filter(x -> (x.getMetaData() != null && sdcType.getValue().equals(x.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)))).collect(toList());
+ if (nodeTemplates != null && !nodeTemplates.isEmpty()) {
+ return nodeTemplates.stream()
+ .filter(x -> (x.getMetadata() != null && sdcType.getValue().equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_TYPE))))
+ .collect(toList());
+ }
log.debug("getNodeTemplateBySdcType - topologyTemplate's nodeTemplates not exist");
return new ArrayList<>();
//Assumed to be unique property for the list
private NodeTemplate getNodeTemplateByCustomizationUuid(List<NodeTemplate> nodeTemplates, String customizationId) {
- if (customizationId != null) {
- Optional<NodeTemplate> findFirst = nodeTemplates.stream().filter(x -> (x.getMetaData() != null && customizationId.equals(x.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)))).findFirst();
+ if (customizationId != null) {
+ Optional<NodeTemplate> findFirst = nodeTemplates.stream().filter(
+ x -> (x.getMetadata() != null && customizationId.equals(x.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID))))
+ .findFirst();
return findFirst.isPresent() ? findFirst.get() : null;
- }
- else {
+ } else {
log.error("getNodeTemplateByCustomizationUuid - customizationId is null");
return null;
}
}
- @Override
- public Map<String, List<InterfacesDef>> getInterfacesOf(NodeTemplate nt){
- if (nt == null) {
- return null;
+ @Override
+ public Map<String, List<InterfacesDef>> getInterfacesOf(NodeTemplate nt) {
+ if (nt == null) {
+ return null;
+ }
+ return nt.getAllInterfaceDetailsForNodeType();
}
- return nt.getAllInterfaceDetailsForNodeType();
- }
- @Override
- public List<String> getInterfaces(NodeTemplate nt){
- Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
- return new ArrayList<>(interfaceDetails.keySet());
- }
+ @Override
+ public List<String> getInterfaces(NodeTemplate nt) {
+ Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
+ return new ArrayList<>(interfaceDetails.keySet());
+ }
- @Override
- public List<InterfacesDef> getInterfaceDetails(NodeTemplate nt, String interfaceName){
- Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
- return interfaceDetails.get(interfaceName);
- }
+ @Override
+ public List<InterfacesDef> getInterfaceDetails(NodeTemplate nt, String interfaceName) {
+ Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
+ return interfaceDetails.get(interfaceName);
+ }
- @Override
- public List<String> getAllInterfaceOperations(NodeTemplate nt, String interfaceName){
- Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
- return interfaceDetails.values().stream().flatMap(List::stream).map(val -> val.getOperationName()).collect(
- Collectors.toList());
- }
+ @Override
+ public List<String> getAllInterfaceOperations(NodeTemplate nt, String interfaceName) {
+ Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
+ return interfaceDetails.values().stream().flatMap(List::stream).map(val -> val.getOperationName()).collect(
+ Collectors.toList());
+ }
- @Override
- public InterfacesDef getInterfaceOperationDetails(NodeTemplate nt, String interfaceName, String operationName){
- Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
- if(!interfaceDetails.isEmpty()){
- List<InterfacesDef> interfaceDefs = interfaceDetails.get(interfaceName);
- return interfaceDefs.stream().filter(val -> val.getOperationName().equals(operationName)).findFirst().orElse(null);
+ @Override
+ public InterfacesDef getInterfaceOperationDetails(NodeTemplate nt, String interfaceName, String operationName) {
+ Map<String, List<InterfacesDef>> interfaceDetails = nt.getAllInterfaceDetailsForNodeType();
+ if (!interfaceDetails.isEmpty()) {
+ List<InterfacesDef> interfaceDefs = interfaceDetails.get(interfaceName);
+ return interfaceDefs.stream().filter(val -> val.getOperationName().equals(operationName)).findFirst().orElse(null);
+ }
+ return null;
}
- return null;
- }
@Override
public List<String> getPropertyLeafValueByPropertyNamePathAndNodeTemplatePath(String propertyNamePath, String nodeTemplatePath) {
log.info("A new request is received: property path is [{}], node template path is [{}]",
- propertyNamePath, nodeTemplatePath);
+ propertyNamePath, nodeTemplatePath);
List<String> propertyValuesList;
if (StringUtils.isEmpty(nodeTemplatePath) || StringUtils.isEmpty(propertyNamePath)) {
log.error("One of parameters is empty or null: property path is [{}], node template path is [{}]",
- propertyNamePath, nodeTemplatePath);
+ propertyNamePath, nodeTemplatePath);
propertyValuesList = Collections.emptyList();
- }
- else {
+ } else {
String[] nodeTemplates = getSplittedPath(nodeTemplatePath);
propertyValuesList = getPropertyFromInternalNodeTemplate(getNodeTemplateByName(nodeTemplates[0]), 1, nodeTemplates, propertyNamePath);
log.info("Found property value {} by path [{}] for node template [{}]",
- propertyValuesList, propertyNamePath, nodeTemplatePath);
+ propertyValuesList, propertyNamePath, nodeTemplatePath);
}
return propertyValuesList;
}
private List<String> getPropertyFromInternalNodeTemplate(NodeTemplate parent, int index,
- String[] nodeTemplatePath, String propertyPath) {
+ String[] nodeTemplatePath, String propertyPath) {
List<String> propertyValuesList;
if (parent == null) {
log.error("Node template {} is not found, the request will be rejected", nodeTemplatePath[index]);
propertyValuesList = Collections.emptyList();
- }
- else if (nodeTemplatePath.length <= index) {
+ } else if (nodeTemplatePath.length <= index) {
log.debug("Stop NODE TEMPLATE searching");
propertyValuesList = getSimpleOrListPropertyValue(parent, propertyPath);
- }
- else {
+ } else {
log.debug("Node template {} is found with name {}", nodeTemplatePath[index], parent.getName());
NodeTemplate childNT = getChildNodeTemplateByName(parent, nodeTemplatePath[index]);
if (childNT == null || !isNodeTypeSupported(childNT)) {
log.error("Unsupported or not found node template named {}, the request will be rejected",
- nodeTemplatePath[index]);
+ nodeTemplatePath[index]);
propertyValuesList = Collections.emptyList();
- }
- else {
+ } else {
propertyValuesList = getPropertyFromInternalNodeTemplate(childNT, index + 1, nodeTemplatePath,
- propertyPath);
+ propertyPath);
}
}
return propertyValuesList;
}
-
-
private List<String> getSimpleOrListPropertyValue(NodeTemplate nodeTemplate, String propertyPath) {
List<String> propertyValueList;
String[] path = getSplittedPath(propertyPath);
//the requested property type is either simple or list of simple types
PropertySchemaType propertyType = PropertySchemaType.getEnumByValue(property.getType());
if (propertyType == PropertySchemaType.LIST &&
- PropertyUtils.isDataPropertyType((String)property.getEntrySchema()
- .get(SdcPropertyNames.PROPERTY_NAME_TYPE))) {
+ PropertyUtils.isDataPropertyType((String) property.getEntrySchema()
+ .get(SdcPropertyNames.PROPERTY_NAME_TYPE))) {
//cover the case when a type of property "path[0]' is list of data types
// and the requested property is an internal simple property of this data type
propertyValueList = calculatePropertyValue(getNodeTemplatePropertyValueAsObject(nodeTemplate, path[0]), path, nodeTemplate.getName());
- }
- else {
+ } else {
//the requested property is simple type or list of simple types
- propertyValueList = calculatePropertyValue(getNodeTemplatePropertyValueAsObject(nodeTemplate, propertyPath), null, nodeTemplate.getName());
+ propertyValueList = calculatePropertyValue(getNodeTemplatePropertyValueAsObject(nodeTemplate, propertyPath), null,
+ nodeTemplate.getName());
}
- }
- else {
+ } else {
log.error("The type of property {} on node {} is neither simple nor list of simple objects, the request will be rejected",
- propertyPath, nodeTemplate.getName());
+ propertyPath, nodeTemplate.getName());
propertyValueList = Collections.emptyList();
}
return propertyValueList;
}
- private List<String> calculatePropertyValue(Object valueAsObject, String path[], String nodeName) {
+ private List<String> calculatePropertyValue(Object valueAsObject, String[] path, String nodeName) {
if (valueAsObject == null || valueAsObject instanceof Map) {
- log.error("The property {} either is not found on node template [{}], or it is data type, or it is not resolved get_input", path, nodeName);
+ log.error("The property {} either is not found on node template [{}], or it is data type, or it is not resolved get_input", path,
+ nodeName);
return Collections.emptyList();
}
if (path != null) {
- return PropertyUtils.findSimplePropertyValueInListOfDataTypes((List<Object>)valueAsObject, path);
+ return PropertyUtils.findSimplePropertyValueInListOfDataTypes((List<Object>) valueAsObject, path);
}
return PropertyUtils.buildSimplePropertValueOrList(valueAsObject);
}
-
-
-
private Property getNodeTemplatePropertyObjectByName(NodeTemplate nodeTemplate, String propertyName) {
return nodeTemplate.getPropertiesObjects()
- .stream()
- .filter(p->p.getName().equals(propertyName))
- .findFirst()
- .orElse(null);
+ .stream()
+ .filter(p -> p.getName().equals(propertyName))
+ .findFirst()
+ .orElse(null);
}
private NodeTemplate getChildNodeTemplateByName(NodeTemplate parent, String nodeTemplateName) {
return getNodeTemplateChildren(parent)
.stream()
- .filter(nt->nt.getName().equals(nodeTemplateName))
+ .filter(nt -> nt.getName().equals(nodeTemplateName))
.findFirst().orElse(null);
}
if (log.isDebugEnabled()) {
log.debug("getEntity request: EntityQuery <{}>, TopologyTemplateQuery <{}>, isRecursive<{}>",
- entityQuery, topologyTemplateQuery, isRecursive);
+ entityQuery, topologyTemplateQuery, isRecursive);
}
return new QueryProcessor(toscaTemplate, entityQuery, topologyTemplateQuery, isRecursive).doQuery();
}
}
@Override
- public List<IEntityDetails> getVFModule(String cuuid){
+ public List<IEntityDetails> getVFModule(String cuuid) {
String normalisedComponentInstanceName = SdcToscaUtility.normaliseComponentInstanceName(getVfiNameByCuuid(cuuid));
List<IEntityDetails> vfModulesFromVf = getVfModulesFromVf(cuuid);
List<IEntityDetails> vfModulesFromService = getVfModulesFromService().stream()
- .filter(v->v.getName().startsWith(normalisedComponentInstanceName))
- .collect(toList());
+ .filter(v -> v.getName().startsWith(normalisedComponentInstanceName))
+ .collect(toList());
addMembersToVfModuleInstances(vfModulesFromVf, vfModulesFromService);
return vfModulesFromService;
}
List<IEntityDetails> vfModuleInstances = new ArrayList<>();
getVfModulesFromVf().forEach(vfmodule -> {
- if (Objects.isNull(vfmodule.getParent())){
+ if (Objects.isNull(vfmodule.getParent())) {
vfModuleInstances.add(vfmodule);
} else {
vfModules.add(vfmodule);
}
});
- addMembersToVfModuleInstances(vfModules,vfModuleInstances);
+ addMembersToVfModuleInstances(vfModules, vfModuleInstances);
return vfModuleInstances;
}
private void addMembersToVfModuleInstances(List<IEntityDetails> vfModules, List<IEntityDetails> vfModuleInstances) {
- for(IEntityDetails vfModuleInstance : vfModuleInstances){
+ for (IEntityDetails vfModuleInstance : vfModuleInstances) {
String origGroupName = getOriginalGroupName(vfModuleInstance);
setVFModuleMembers(vfModules, vfModuleInstance, origGroupName);
}
}
private void setVFModuleMembers(List<IEntityDetails> vfModules, IEntityDetails vfModuleInstance, String origGroupName) {
- for (IEntityDetails vfModule : vfModules){
- if (vfModuleInstance instanceof GroupEntityDetails && vfModule.getName().equals(origGroupName)){
+ for (IEntityDetails vfModule : vfModules) {
+ if (vfModuleInstance instanceof GroupEntityDetails && vfModule.getName().equals(origGroupName)) {
List<IEntityDetails> memberNodes = vfModule.getMemberNodes();
- ((GroupEntityDetails)vfModuleInstance).setMemberNodes(memberNodes);
+ ((GroupEntityDetails) vfModuleInstance).setMemberNodes(memberNodes);
}
}
}
private List<IEntityDetails> getVfModulesFromService() {
EntityQuery entityQuery = EntityQuery.newBuilder(GROUPS_VF_MODULE)
- .build();
+ .build();
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
- .build();
+ .build();
return getEntity(entityQuery, topologyTemplateQuery, false);
}
private List<IEntityDetails> getVfModulesFromVf(String cuuid) {
EntityQuery entityQuery = EntityQuery.newBuilder(GROUPS_VF_MODULE)
- .build();
+ .build();
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
- .customizationUUID(cuuid)
- .build();
+ .customizationUUID(cuuid)
+ .build();
return getEntity(entityQuery, topologyTemplateQuery, false);
}
private List<IEntityDetails> getVfModulesFromVf() {
EntityQuery entityQuery = EntityQuery.newBuilder(GROUPS_VF_MODULE)
- .build();
+ .build();
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
- .build();
+ .build();
return getEntity(entityQuery, topologyTemplateQuery, true);
}
private String getVfiNameByCuuid(String cuuid) {
EntityQuery entityQuery = EntityQuery.newBuilder(SdcTypes.VF)
- .customizationUUID(cuuid)
- .build();
+ .customizationUUID(cuuid)
+ .build();
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
- .build();
+ .build();
return getEntity(entityQuery, topologyTemplateQuery, true).get(0).getName();
}
- }
+}
* 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.
import java.util.ArrayList;
import java.util.List;
-
import org.onap.sdc.tosca.parser.api.ConformanceLevel;
+import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.config.ConfigurationManager;
import org.onap.sdc.tosca.parser.config.ErrorInfo;
import org.onap.sdc.tosca.parser.config.JToscaValidationIssueInfo;
import org.onap.sdc.tosca.parser.config.SdcToscaParserErrors;
import org.onap.sdc.tosca.parser.enums.JToscaValidationIssueType;
-import org.onap.sdc.tosca.parser.utils.GeneralUtility;
-import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
+import org.onap.sdc.tosca.parser.utils.GeneralUtility;
import org.onap.sdc.toscaparser.api.ToscaTemplate;
-import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.onap.sdc.toscaparser.api.common.JToscaException;
+import org.onap.sdc.toscaparser.api.common.JToscaValidationIssue;
import org.onap.sdc.toscaparser.api.utils.JToscaErrorCodes;
import org.onap.sdc.toscaparser.api.utils.ThreadLocalsHolder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SdcToscaParserFactory {
- private static Logger log = LoggerFactory.getLogger(SdcToscaParserFactory.class.getName());
+
+ private static Logger log = LoggerFactory.getLogger(SdcToscaParserFactory.class.getName());
private static ConfigurationManager configurationManager;
private static volatile SdcToscaParserFactory instance;
private List<JToscaValidationIssue> criticalExceptions = new ArrayList<>();
private List<JToscaValidationIssue> warningExceptions = new ArrayList<>();
private List<JToscaValidationIssue> notAnalyzadExceptions = new ArrayList<>();
- private SdcToscaParserFactory() {}
+
+ private SdcToscaParserFactory() {
+ }
/**
* Get an SdcToscaParserFactory instance.
+ *
* @return SdcToscaParserFactory instance.
*/
public static SdcToscaParserFactory getInstance() {
/**
* Get an ISdcCsarHelper object for this CSAR file.
*
- * @param csarPath - the absolute path to CSAR file.
+ * @param csarPath - the absolute path to CSAR file.
* @param resolveGetInput - resolve get_input properties
* @return ISdcCsarHelper object.
* @throws SdcToscaParserException - in case the path or CSAR are invalid.
validateCsarVersion(cSarConformanceLevel);
try {
handleErrorsByTypes(csarPath, cSarConformanceLevel);
- } catch (JToscaException e) {
+ } catch (JToscaException e) {
throwSdcToscaParserException(e);
- }
+ }
return sdcCsarHelperImpl;
}
}
private void handleErrorsByTypes(String csarPath, String cSarConformanceLevel) throws JToscaException {
clearValidationIssuesLists();
- for(JToscaValidationIssue toscaValidationIssue : ThreadLocalsHolder.getCollector().getValidationIssues().values()){
- List<JToscaValidationIssueInfo> issueInfos = configurationManager.getJtoscaValidationIssueConfiguration().getValidationIssues().get(toscaValidationIssue.getCode());
- if(issueInfos != null && !issueInfos.isEmpty()){
- JToscaValidationIssueInfo issueInfo = null;
- issueInfo = issueInfos.stream()
- .filter(i-> isMatchConformanceLevel(cSarConformanceLevel,i.getSinceCsarConformanceLevel()))
- .max((i1,i2) -> GeneralUtility.conformanceLevelCompare(i1.getSinceCsarConformanceLevel(), i2.getSinceCsarConformanceLevel()) )
+ for (JToscaValidationIssue toscaValidationIssue : ThreadLocalsHolder.getCollector().getValidationIssues().values()) {
+ List<JToscaValidationIssueInfo> issueInfos = configurationManager.getJtoscaValidationIssueConfiguration().getValidationIssues()
+ .get(toscaValidationIssue.getCode());
+ if (issueInfos != null && !issueInfos.isEmpty()) {
+ final JToscaValidationIssueInfo issueInfo = issueInfos.stream()
+ .filter(i -> isMatchConformanceLevel(cSarConformanceLevel, i.getSinceCsarConformanceLevel()))
+ .max((i1, i2) -> GeneralUtility.conformanceLevelCompare(i1.getSinceCsarConformanceLevel(), i2.getSinceCsarConformanceLevel()))
.orElse(null);
- if(issueInfo != null){
+ if (issueInfo != null) {
switch (JToscaValidationIssueType.valueOf(issueInfo.getIssueType())) {
case CRITICAL:
criticalExceptions.add(toscaValidationIssue);
default:
break;
}
- }else{
+ } else {
notAnalyzadExceptions.add(toscaValidationIssue);
}
- }else{//notAnalyzed
+ } else {//notAnalyzed
notAnalyzadExceptions.add(toscaValidationIssue);
}
- }
- logErrors(csarPath);
+ }
+ logErrors(csarPath);
}
- private void clearValidationIssuesLists(){
+ private void clearValidationIssuesLists() {
notAnalyzadExceptions.clear();
criticalExceptions.clear();
warningExceptions.clear();
}
- private void logErrors(String inputPath) throws JToscaException{
- //Warnings
- int warningsCount = warningExceptions.size();
- if (warningsCount > 0) {
- log.warn("####################################################################################################");
- log.warn("CSAR Warnings found! CSAR name - {}", inputPath);
- log.warn("ToscaTemplate - verifyTemplate - {} Parsing Warning{} occurred...", warningsCount, (warningsCount > 1 ? "s" : ""));
- for (JToscaValidationIssue info : warningExceptions) {
- log.warn("JTosca Exception [{}]: {}. CSAR name - {}", info.getCode(),info.getMessage(), inputPath);
- }
- log.warn("####################################################################################################");
- }
- //Criticals
- int criticalsCount = criticalExceptions.size();
- if (criticalsCount > 0) {
- log.error("####################################################################################################");
- log.error("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", criticalsCount, (criticalsCount > 1 ? "s" : ""));
- for (JToscaValidationIssue info : criticalExceptions) {
- log.error("JTosca Exception [{}]: {}. CSAR name - {}", info.getCode(),info.getMessage(), inputPath);
- }
- throw new JToscaException(String.format("CSAR Validation Failed. CSAR name - {}. Please check logs for details.", inputPath), JToscaErrorCodes.CSAR_TOSCA_VALIDATION_ERROR.getValue());
- }
+ private void logErrors(String inputPath) throws JToscaException {
+ //Warnings
+ int warningsCount = warningExceptions.size();
+ if (warningsCount > 0) {
+ log.warn("####################################################################################################");
+ log.warn("CSAR Warnings found! CSAR name - {}", inputPath);
+ log.warn("ToscaTemplate - verifyTemplate - {} Parsing Warning{} occurred...", warningsCount, (warningsCount > 1 ? "s" : ""));
+ for (JToscaValidationIssue info : warningExceptions) {
+ log.warn("JTosca Exception [{}]: {}. CSAR name - {}", info.getCode(), info.getMessage(), inputPath);
+ }
+ log.warn("####################################################################################################");
+ }
+ //Criticals
+ int criticalsCount = criticalExceptions.size();
+ if (criticalsCount > 0) {
+ log.error("####################################################################################################");
+ log.error("ToscaTemplate - verifyTemplate - {} Parsing Critical{} occurred...", criticalsCount, (criticalsCount > 1 ? "s" : ""));
+ for (JToscaValidationIssue info : criticalExceptions) {
+ log.error("JTosca Exception [{}]: {}. CSAR name - {}", info.getCode(), info.getMessage(), inputPath);
+ }
+ throw new JToscaException(String.format("CSAR Validation Failed. CSAR name - {}. Please check logs for details.", inputPath),
+ JToscaErrorCodes.CSAR_TOSCA_VALIDATION_ERROR.getValue());
+ }
}
+
public List<JToscaValidationIssue> getCriticalExceptions() {
- return criticalExceptions;
- }
+ return criticalExceptions;
+ }
- public List<JToscaValidationIssue> getWarningExceptions() {
- return warningExceptions;
- }
+ public List<JToscaValidationIssue> getWarningExceptions() {
+ return warningExceptions;
+ }
- public List<JToscaValidationIssue> getNotAnalyzadExceptions() {
- return notAnalyzadExceptions;
- }
+ public List<JToscaValidationIssue> getNotAnalyzadExceptions() {
+ return notAnalyzadExceptions;
+ }
- private void validateCsarVersion(String cSarVersion) throws SdcToscaParserException {
+ private void validateCsarVersion(String cSarVersion) throws SdcToscaParserException {
ConformanceLevel level = configurationManager.getConfiguration().getConformanceLevel();
String minVersion = level.getMinVersion();
if (cSarVersion != null) {
}
}
- private boolean isMatchConformanceLevel(String ValidationIssueVersion, String cSarVersion){
+ private boolean isMatchConformanceLevel(String ValidationIssueVersion, String cSarVersion) {
if (ValidationIssueVersion != null && cSarVersion != null) {
if ((GeneralUtility.conformanceLevelCompare(ValidationIssueVersion, cSarVersion) >= 0)) {
return true;
}
return false;
}
+
private void throwConformanceLevelException(String minVersion) throws SdcToscaParserException {
ErrorInfo errorInfo = configurationManager.getErrorConfiguration().getErrorInfo(SdcToscaParserErrors.CONFORMANCE_LEVEL_ERROR.toString());
throw new SdcToscaParserException(String.format(errorInfo.getMessage(), minVersion), errorInfo.getCode());
}
private void throwSdcToscaParserException(JToscaException e) throws SdcToscaParserException {
- ErrorInfo errorInfo = configurationManager.getErrorConfiguration().getErrorInfo(SdcToscaParserErrors.getSdcErrorByJToscaError(JToscaErrorCodes.getByCode(e.getCode())).toString());
+ ErrorInfo errorInfo = configurationManager.getErrorConfiguration()
+ .getErrorInfo(SdcToscaParserErrors.getSdcErrorByJToscaError(JToscaErrorCodes.getByCode(e.getCode())).toString());
throw new SdcToscaParserException(errorInfo.getMessage(), errorInfo.getCode());
}
-
}
import org.onap.sdc.tosca.parser.exceptions.SdcToscaParserException;
import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
-
public class SdcToscaParserBasicTest extends BaseSetupExtension {
public static final String VF_CUSTOMIZATION_UUID = "56179cd8-de4a-4c38-919b-bbc4452d2d73";
static ISdcCsarHelper csarHelperServiceAnnotations;
static ISdcCsarHelper csarHelperServiceAdiodAnnotations;
static ISdcCsarHelper csarHelperServiceNetworkCloud;
- static Map<String, HashMap<String, List<String>>> fdntCsarHelper_Data;
+ static Map<String, Map<String, List<String>>> fdntCsarHelper_Data;
@Override
void setup() throws SdcToscaParserException {
fdntCsarHelper_Data = new HashMap<>() {
{
- HashMap<String, List<String>> FDNT;
-
- FDNT = new HashMap<>();
+ final Map<String, List<String>> FDNT = new HashMap<>();
FDNT.put("VF Name", Arrays.asList("FDNT 1"));
FDNT.put("capabilities", Arrays.asList(
"dnt_fw_rhrg.binding_DNT_FW_INT_DNS_TRUSTED_RVMI",
}
protected ISdcCsarHelper getCsarHelper(String path) throws SdcToscaParserException {
- System.out.println("Parsing CSAR " + path + "...");
- String fileStr1 = SdcToscaParserBasicTest.class.getClassLoader().getResource(path).getFile();
- File file1 = new File(fileStr1);
- ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(file1.getAbsolutePath());
- return sdcCsarHelper;
+ return getCsarHelper(path, true);
}
protected ISdcCsarHelper getCsarHelper(String path, boolean resolveGetInput) throws SdcToscaParserException {
System.out.println("Parsing CSAR " + path + "...");
- String fileStr1 = SdcToscaParserBasicTest.class.getClassLoader().getResource(path).getFile();
- File file1 = new File(fileStr1);
- ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(file1.getAbsolutePath(), resolveGetInput);
- return sdcCsarHelper;
+ return factory.getSdcCsarHelper(new File(SdcToscaParserBasicTest.class.getClassLoader().getResource(path).getFile()).getAbsolutePath(),
+ resolveGetInput);
}
@Override
--- /dev/null
+/*
+ * -
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2022 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.sdc.impl;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.net.URL;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.elements.ArtifactDef;
+
+class ToscaParserArtifactsTest {
+
+ private static final String TEST_ARTIFACTS_FILENAME = "csars/resource-VspWithArtifacts.csar";
+ private static final String TEST_ARTIFACT_TYPE = "tosca.artifacts.asd.deploymentItem";
+ private static final List<String> ARTIFACTS_NAME_LIST = Arrays.asList("sampleapp-db", "sampleapp-services");
+ private static ISdcCsarHelper helper = null;
+
+ @BeforeAll
+ public static void setup() throws Exception {
+ final URL resource = ToscaParserArtifactsTest.class.getClassLoader().getResource(TEST_ARTIFACTS_FILENAME);
+ if (resource != null) {
+ helper = SdcToscaParserFactory.getInstance().getSdcCsarHelper(resource.getFile());
+ }
+ assertNotNull(helper);
+ }
+
+ @Test
+ void testGetArtifacts() {
+ final NodeTemplate nodeTemplate = helper.getServiceNodeTemplates().get(0);
+ assertNotNull(nodeTemplate);
+ final Map<String, ArtifactDef> artifacts = nodeTemplate.getArtifacts();
+ assertNotNull(artifacts);
+ assertEquals(2, artifacts.size());
+ artifacts.entrySet().forEach(entry -> {
+ assertTrue(ARTIFACTS_NAME_LIST.contains(entry.getKey()));
+ final ArtifactDef artifactDef = entry.getValue();
+ assertNotNull(artifactDef);
+ final String artifactTypeDefType = artifactDef.getType();
+ assertNotNull(artifactTypeDefType);
+ assertEquals(TEST_ARTIFACT_TYPE, artifactTypeDefType);
+ final Map<String, Object> properties = artifactDef.getProperties();
+ assertNotNull(properties);
+ assertFalse(properties.isEmpty());
+ final String file = artifactDef.getFile();
+ assertNotNull(file);
+ assertTrue(file.startsWith("../Artifacts/Deployment/HELM/sampleapp-"));
+ });
+
+ }
+
+}
public void testGetVnfConfig() {
NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
assertNotNull(vnfConfig);
- assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
+ assertEquals("vnfConfiguration", vnfConfig.getMetadata().getValue("name"));
}
@Test
children.sort(Comparator.comparing(NodeTemplate::getName));
assertEquals("DNT_FW_RSG_SI_1", children.get(1).getName());
- assertEquals("VFC", children.get(1).getMetaData().getValue("type"));
+ assertEquals("VFC", children.get(1).getMetadata().getValue("type"));
assertEquals("DNT_PORT", children.get(2).getName());
- assertEquals("CP", children.get(2).getMetaData().getValue("type"));
+ assertEquals("CP", children.get(2).getMetadata().getValue("type"));
}
@Test
vfChildren.sort(Comparator.comparing(NodeTemplate::getName));
assertEquals("VFC1 DUMMY", vfChildren.get(0).getName());
assertEquals("VF_VNF", vfChildren.get(1).getName());
- assertEquals("CVFC", vfChildren.get(1).getMetaData().getValue("type"));
+ assertEquals("CVFC", vfChildren.get(1).getMetadata().getValue("type"));
List<NodeTemplate> vfcChildren = nestedVfcCsarHlper.getNodeTemplateChildren(vfChildren.get(1));
public void testGetVnfConfigGetProperties() {
NodeTemplate vnfConfig = nfodCsarHlper.getVnfConfig("9bb2ef82-f8f6-4391-bc71-db063f15bf57");
assertNotNull(vnfConfig);
- assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
+ assertEquals("vnfConfiguration", vnfConfig.getMetadata().getValue("name"));
String manufacturer_reference_number = nfodCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#ATT_part_12345_for_FortiGate-VM00#vendor_info#manufacturer_reference_number");
String num_cpus = nfodCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#ATT_part_67890_for_FortiGate-VM01#compute_flavor#num_cpus");
public void testNewGetVnfConfigGetProperties() {
NodeTemplate vnfConfig = nfodNEWCsarHlper.getVnfConfig("a6587663-b27f-4e88-8a86-604604302ce6");
assertNotNull(vnfConfig);
- assertEquals("vnfConfiguration", vnfConfig.getMetaData().getValue("name"));
+ assertEquals("vnfConfiguration", vnfConfig.getMetadata().getValue("name"));
//Deployment flavor 1
String manufacturer_reference_number = nfodNEWCsarHlper.getNodeTemplatePropertyLeafValue(vnfConfig, "allowed_flavors#123456#vendor_info#manufacturer_reference_number");
NodeTemplate nodeTemplate = fdntCsarHelper.getServiceNodeTemplateByNodeName("FDNT 1");
assertNotNull(nodeTemplate);
assertEquals(nodeTemplate.getName(), "FDNT 1");
- assertEquals(nodeTemplate.getMetaData().getValue("type"), "VF");
+ assertEquals(nodeTemplate.getMetadata().getValue("type"), "VF");
}
@Test
NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("VF_1_V_port_1 0");
assertNotNull(nodeTemplate);
assertEquals(nodeTemplate.getName(), "VF_1_V_port_1 0");
- assertEquals(nodeTemplate.getMetaData().getValue("type"), "VF");
+ assertEquals(nodeTemplate.getMetadata().getValue("type"), "VF");
}
@Test
NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("ExtVL 0");
assertNotNull(nodeTemplate);
assertEquals(nodeTemplate.getName(), "ExtVL 0");
- assertEquals(nodeTemplate.getMetaData().getValue("type"), "VL");
+ assertEquals(nodeTemplate.getMetadata().getValue("type"), "VL");
}
@Test
NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("ExtCP 0");
assertNotNull(nodeTemplate);
assertEquals(nodeTemplate.getName(), "ExtCP 0");
- assertEquals(nodeTemplate.getMetaData().getValue("type"), "CP");
+ assertEquals(nodeTemplate.getMetadata().getValue("type"), "CP");
}
@Test
NodeTemplate nodeTemplate = QAServiceForToscaParserTests.getServiceNodeTemplateByNodeName("PNF TEST 0");
assertNotNull(nodeTemplate);
assertEquals(nodeTemplate.getName(), "PNF TEST 0");
- assertEquals(nodeTemplate.getMetaData().getValue("type"), "PNF");
+ assertEquals(nodeTemplate.getMetadata().getValue("type"), "PNF");
}
//QA region getServiceNodeTemplateBySdcType tests
public void getServiceNodeTemplateBySdcType_VF() {
List<NodeTemplate> vfList = QAServiceForToscaParserTests.getServiceNodeTemplatesByType("org.openecomp.resource.vf.Vf1VPort1");
assertEquals(2, vfList.size());
- assertEquals("VF_1_V_port_1", vfList.get(0).getMetaData().getValue("name"));
+ assertEquals("VF_1_V_port_1", vfList.get(0).getMetadata().getValue("name"));
}
// endregion Added by QA - Continue with testings of resolve get_input
NodeTemplate nodeTemplate = csarHelperServiceWithCrs.getServiceNodeTemplateByNodeName("chaya best cr 0");
List<NodeTemplate> crCpChildren = csarHelperServiceWithCrs.getNodeTemplateBySdcType(nodeTemplate, SdcTypes.CP);
assertEquals(crCpChildren.get(0).getName(), "ContrailPort 0");
- assertEquals(crCpChildren.get(0).getMetaData().getValue("type"), SdcTypes.CP.name());
+ assertEquals(crCpChildren.get(0).getMetadata().getValue("type"), SdcTypes.CP.name());
}
@Test
public void templateIsFoundByTypeOnly() {
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.SERVICE.getValue());
assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
}
public void templateIsNotFoundWhenMetadataIsNull() {
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
.build();
- when(nodeTemplate.getMetaData()).thenReturn(null);
+ when(nodeTemplate.getMetadata()).thenReturn(null);
assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
}
public void templateIsFoundIfItIsService() {
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.SERVICE)
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.SERVICE.getValue());
assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
}
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.customizationUUID("345")
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
public void templateIsNotFoundWhenTypeIsNotMatchedAndCuuidIsNotSet() {
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
}
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
.customizationUUID("2345")
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn(null);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
public void templateIsFoundWhenTypeIsMatchedAndCuuidIsNullInMetadata() {
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.VF)
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn(null);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.VF.getValue());
assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CVFC)
.customizationUUID("345")
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID)).thenReturn("345");
assertTrue(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
TopologyTemplateQuery topologyTemplateQuery = TopologyTemplateQuery.newBuilder(SdcTypes.CR)
.customizationUUID("345")
.build();
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn(SdcTypes.CVFC.getValue());
assertFalse(topologyTemplateQuery.isMatchingSearchCriteria(nodeTemplate));
}
@Test
public void verifyNodeTypeIsNotSupported() {
- when(nodeTemplate.getMetaData()).thenReturn(metadata);
+ when(nodeTemplate.getMetadata()).thenReturn(metadata);
when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn("VFC-TEST");
ISdcCsarHelper sdcCsarHelper = new SdcCsarHelperImpl(toscaTemplate);
Code Review / sdc / sdc-tosca.git / commitdiff