diff options
Diffstat (limited to 'src/main/java/org/onap/sdc/tosca/parser/impl/QueryProcessor.java')
-rw-r--r-- | src/main/java/org/onap/sdc/tosca/parser/impl/QueryProcessor.java | 127 |
1 files changed, 127 insertions, 0 deletions
diff --git a/src/main/java/org/onap/sdc/tosca/parser/impl/QueryProcessor.java b/src/main/java/org/onap/sdc/tosca/parser/impl/QueryProcessor.java new file mode 100644 index 0000000..42b499b --- /dev/null +++ b/src/main/java/org/onap/sdc/tosca/parser/impl/QueryProcessor.java @@ -0,0 +1,127 @@ +package org.onap.sdc.tosca.parser.impl; + +import com.google.common.collect.Lists; +import org.onap.sdc.tosca.parser.api.IEntityDetails; +import org.onap.sdc.tosca.parser.elements.queries.EntityQuery; +import org.onap.sdc.tosca.parser.elements.queries.TopologyTemplateQuery; +import org.onap.sdc.tosca.parser.enums.EntityTemplateType; +import org.onap.sdc.tosca.parser.enums.SdcTypes; +import org.onap.sdc.toscaparser.api.NodeTemplate; +import org.onap.sdc.toscaparser.api.ToscaTemplate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + * Performs search for entity templates inside node template according to query criteria + */ +class QueryProcessor { + private static final Logger logger = LoggerFactory.getLogger(QueryProcessor.class.getName()); + + private final EntityQuery entityQuery; + private final TopologyTemplateQuery topologyTemplateQuery; + private final ToscaTemplate toscaTemplate; + private boolean isRecursive = false; + + QueryProcessor(ToscaTemplate toscaTemplate, EntityQuery entityQuery, TopologyTemplateQuery topologyTemplateQuery, boolean isRecursive) { + this.toscaTemplate = toscaTemplate; + this.entityQuery = entityQuery == null ? EntityQuery.newBuilder(EntityTemplateType.ALL).build() : entityQuery; + this.topologyTemplateQuery = topologyTemplateQuery; + this.isRecursive = isRecursive; + } + + List<IEntityDetails> doQuery() { + List<IEntityDetails> entityDetailsList = Lists.newArrayList(); + if (isServiceSearch()) { + //search for entities inside the service + if (logger.isDebugEnabled()) { + logger.debug("Service {} is searched for {}", toscaTemplate.getMetaData().getValue(SdcPropertyNames.PROPERTY_NAME_NAME), entityQuery); + } + entityDetailsList.addAll(entityQuery.getEntitiesFromService(toscaTemplate)); + + if (!isRecursive) { + return entityDetailsList; + } + } + + List<NodeTemplate> foundTopologyTemplates = getInternalTopologyTemplates(toscaTemplate.getNodeTemplates(), false); + if (isRecursive) { + if (logger.isDebugEnabled()) { + logger.debug("Search for entities recursively"); + } + //go over internal topology templates of the found templates + // and search for instances of the same type + //if the queried topology template is "SERVICE", search for all instances of templates in the service + List<NodeTemplate> internalTopologyTemplates = foundTopologyTemplates.stream() + .filter(nt->nt.getSubMappingToscaTemplate() != null) + .map(nt->getInternalTopologyTemplates(nt.getSubMappingToscaTemplate().getNodeTemplates(), true)) + .flatMap(List::stream) + .collect(Collectors.toList()); + foundTopologyTemplates.addAll(internalTopologyTemplates); + } + if (logger.isDebugEnabled()) { + logger.debug("Found topology templates {} matching following query criteria: {}", + foundTopologyTemplates, topologyTemplateQuery); + } + //go over all node templates found according to query criteria and recursive flag and + // search for the requested entities. + entityDetailsList.addAll(searchEntitiesInsideTopologyTemplates(foundTopologyTemplates)); + + return entityDetailsList; + } + + private Map<String, NodeTemplate> convertListToMap(List<NodeTemplate> nodeTemplateList) { + // we use map to avoid duplicate search through same node templates + return nodeTemplateList.stream() + .collect(Collectors.toMap(NodeTemplate::getName, nt->nt, (nt1, nt2)->nt1)); + } + + private List<IEntityDetails> searchEntitiesInsideTopologyTemplates(List<NodeTemplate> foundTopologyTemplates) { + return convertListToMap(foundTopologyTemplates) + .values() + .stream() + .map(entityQuery::getEntitiesFromTopologyTemplate) + .flatMap(List::stream) + .collect(Collectors.toList()); + } + + private boolean isServiceSearch() { + return topologyTemplateQuery.getNodeTemplateType() == SdcTypes.SERVICE; + } + + private List<NodeTemplate> getInternalTopologyTemplates(List<NodeTemplate> nodeTemplateList, boolean searchTypeOnly) { + return nodeTemplateList + .stream() + .map(child->getTopologyTemplatesByQuery(child, searchTypeOnly)) + .flatMap(List::stream) + .collect(Collectors.toList()); + } + + private List<NodeTemplate> getTopologyTemplatesByQuery(NodeTemplate current, boolean searchTypeOnly) { + List<NodeTemplate> topologyTemplateList = Lists.newArrayList(); + + boolean isTopologyTemplateFound = searchTypeOnly ? + topologyTemplateQuery.isSameSdcType(current.getMetaData()) : topologyTemplateQuery.isMatchingSearchCriteria(current); + if (isTopologyTemplateFound) { + topologyTemplateList.add(current); + if (!isServiceSearch()) { + //recursion stop condition + return topologyTemplateList; + } + } + 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() + .stream() + .map(nt->getTopologyTemplatesByQuery(nt, searchTypeOnly)) + .flatMap(List::stream) + .collect(Collectors.toList())); + } + return topologyTemplateList; + } + + +} |