X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fonap%2Faai%2Fbabel%2Fparser%2FArtifactGeneratorToscaParser.java;h=0777e516fc0a2963b293a4a9311d12599824f039;hb=5f1b6e4eb654639de6aaae9b7d862eb01b991f55;hp=2421d68603fe460afada4224dfe341a5c6f4d93e;hpb=a2c5714eabfb87d4a59f106e418c967b599c4212;p=aai%2Fbabel.git diff --git a/src/main/java/org/onap/aai/babel/parser/ArtifactGeneratorToscaParser.java b/src/main/java/org/onap/aai/babel/parser/ArtifactGeneratorToscaParser.java index 2421d68..0777e51 100644 --- a/src/main/java/org/onap/aai/babel/parser/ArtifactGeneratorToscaParser.java +++ b/src/main/java/org/onap/aai/babel/parser/ArtifactGeneratorToscaParser.java @@ -2,8 +2,8 @@ * ============LICENSE_START======================================================= * org.onap.aai * ================================================================================ - * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved. - * Copyright © 2017-2018 European Software Marketing Ltd. + * Copyright (c) 2017-2019 AT&T Intellectual Property. All rights reserved. + * Copyright (c) 2017-2019 European Software Marketing Ltd. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -21,44 +21,55 @@ package org.onap.aai.babel.parser; +import com.google.gson.Gson; +import com.google.gson.JsonSyntaxException; +import java.io.BufferedReader; import java.io.File; -import java.io.FileInputStream; +import java.io.FileReader; import java.io.IOException; -import java.util.LinkedList; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Properties; +import java.util.Optional; +import java.util.function.Predicate; import java.util.stream.Collectors; -import org.onap.aai.babel.logging.ApplicationMsgs; +import java.util.stream.Stream; import org.onap.aai.babel.logging.LogHelper; +import org.onap.aai.babel.xml.generator.XmlArtifactGenerationException; +import org.onap.aai.babel.xml.generator.data.GroupConfiguration; import org.onap.aai.babel.xml.generator.data.WidgetConfigurationUtil; -import org.onap.aai.babel.xml.generator.model.AllotedResource; -import org.onap.aai.babel.xml.generator.model.L3NetworkWidget; import org.onap.aai.babel.xml.generator.model.Model; -import org.onap.aai.babel.xml.generator.model.ProvidingService; import org.onap.aai.babel.xml.generator.model.Resource; -import org.onap.aai.babel.xml.generator.model.Service; -import org.onap.aai.babel.xml.generator.model.TunnelXconnectWidget; -import org.onap.aai.babel.xml.generator.model.VfModule; import org.onap.aai.babel.xml.generator.model.Widget; +import org.onap.aai.babel.xml.generator.model.WidgetType; 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; +/** + * Wrapper for the sdc-tosca parser. + * + */ public class ArtifactGeneratorToscaParser { private static Logger log = LogHelper.INSTANCE; - public static final String PROPERTY_ARTIFACT_GENERATOR_CONFIG_FILE = "artifactgenerator.config"; + public static final String PROPERTY_TOSCA_MAPPING_FILE = "tosca.mappings.config"; + + public static final String GENERATOR_AAI_CONFIGLOCATION_NOT_FOUND = + "Cannot generate artifacts. System property %s not configured"; private static final String GENERATOR_AAI_CONFIGFILE_NOT_FOUND = "Cannot generate artifacts. Artifact Generator Configuration file not found at %s"; - private static final String GENERATOR_AAI_CONFIGLOCATION_NOT_FOUND = - "Cannot generate artifacts. artifactgenerator.config system property not configured"; private static final String GENERATOR_AAI_PROVIDING_SERVICE_METADATA_MISSING = "Cannot generate artifacts. Providing Service Metadata is missing for allotted resource %s"; private static final String GENERATOR_AAI_PROVIDING_SERVICE_MISSING = @@ -77,212 +88,360 @@ public class ArtifactGeneratorToscaParser { /** * Constructs using csarHelper * - * @param csarHelper The csar helper + * @param csarHelper + * The csar helper */ public ArtifactGeneratorToscaParser(ISdcCsarHelper csarHelper) { this.csarHelper = csarHelper; } /** - * Returns the artifact description + * Initializes the group filtering and TOSCA to Widget mapping configuration. * - * @param model the artifact model - * @return the artifact model's description + * @param configLocation + * the pathname to the JSON mappings file + * @throws IOException + * if the file content could not be read successfully */ - public static String getArtifactDescription(Model model) { - String artifactDesc = model.getModelDescription(); - if (model.getModelType().equals(ModelType.SERVICE)) { - artifactDesc = "AAI Service Model"; - } else if (model.getModelType().equals(ModelType.RESOURCE)) { - artifactDesc = "AAI Resource Model"; + public static void initToscaMappingsConfiguration(String configLocation) throws IOException { + log.debug("Getting TOSCA Mappings Configuration"); + File file = new File(configLocation); + if (!file.exists()) { + throw new IllegalArgumentException(String.format(GENERATOR_AAI_CONFIGFILE_NOT_FOUND, configLocation)); + } + + GroupConfiguration config; + + try (BufferedReader bufferedReader = new BufferedReader(new FileReader(configLocation))) { + config = new Gson().fromJson(bufferedReader, GroupConfiguration.class); + } catch (JsonSyntaxException e) { + throw new IOException("Invalid Mappings Configuration " + configLocation, e); + } + + if (config == null) { + throw new IOException("There is no content for the Mappings Configuration " + configLocation); } - return artifactDesc; + + WidgetConfigurationUtil.setSupportedInstanceGroups(config.getInstanceGroupTypes()); + WidgetConfigurationUtil.setWidgetTypes(config.getWidgetTypes()); + WidgetConfigurationUtil.setWidgetMappings(config.getWidgetMappings()); } /** - * Initialises the widget configuration. + * Process groups for this service node, according to the defined filter. * - * @throws IOException + * @param resourceModel + * @param serviceNodeTemplate + * @return resources for which XML Models should be generated + * @throws XmlArtifactGenerationException + * if there is no configuration defined for a member Widget of an instance group */ - public static void initWidgetConfiguration() throws IOException { - log.debug("Getting Widget Configuration"); - String configLocation = System.getProperty(PROPERTY_ARTIFACT_GENERATOR_CONFIG_FILE); - if (configLocation != null) { - File file = new File(configLocation); - if (file.exists()) { - Properties properties = new Properties(); - properties.load(new FileInputStream(file)); - WidgetConfigurationUtil.setConfig(properties); - } else { - throw new IllegalArgumentException(String.format(GENERATOR_AAI_CONFIGFILE_NOT_FOUND, configLocation)); + public List processInstanceGroups(Model resourceModel, NodeTemplate serviceNodeTemplate) + throws XmlArtifactGenerationException { + List resources = new ArrayList<>(); + if (serviceNodeTemplate.getSubMappingToscaTemplate() != null) { + List serviceGroups = serviceNodeTemplate.getSubMappingToscaTemplate().getGroups(); + for (Group group : serviceGroups) { + if (WidgetConfigurationUtil.isSupportedInstanceGroup(group.getType())) { + resources.addAll(processInstanceGroup(resourceModel, group.getMemberNodes(), + group.getMetadata().getAllProperties(), group.getProperties())); + } } - } else { - throw new IllegalArgumentException(GENERATOR_AAI_CONFIGLOCATION_NOT_FOUND); } + return resources; } /** - * Process the service TOSCA. + * Merge a Map of String values with a Map of TOSCA Property Objects to create a combined Map. If there are + * duplicate keys then the TOSCA Property value takes precedence. * - * @param service model of the service artifact - * @param idTypeStore ID->Type mapping - * @param nodeTemplates a list of service nodes + * @param stringProps + * initial Map of String property values (e.g. from the TOSCA YAML metadata section) + * @param toscaProps + * Map of TOSCA Property Type Object values to merge in (or overwrite) + * @return a Map of the property values converted to String + */ + public Map mergeProperties(Map stringProps, Map toscaProps) { + Map props = new HashMap<>(stringProps); + toscaProps.forEach((key, toscaProp) -> props.put(key, + toscaProp.getValue() == null ? "" : toscaProp.getValue().toString())); + return props; + } + + public Resource createInstanceGroupModel(Map properties) { + Resource groupModel = new Resource(WidgetType.valueOf("INSTANCE_GROUP"), true); + groupModel.populateModelIdentificationInformation(properties); + return groupModel; + } + + /** + * Add the resource/widget to the specified model. * + * @param model + * @param relation + * resource or widget model to add + * @throws XmlArtifactGenerationException + * if the relation is a widget and there is no configuration defined for the relation's widget type */ - public void processServiceTosca(Service service, Map idTypeStore, - List nodeTemplates) { - log.debug("Inside Service Tosca "); - - // Get the resource/widgets in the service according to the node-template types - for (NodeTemplate node : nodeTemplates) { - if (node.getMetaData() != null) { - Model model = Model.getModelFor(correctNodeType(node)); - if (model != null) { - model.populateModelIdentificationInformation(node.getMetaData().getAllProperties()); - if (model instanceof Resource) { - // Keeping track of resource types and - // their uuid for identification during resource tosca processing - idTypeStore.put(model.getModelNameVersionId(), correctNodeType(node)); - service.addResource((Resource) model); - } else { - service.addWidget((Widget) model); - } - } - } else { - log.warn(ApplicationMsgs.MISSING_SERVICE_METADATA, node.getName()); + public void addRelatedModel(final Model model, final Resource relation) throws XmlArtifactGenerationException { + if (relation.getModelType() == ModelType.RESOURCE) { + model.addResource(relation); + } else { + model.addWidget(Widget.createWidget(relation.getWidgetType())); + } + } + + public boolean hasAllottedResource(Map metadata) { + return ALLOTTED_RESOURCE.equals(metadata.get(CATEGORY)); + } + + public boolean hasSubCategoryTunnelXConnect(Map metadata) { + return TUNNEL_XCONNECT.equals(metadata.get(SUBCATEGORY)); + } + + /** + * Process TOSCA Group information for VF Modules. + * + * @param resources + * @param model + * @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 resources, Model resourceModel, NodeTemplate serviceVfNode) + throws XmlArtifactGenerationException { + // Process each VF Group + for (Group serviceGroup : getVfModuleGroups(serviceVfNode)) { + Model groupModel = Model.getModelFor(serviceGroup.getType()); + if (groupModel.hasWidgetType("VFMODULE")) { + processVfModule(resources, resourceModel, serviceGroup, serviceVfNode, (Resource) groupModel); } } } /** - * Generates a Resource List using input Service Node Templates. + * Implementation taken from the sdc-tosca parser (deprecated method). * - * @param serviceNodes input Service Node Templates - * @param idTypeStore ID->Type mapping - * @return the processed resource models + * @param serviceVfNode + * a VF resource Node Template + * @return all service level VfModule groups with a name matching that of the supplied VF node template */ - public List processResourceToscas(List serviceNodes, Map idTypeStore) { - List resources = new LinkedList<>(); - for (NodeTemplate serviceNode : serviceNodes) { - if (serviceNode.getMetaData() != null) { - List resourceNodes = csarHelper.getNodeTemplateChildren(serviceNode); - processResourceTosca(idTypeStore, resources, serviceNode, resourceNodes); - } else { - log.warn(ApplicationMsgs.MISSING_SERVICE_METADATA, serviceNode.getName()); + private List 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(Resource resourceModel, List resourceNodeTemplates) + throws XmlArtifactGenerationException { + boolean foundProvidingService = false; + + for (NodeTemplate resourceNodeTemplate : resourceNodeTemplates) { + String nodeTypeName = resourceNodeTemplate.getType(); + Metadata metadata = resourceNodeTemplate.getMetaData(); + String metaDataType = Optional.ofNullable(metadata).map(m -> m.getValue("type")).orElse(nodeTypeName); + Resource model = Model.getModelFor(nodeTypeName, metaDataType); + + if (metadata != null && hasAllottedResource(metadata.getAllProperties()) + && model.hasWidgetType("VSERVER")) { + model = new Resource(WidgetType.valueOf("ALLOTTED_RESOURCE"), false); + Map props = new HashMap<>(); + props.put("providingService", true); + model.setProperties(props); } + + foundProvidingService |= processModel(resourceModel, metadata, model, resourceNodeTemplate.getProperties()); } + + if (resourceModel.hasWidgetType("ALLOTTED_RESOURCE") && !foundProvidingService) { + throw new XmlArtifactGenerationException(String.format(GENERATOR_AAI_PROVIDING_SERVICE_MISSING, + Optional.ofNullable(resourceModel.getModelId()).orElse(""))); + } + } + + /** + * Create an Instance Group Model and populate it with the supplied data. + * + * @param resourceModel + * the Resource node template Model + * @param memberNodes + * the Resources and Widgets belonging to the Group + * @param metaProperties + * the metadata of the Group + * @param properties + * the properties of the Group + * @return the Instance Group and Member resource models + * @throws XmlArtifactGenerationException + * if there is no configuration defined for one of the member Widgets + */ + private List processInstanceGroup(Model resourceModel, ArrayList memberNodes, + Map metaProperties, Map properties) + throws XmlArtifactGenerationException { + Resource groupModel = createInstanceGroupModel(mergeProperties(metaProperties, properties)); + resourceModel.addResource(groupModel); + List resources = Stream.of(groupModel).collect(Collectors.toList()); + + if (memberNodes != null && !memberNodes.isEmpty()) { + resources.addAll(generateResourcesAndWidgets(memberNodes, groupModel)); + } + return resources; } - private void processResourceTosca(Map idTypeStore, List resources, - NodeTemplate serviceNode, List resourceNodes) { - String resourceUuId = serviceNode.getMetaData().getValue("UUID"); - String resourceType = idTypeStore.get(resourceUuId); - if (resourceType != null) { - Model model = Model.getModelFor(resourceType); + /** + * @param memberNodes + * @param groupModel + * @return a list of Resources + * @throws XmlArtifactGenerationException + * if a member node template is a widget and there is no configuration defined for that relation's + * widget type + */ + private List generateResourcesAndWidgets(final ArrayList memberNodes, + final Resource groupModel) throws XmlArtifactGenerationException { + log.debug(String.format("Processing member nodes for Group %s (invariant UUID %s)", // + groupModel.getModelName(), groupModel.getModelId())); - log.debug("Inside Resource artifact generation for resource"); - Map serviceMetadata = serviceNode.getMetaData().getAllProperties(); - model.populateModelIdentificationInformation(serviceMetadata); + List resources = new ArrayList<>(); - // Found model from the type store so removing the same - idTypeStore.remove(model.getModelNameVersionId()); - processVfTosca(idTypeStore, model, resourceNodes); + for (NodeTemplate nodeTemplate : memberNodes) { + String nodeTypeName = nodeTemplate.getType(); + final String metadataType = nodeTemplate.getMetaData().getValue("type"); - // Process group information from tosca for vfModules - if (csarHelper.getServiceVfList() != null) { - processVfModules(resources, model, serviceNode); - } + log.debug(String.format("Get model for %s (metadata type %s)", nodeTypeName, metadataType)); + Resource memberModel = Model.getModelFor(nodeTypeName, metadataType); + + if (memberModel != null) { + memberModel.populateModelIdentificationInformation(nodeTemplate.getMetaData().getAllProperties()); - if (hasSubCategoryTunnelXConnect(serviceMetadata) && hasAllottedResource(serviceMetadata)) { - model.addWidget(new TunnelXconnectWidget()); + log.debug(String.format("Generating grouped %s (%s) from TOSCA type %s", + memberModel.getClass().getSuperclass().getSimpleName(), memberModel.getClass(), nodeTypeName)); + + addRelatedModel(groupModel, memberModel); + if (memberModel.getModelType() == ModelType.RESOURCE) { + resources.add(memberModel); + } } - resources.add((Resource) model); } + return resources; } - private void processVfModules(List resources, Model resourceModel, NodeTemplate serviceNode) { - // Get the customisation UUID for each VF node and use it to get its Groups - String uuid = csarHelper.getNodeTemplateCustomizationUuid(serviceNode); - List serviceGroups = csarHelper.getVfModulesByVf(uuid); + /** + * @param resources + * @param vfModel + * @param groupDefinition + * @param serviceNode + * @param groupModel + * @throws XmlArtifactGenerationException + * if the configured widget mappings do not support the widget type of a VF Module + */ + private void processVfModule(List resources, Model vfModel, Group groupDefinition, + NodeTemplate serviceNode, Resource groupModel) throws XmlArtifactGenerationException { + groupModel.populateModelIdentificationInformation( + mergeProperties(groupDefinition.getMetadata().getAllProperties(), groupDefinition.getProperties())); - // Process each VF Group - for (Group serviceGroup : serviceGroups) { - Model groupModel = Model.getModelFor(serviceGroup.getType()); - if (groupModel instanceof VfModule) { - processVfModule(resources, resourceModel, serviceGroup, serviceNode, (VfModule) groupModel); - } + + 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 + if (!resources.contains(groupModel)) { + resources.add(groupModel); } } - private void processVfModule(List resources, Model model, Group groupDefinition, NodeTemplate serviceNode, - VfModule groupModel) { - // Populate group with metadata properties - groupModel.populateModelIdentificationInformation(groupDefinition.getMetadata().getAllProperties()); - // Populate group with non-metadata properties - Map groupProperties = groupDefinition.getProperties(); - Map properties = populateStringProperties(groupProperties); - groupModel.populateModelIdentificationInformation(properties); + /** + * @param substitutionMappings + * @param vfModuleInvariantUuid + * @return all serviceNode child Node Templates which are members of the first VF Module Group + */ + private List 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 filterByVfModuleInvariantUuid(String vfModuleInvariantUuid) { + return nt -> (nt.getMetadata() != null && vfModuleInvariantUuid + .equals(nt.getMetadata().getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELINVARIANTUUID))); + } - // Get names of the members of the service group - List members = csarHelper.getMembersOfVfModule(serviceNode, groupDefinition); + /** + * @param groupModel + * @param members + * @throws XmlArtifactGenerationException + * if the configured widget mappings do not support the widget type of a member + */ + private void processVfModuleGroup(Resource groupModel, List members) + throws XmlArtifactGenerationException { if (members != null && !members.isEmpty()) { + // Get names of the members of the service group List memberNames = members.stream().map(NodeTemplate::getName).collect(Collectors.toList()); groupModel.setMembers(memberNames); for (NodeTemplate member : members) { processGroupMembers(groupModel, member); } } - - model.addResource(groupModel); // Added group (VfModule) to the (VF) model - // Check if we have already encountered the same VfModule across all the artifacts - if (!resources.contains(groupModel)) { - resources.add(groupModel); - } } - private void processGroupMembers(Model group, NodeTemplate member) { - Model resourceNode; - // L3-network inside vf-module to be generated as Widget a special handling. - if (member.getType().contains("org.openecomp.resource.vl")) { - resourceNode = new L3NetworkWidget(); - } else { - resourceNode = Model.getModelFor(member.getType()); + /** + * Process the Widget members of a VF Module Group + * + * @param group + * the group resource model + * @param member + * the group member to process + * @throws XmlArtifactGenerationException + * if the configured widget mappings do not support the widget type of the member + */ + private void processGroupMembers(Resource group, NodeTemplate member) throws XmlArtifactGenerationException { + Resource resource = Model.getModelFor(member.getType()); + + log.debug(member.getType() + " mapped to " + resource); + + if (resource.hasWidgetType("L3_NET")) { + // An l3-network inside a vf-module is treated as a Widget + resource.setModelType(ModelType.WIDGET); } - if (resourceNode != null && !(resourceNode instanceof Resource)) { - Widget widget = (Widget) resourceNode; + + if (resource.getModelType() == ModelType.WIDGET) { + Widget widget = Widget.createWidget(resource.getWidgetType()); widget.addKey(member.getName()); // Add the widget element encountered to the Group model group.addWidget(widget); } } - private String correctNodeType(NodeTemplate nodeType) { - String correctedNodeType = nodeType.getType(); - Metadata metadata = nodeType.getMetaData(); - if (metadata != null && hasAllottedResource(metadata.getAllProperties())) { - if (nodeType.getType().contains("org.openecomp.resource.vf.")) { - correctedNodeType = "org.openecomp.resource.vf.allottedResource"; - } - if (nodeType.getType().contains("org.openecomp.resource.vfc.")) { - correctedNodeType = "org.openecomp.resource.vfc.AllottedResource"; - } - } - return correctedNodeType; - } - - private boolean hasAllottedResource(Map metadata) { - return ALLOTTED_RESOURCE.equals(metadata.get(CATEGORY)); - } - - private boolean hasSubCategoryTunnelXConnect(Map metadata) { - return TUNNEL_XCONNECT.equals(metadata.get(SUBCATEGORY)); - } - /** * Create a Map of property name against String property value from the input Map * - * @param inputMap The input Map + * @param inputMap + * The input Map * @return Map of property name against String property value */ private Map populateStringProperties(Map inputMap) { @@ -290,33 +449,47 @@ public class ArtifactGeneratorToscaParser { e -> e.getValue().getValue() == null ? "" : e.getValue().getValue().toString())); } - private void processVfTosca(Map idTypeStore, Model resourceModel, - List resourceNodes) { - boolean providingServiceFound = false; - - for (NodeTemplate resourceNodeTemplate : resourceNodes) { - Model resourceNode = Model.getModelFor(correctNodeType(resourceNodeTemplate)); - if (resourceNode instanceof ProvidingService) { - providingServiceFound = true; - Map nodeProperties = resourceNodeTemplate.getProperties(); - if (nodeProperties.get("providing_service_uuid") == null - || nodeProperties.get("providing_service_invariant_uuid") == null) { - throw new IllegalArgumentException(String.format(GENERATOR_AAI_PROVIDING_SERVICE_METADATA_MISSING, - resourceModel.getModelId())); - } - Map properties = populateStringProperties(nodeProperties); - properties.put(VERSION, "1.0"); - resourceNode.populateModelIdentificationInformation(properties); - resourceModel.addResource((Resource) resourceNode); - } else if (resourceNode instanceof Resource && !(resourceNode.getWidgetType().equals(Widget.Type.L3_NET))) { - idTypeStore.put(resourceNode.getModelNameVersionId(), correctNodeType(resourceNodeTemplate)); - resourceModel.addResource((Resource) resourceNode); + /** + * If the specified resourceNode is a type of Resource, add it to the specified resourceModel. If the Resource type + * is ProvidingService then return true, otherwise return false. + * + * @param resourceModel + * parent Resource + * @param metaData + * for populating the Resource IDs + * @param resourceNode + * any Model (will be ignored if not a Resource) + * @param nodeProperties + * the node properties + * @return whether or not a ProvidingService was processed + */ + private boolean processModel(Model resourceModel, Metadata metaData, Resource resourceNode, + Map nodeProperties) { + boolean foundProvidingService = resourceNode != null + && (boolean) Optional.ofNullable(resourceNode.getProperties().get("providingService")).orElse(false); + + if (foundProvidingService) { + processProvidingService(resourceModel, resourceNode, nodeProperties); + } else if (resourceNode != null && resourceNode.getModelType() == ModelType.RESOURCE + && !resourceNode.hasWidgetType("L3_NET")) { + if (metaData != null) { + resourceNode.populateModelIdentificationInformation(metaData.getAllProperties()); } + resourceModel.addResource(resourceNode); } + return foundProvidingService; + } - if (resourceModel instanceof AllotedResource && !providingServiceFound) { + private void processProvidingService(Model resourceModel, Resource resourceNode, + Map nodeProperties) { + if (nodeProperties == null || nodeProperties.get("providing_service_uuid") == null + || nodeProperties.get("providing_service_invariant_uuid") == null) { throw new IllegalArgumentException( - String.format(GENERATOR_AAI_PROVIDING_SERVICE_MISSING, resourceModel.getModelId())); + String.format(GENERATOR_AAI_PROVIDING_SERVICE_METADATA_MISSING, resourceModel.getModelId())); } + Map properties = populateStringProperties(nodeProperties); + properties.put(VERSION, "1.0"); + resourceNode.populateModelIdentificationInformation(properties); + resourceModel.addResource(resourceNode); } }