import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.onap.aai.babel.logging.LogHelper;
import org.onap.aai.babel.xml.generator.types.ModelType;
import org.onap.aai.cl.api.Logger;
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.onap.sdc.tosca.parser.impl.SdcPropertyNames;
+import org.onap.sdc.tosca.parser.utils.SdcToscaUtility;
import org.onap.sdc.toscaparser.api.Group;
import org.onap.sdc.toscaparser.api.NodeTemplate;
import org.onap.sdc.toscaparser.api.Property;
+import org.onap.sdc.toscaparser.api.SubstitutionMappings;
import org.onap.sdc.toscaparser.api.elements.Metadata;
/**
throws XmlArtifactGenerationException {
List<Resource> resources = new ArrayList<>();
if (serviceNodeTemplate.getSubMappingToscaTemplate() != null) {
- List<Group> serviceGroups = csarHelper.getGroupsOfOriginOfNodeTemplate(serviceNodeTemplate);
+ List<Group> serviceGroups = serviceNodeTemplate.getSubMappingToscaTemplate().getGroups();
for (Group group : serviceGroups) {
if (WidgetConfigurationUtil.isSupportedInstanceGroup(group.getType())) {
resources.addAll(processInstanceGroup(resourceModel, group.getMemberNodes(),
*
* @param resources
* @param model
- * @param serviceNode
+ * @param serviceVfNode
+ * a VF resource Node Template
* @throws XmlArtifactGenerationException
* if the configured widget mappings do not support the widget type of a VF Module
*/
- public void processVfModules(List<Resource> resources, Model resourceModel, NodeTemplate serviceNode)
+ public void processVfModules(List<Resource> resources, Model resourceModel, NodeTemplate serviceVfNode)
throws XmlArtifactGenerationException {
- // Get the customization UUID for each VF node and use it to get its Groups
- String uuid = csarHelper.getNodeTemplateCustomizationUuid(serviceNode);
- List<Group> serviceGroups = csarHelper.getVfModulesByVf(uuid);
-
// Process each VF Group
- for (Group serviceGroup : serviceGroups) {
+ for (Group serviceGroup : getVfModuleGroups(serviceVfNode)) {
Model groupModel = Model.getModelFor(serviceGroup.getType());
if (groupModel.hasWidgetType("VFMODULE")) {
- processVfModule(resources, resourceModel, serviceGroup, serviceNode, (Resource) groupModel);
+ processVfModule(resources, resourceModel, serviceGroup, serviceVfNode, (Resource) groupModel);
}
}
}
/**
+ * Implementation taken from the sdc-tosca parser (deprecated method).
+ *
+ * @param serviceVfNode
+ * a VF resource Node Template
+ * @return all service level VfModule groups with a name matching that of the supplied VF node template
+ */
+ private List<Group> getVfModuleGroups(NodeTemplate serviceVfNode) {
+ String instanceName = SdcToscaUtility.normaliseComponentInstanceName(serviceVfNode.getName());
+
+ return ToscaParser.getServiceLevelGroups(csarHelper).stream()
+ .filter(group -> "org.openecomp.groups.VfModule".equals(group.getTypeDefinition().getType())
+ && group.getName().startsWith(instanceName))
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Add each of the resources to the specified resourceModel. If the resourceModel type is Allotted Resource then
+ * validate that one of the resources is a Providing Service.
+ *
* @param resourceModel
+ * parent Resource model
* @param resourceNodeTemplates
+ * the child node templates of the resourceModel
+ * @throws XmlArtifactGenerationException
+ * if the resourceModel is an ALLOTTED_RESOURCE with no Providing Service
*/
- public void processResourceModels(Model resourceModel, List<NodeTemplate> resourceNodeTemplates) {
+ public void processResourceModels(Resource resourceModel, List<NodeTemplate> resourceNodeTemplates)
+ throws XmlArtifactGenerationException {
boolean foundProvidingService = false;
for (NodeTemplate resourceNodeTemplate : resourceNodeTemplates) {
}
if (resourceModel.hasWidgetType("ALLOTTED_RESOURCE") && !foundProvidingService) {
- final String modelInvariantId = resourceModel.getModelId();
- throw new IllegalArgumentException(String.format(GENERATOR_AAI_PROVIDING_SERVICE_MISSING,
- modelInvariantId == null ? "<null ID>" : modelInvariantId));
+ throw new XmlArtifactGenerationException(String.format(GENERATOR_AAI_PROVIDING_SERVICE_MISSING,
+ Optional.ofNullable(resourceModel.getModelId()).orElse("<null ID>")));
}
}
*/
private void processVfModule(List<Resource> resources, Model vfModel, Group groupDefinition,
NodeTemplate serviceNode, Resource groupModel) throws XmlArtifactGenerationException {
- groupModel.populateModelIdentificationInformation(
- mergeProperties(groupDefinition.getMetadata().getAllProperties(), groupDefinition.getProperties()));
+ Metadata metadata = groupDefinition.getMetadata();
+
+ Map<String, String> mergedProperties =
+ mergeProperties(metadata == null ? Collections.emptyMap() : metadata.getAllProperties(),
+ groupDefinition.getProperties());
- processVfModuleGroup(groupModel, csarHelper.getMembersOfVfModule(serviceNode, groupDefinition));
+ groupModel.populateModelIdentificationInformation(mergedProperties);
+ SubstitutionMappings substitutionMappings = serviceNode.getSubMappingToscaTemplate();
+ if (substitutionMappings != null) {
+ processVfModuleGroup(groupModel, getVfModuleMembers(substitutionMappings,
+ groupDefinition.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)));
+ }
vfModel.addResource(groupModel); // Add group (VfModule) to the (VF) model
// Check if we have already encountered the same VfModule across all the artifacts
}
}
+ /**
+ * @param substitutionMappings
+ * @param vfModuleInvariantUuid
+ * @return all serviceNode child Node Templates which are members of the first VF Module Group
+ */
+ private List<NodeTemplate> getVfModuleMembers(SubstitutionMappings substitutionMappings,
+ String vfModuleInvariantUuid) {
+ return Optional.ofNullable(substitutionMappings.getGroups()) //
+ .map(groups -> groups.stream() //
+ .filter(filterByVfModuleInvariantUuid(vfModuleInvariantUuid)) //
+ .findFirst().map(module -> Optional.ofNullable(module.getMembers()).orElse(new ArrayList<>()))
+ .orElse(new ArrayList<>()))
+ .map(members -> substitutionMappings.getNodeTemplates().stream()
+ .filter(nt -> members.contains(nt.getName())) //
+ .collect(Collectors.toList()))
+ .orElse(Collections.emptyList());
+ }
+
+ private Predicate<? super Group> filterByVfModuleInvariantUuid(String vfModuleInvariantUuid) {
+ return nt -> (nt.getMetadata() != null && vfModuleInvariantUuid
+ .equals(nt.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID)));
+ }
+
/**
* @param groupModel
* @param members
* parent Resource
* @param metaData
* for populating the Resource IDs
- * @param resourceNode
- * any Model (will be ignored if not a Resource)
+ * @param childResource
+ * a child Resource (will be ignored if this is a Widget type)
* @param nodeProperties
* the node properties
* @return whether or not a ProvidingService was processed
*/
- private boolean processModel(Model resourceModel, Metadata metaData, Resource resourceNode,
+ private boolean processModel(Model resourceModel, Metadata metaData, Resource childResource,
Map<String, Property> nodeProperties) {
- boolean foundProvidingService = resourceNode != null
- && (boolean) Optional.ofNullable(resourceNode.getProperties().get("providingService")).orElse(false);
+ boolean isProvidingService = childResource != null
+ && (boolean) Optional.ofNullable(childResource.getProperties().get("providingService")).orElse(false);
- if (foundProvidingService) {
- processProvidingService(resourceModel, resourceNode, nodeProperties);
- } else if (resourceNode != null && resourceNode.getModelType() == ModelType.RESOURCE
- && !resourceNode.hasWidgetType("L3_NET")) {
+ if (isProvidingService) {
+ processProvidingService(resourceModel, childResource, nodeProperties);
+ } else if (childResource != null && childResource.getModelType() == ModelType.RESOURCE
+ && !childResource.hasWidgetType("L3_NET")) {
if (metaData != null) {
- resourceNode.populateModelIdentificationInformation(metaData.getAllProperties());
+ childResource.populateModelIdentificationInformation(metaData.getAllProperties());
}
- resourceModel.addResource(resourceNode);
+ resourceModel.addResource(childResource);
}
- return foundProvidingService;
+ return isProvidingService;
}
+ /**
+ * @param resourceModel
+ * @param resourceNode
+ * @param nodeProperties
+ */
private void processProvidingService(Model resourceModel, Resource resourceNode,
Map<String, Property> nodeProperties) {
if (nodeProperties == null || nodeProperties.get("providing_service_uuid") == null