From 1cfb08779ea0e00be69e072a940b3063e049fe6b Mon Sep 17 00:00:00 2001 From: Ofir Sonsino Date: Wed, 31 Jan 2018 17:19:00 +0200 Subject: org.onap migration Change-Id: I52f0b2851f2c765752b6d21f49b32136d7d72a3d Issue-ID: VID-86 Signed-off-by: Ofir Sonsino --- .../org/onap/vid/asdc/parser/ToscaParserImpl2.java | 354 +++++++++++++++++++++ 1 file changed, 354 insertions(+) create mode 100644 vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java (limited to 'vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java') diff --git a/vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java b/vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java new file mode 100644 index 000000000..4a5ab3af3 --- /dev/null +++ b/vid-app-common/src/main/java/org/onap/vid/asdc/parser/ToscaParserImpl2.java @@ -0,0 +1,354 @@ +package org.onap.vid.asdc.parser; + +import org.onap.vid.asdc.beans.Service; +import org.onap.vid.model.*; +import org.openecomp.sdc.tosca.parser.api.ISdcCsarHelper; +import org.openecomp.sdc.tosca.parser.exceptions.SdcToscaParserException; +import org.openecomp.sdc.tosca.parser.impl.FilterType; +import org.openecomp.sdc.tosca.parser.impl.SdcToscaParserFactory; +import org.openecomp.sdc.tosca.parser.impl.SdcTypes; +import org.openecomp.sdc.toscaparser.api.*; +import org.openecomp.sdc.toscaparser.api.parameters.Input; + +import java.nio.file.Path; +import java.util.*; +import java.util.stream.Collectors; + +import static java.util.stream.Collectors.toMap; + +public class ToscaParserImpl2 { + + + public class Constants { + public final static String uuid = "UUID"; + public final static String description = "description"; + public final static String serviceType = "serviceType"; + public final static String serviceRole = "serviceRole"; + public final static String ecompGeneratedNaming = "ecompGeneratedNaming"; + + public final static String customizationUUID = "customizationUUID"; + public final static String vfModuleModelVersion = "vfModuleModelVersion"; + public final static String vfModuleModelCustomizationUUID = "vfModuleModelCustomizationUUID"; + public final static String volume_group = "volume_group"; + public final static String vfModuleModelInvariantUUID = "vfModuleModelInvariantUUID"; + public final static String vfModuleModelUUID = "vfModuleModelUUID"; + public final static String invariantUUID = "invariantUUID"; + public final static String version = "version"; + public final static String name = "name"; + public final static String category = "category"; + public final static String vfModuleModelName = "vfModuleModelName"; + public final static String getInput = "get_input"; + + public final static String instantiationType = "instantiationType"; + //Instantiation Types + public final static String both = "Both"; + public final static String macro = "Macro"; + public final static String aLaCarte = "A-La-Carte"; + public final static String clientConfig = "ClientConfig"; + + + } + + public ToscaParserImpl2() { + + } + + public ServiceModel makeServiceModel(Path path, Service asdcServiceMetadata) throws Exception { + ServiceModel serviceModel = new ServiceModel(); + SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance(); + ISdcCsarHelper sdcCsarHelper = factory.getSdcCsarHelper(path.toFile().getAbsolutePath(),false); + serviceModel.setService(extractServiceFromCsar(asdcServiceMetadata, sdcCsarHelper)); + + serviceModel.setVolumeGroups(extractVolumeGroups(sdcCsarHelper)); + serviceModel.setVfModules(extractVfModuleFromCsar(sdcCsarHelper)); + serviceModel.setVnfs(extractVnfsFromCsar(serviceModel,sdcCsarHelper)); + serviceModel.setConfigurations(extractPortMirroringConfigFromCsar(sdcCsarHelper)); + serviceModel.setServiceProxies(extractServiceProxyFromCsar(sdcCsarHelper)); + serviceModel.setNetworks(extractNetworksFromCsar(sdcCsarHelper)); + serviceModel.setPnfs(extractPnfsFromCsar(sdcCsarHelper)); + return serviceModel; + } + + private org.onap.vid.model.Service extractServiceFromCsar(Service asdcServiceMetadata, ISdcCsarHelper csarHelper) throws SdcToscaParserException { + org.onap.vid.model.Service service = new org.onap.vid.model.Service(); + + service.setName(csarHelper.getServiceMetadata().getValue(Constants.name)); + service.setCategory(csarHelper.getServiceMetadata().getValue(Constants.category)); + service.setInvariantUuid(csarHelper.getServiceMetadata().getValue(Constants.invariantUUID)); + service.setUuid(csarHelper.getServiceMetadata().getValue(Constants.uuid)); + service.setVersion(asdcServiceMetadata.getVersion()); + service.setDescription(csarHelper.getServiceMetadata().getValue(Constants.description)); + service.setInputs(inputsListToInputsMap(csarHelper.getServiceInputs())); + service.setServiceEcompNaming(csarHelper.getServiceMetadata().getValue(Constants.ecompGeneratedNaming)); + service.setServiceType(csarHelper.getServiceMetadata().getValue(Constants.serviceType)); + service.setServiceRole(csarHelper.getServiceMetadata().getValue(Constants.serviceRole)); + service.setInstantiationType(validateInstantiationType(csarHelper)); + return service; + } + + + private Map extractVnfsFromCsar(ServiceModel serviceModel,ISdcCsarHelper csarHelper) { + List nodeTemplates = csarHelper.getServiceVfList(); + Map vnfsMaps = new HashMap(); + + for (NodeTemplate nodeTemplate : nodeTemplates) { + VNF vnf = new VNF(); + populateNodeFromNodeTemplate(nodeTemplate, csarHelper, vnf); + + vnf.setModelCustomizationName(nodeTemplate.getName()); + Map vfModuleHashMap = getVfModulesFromVF(csarHelper, vnf.getCustomizationUuid()); + vnf.setVfModules(vfModuleHashMap); + + Map volumeGroupMap = getVolumeGroupsFromVF(csarHelper, vnf.getCustomizationUuid()); + vnf.setVolumeGroups(volumeGroupMap); + + vnfsMaps.put(nodeTemplate.getName(), vnf); + } + return vnfsMaps; + } + + private Map extractPortMirroringConfigFromCsar(ISdcCsarHelper csarHelper) { + List nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.CONFIGURATION); + Map configMaps = new HashMap<>(); + + for (NodeTemplate nodeTemplate : nodeTemplates) { + PortMirroringConfig pmConfig = new PortMirroringConfig(); + populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pmConfig); + + pmConfig.setModelCustomizationName(nodeTemplate.getName()); + pmConfig.setRequirementAssignments(nodeTemplate.getRequirements()); + setSourceAndCollectorProxyNodes(csarHelper, pmConfig, nodeTemplate); + + configMaps.put(nodeTemplate.getName(), pmConfig); + } + + return configMaps; + } + + private Map extractServiceProxyFromCsar(ISdcCsarHelper csarHelper) { + List nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.SERVICE_PROXY); + Map serviceProxies = new HashMap<>(); + for (NodeTemplate nodeTemplate: nodeTemplates) { + ServiceProxy serviceProxy = new ServiceProxy(); + populateNodeFromNodeTemplate(nodeTemplate, csarHelper, serviceProxy); + + Map metadata = nodeTemplate.getMetaData().getAllProperties(); + serviceProxy.setSourceModelUuid(metadata.get("sourceModelUuid")); + serviceProxy.setSourceModelInvariant(metadata.get("sourceModelInvariant")); + serviceProxy.setSourceModelName(metadata.get("sourceModelName")); + + serviceProxies.put(nodeTemplate.getName(), serviceProxy); + } + + return serviceProxies; + } + + private void setSourceAndCollectorProxyNodes(ISdcCsarHelper csarHelper, PortMirroringConfig portMirroringConfig, NodeTemplate nodeTemplate) { + RequirementAssignments requirementAssignments = nodeTemplate.getRequirements(); + + List sourceNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("source").getAll()); + portMirroringConfig.setSourceNodes(sourceNodes); + + List collectorNodes = getRequirementsNodesNames(requirementAssignments.getRequirementsByName("collector").getAll()); + if (!collectorNodes.isEmpty()) { // vprobe + portMirroringConfig.setCollectorNodes(collectorNodes); + } else { // pprobe - configuration by policy + String collectorNodeName = csarHelper.getNodeTemplatePropertyLeafValue(nodeTemplate, "collector_node"); + if (collectorNodeName != null) { + portMirroringConfig.setCollectorNodes(Arrays.asList(collectorNodeName)); + portMirroringConfig.setConfigurationByPolicy(true); + } + } + } + + private List getRequirementsNodesNames(List requirements) { + + List requirementsNodes = new ArrayList<>(); + if (requirements != null && requirements.size() > 0) { + requirementsNodes = requirements.stream().map(RequirementAssignment::getNodeTemplateName).collect(Collectors.toList()); + } + + return requirementsNodes; + } + + Map getVfModulesFromVF(ISdcCsarHelper csarHelper, String vfUuid) { + List vfModulesByVf = csarHelper.getVfModulesByVf(vfUuid); + return vfModulesByVf.stream() + .collect(toMap(Group::getName, this::populateVfModuleFromGroup)); + } + + Map getVolumeGroupsFromVF(ISdcCsarHelper csarHelper, String vfCustomizationUuid) { + List vfModulesByVf = csarHelper.getVfModulesByVf(vfCustomizationUuid); + return vfModulesByVf.stream() + .filter((group -> isVolumeGroup(group))) + .collect(toMap(Group::getName, this::populateVolumeGroupFromGroup)); + } + + private static Boolean isVolumeGroup(Group group) { + return Boolean.valueOf(group.getPropertyValue(Constants.volume_group).toString()); + } + + private Map extractNetworksFromCsar(ISdcCsarHelper csarHelper) { + List nodeTemplates = csarHelper.getServiceVlList(); + Map networksMap = new HashMap(); + + for (NodeTemplate nodeTemplate : nodeTemplates) { + Network newNetwork = new Network(); + populateNodeFromNodeTemplate(nodeTemplate, csarHelper, newNetwork); + newNetwork.setModelCustomizationName(nodeTemplate.getName()); + networksMap.put(nodeTemplate.getName(), newNetwork); + } + return networksMap; + } + + private Map extractPnfsFromCsar(ISdcCsarHelper csarHelper) { + List nodeTemplates = csarHelper.getServiceNodeTemplateBySdcType(SdcTypes.PNF); + HashMap pnfHashMap = new HashMap<>(); + + for (NodeTemplate nodeTemplate : nodeTemplates) { + Node pnf = new Node(); + populateNodeFromNodeTemplate(nodeTemplate, csarHelper, pnf); + pnfHashMap.put(nodeTemplate.getName(), pnf); + } + return pnfHashMap; + } + + private Map extractVfModuleFromCsar(ISdcCsarHelper csarHelper) { + List serviceVfList = csarHelper.getServiceVfList(); + HashMap vfModuleHashMap = new HashMap<>(); + + for (NodeTemplate nodeTemplate : serviceVfList) { + Map nodeTemplateVfModule = + getVfModulesFromVF(csarHelper, nodeTemplate.getMetaData().getValue(Constants.customizationUUID)); + vfModuleHashMap.putAll(nodeTemplateVfModule); + } + return vfModuleHashMap; + } + + private Map extractVolumeGroups(ISdcCsarHelper csarHelper) { + HashMap volumeGroupHashMap = new HashMap<>(); + for (NodeTemplate nodeTemplate : csarHelper.getServiceVfList()) { + Map nodeTemplateVolumeGroups = + getVolumeGroupsFromVF(csarHelper, csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate)); + volumeGroupHashMap.putAll(nodeTemplateVolumeGroups); + } + return volumeGroupHashMap; + } + + private Map inputsListToInputsMap(List inputList) { + Map inputs = new HashMap<>(); + for (org.openecomp.sdc.toscaparser.api.parameters.Input input : inputList) { + inputs.put(input.getName(), convertInput(input, new org.onap.vid.asdc.beans.tosca.Input())); + } + return inputs; + } + + private Node populateNodeFromNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode) { + newNode.setCustomizationUuid(csarHelper.getNodeTemplateCustomizationUuid(nodeTemplate)); + newNode.setDescription(nodeTemplate.getMetaData().getValue(Constants.description)); + newNode.setInvariantUuid(nodeTemplate.getMetaData().getValue(Constants.invariantUUID)); + newNode.setUuid(nodeTemplate.getMetaData().getValue(Constants.uuid)); + newNode.setName(nodeTemplate.getMetaData().getValue(Constants.name)); + newNode.setVersion(nodeTemplate.getMetaData().getValue(Constants.version)); + newNode.setInputs(extractInputsAndCommandsForNodeTemplate(nodeTemplate, csarHelper, newNode)); + newNode.setType(nodeTemplate.getMetaData().getValue("type")); + Map propertiesMap = setPropertiesOfVnf(nodeTemplate.getPropertiesObjects()); + newNode.setProperties(propertiesMap); + return newNode; + } + + private VfModule populateVfModuleFromGroup(Group group){ + VfModule vfModule = new VfModule(); + + vfModule.setVersion(group.getMetadata().getValue(Constants.vfModuleModelVersion)); + vfModule.setCustomizationUuid(group.getMetadata().getValue(Constants.vfModuleModelCustomizationUUID)); + vfModule.setModelCustomizationName(group.getMetadata().getValue(Constants.vfModuleModelName)); + vfModule.setName(group.getMetadata().getValue(Constants.vfModuleModelName)); + vfModule.setVolumeGroupAllowed(isVolumeGroup(group)); + vfModule.setDescription(group.getDescription()); + vfModule.setInvariantUuid(group.getMetadata().getValue(Constants.vfModuleModelInvariantUUID)); + vfModule.setUuid(group.getMetadata().getValue(Constants.vfModuleModelUUID)); + return vfModule; + } + + private VolumeGroup populateVolumeGroupFromGroup(Group group){ + VolumeGroup volumeGroup = new VolumeGroup(); + volumeGroup.setDescription(group.getDescription()); + volumeGroup.setInvariantUuid(group.getMetadata().getValue(Constants.vfModuleModelInvariantUUID)); + volumeGroup.setName(group.getMetadata().getValue(Constants.vfModuleModelName)); + volumeGroup.setModelCustomizationName(group.getMetadata().getValue(Constants.vfModuleModelName)); + volumeGroup.setVersion(group.getMetadata().getValue(Constants.vfModuleModelVersion)); + volumeGroup.setUuid(group.getMetadata().getValue(Constants.vfModuleModelUUID)); + volumeGroup.setCustomizationUuid(group.getMetadata().getValue(Constants.vfModuleModelCustomizationUUID)); + + return volumeGroup; + } + + + private Map extractInputsAndCommandsForNodeTemplate(NodeTemplate nodeTemplate, ISdcCsarHelper csarHelper, Node newNode){ + Map inputMap = new HashMap<>(); + Map commandPropertyMap = new HashMap<>(); + + List inputs = csarHelper.getServiceInputs(); + Map properties = csarHelper.filterNodeTemplatePropertiesByValue(nodeTemplate, FilterType.CONTAINS, Constants.getInput); + for (Map.Entry property : properties.entrySet()) { + String inputKey = property.getValue(); + String key = extractInputValue(inputKey); + for (Input input: inputs){ + if(input.getName().equals(key)){ + org.onap.vid.asdc.beans.tosca.Input localInput = new org.onap.vid.asdc.beans.tosca.Input(); + localInput = convertInput(input, localInput); + String name = property.getKey(); + commandPropertyMap.put(name, extractCommands(name, key)); + inputMap.put(name, localInput); + } + } + } + newNode.setCommands(commandPropertyMap); + return inputMap; + } + + private String extractInputValue(String inputKey) { + return inputKey.substring(inputKey.indexOf(":") + 1); + } + + private org.onap.vid.asdc.beans.tosca.Input convertInput(Input parserInput, org.onap.vid.asdc.beans.tosca.Input localInput){ + localInput.setDefault(parserInput.getDefault()); + localInput.setDescription(parserInput.getDescription()); + localInput.setRequired(parserInput.isRequired()); + localInput.setType(parserInput.getType()); + localInput.setConstraints(parserInput.getConstraints()); +// localInput.setentry_schema() + return localInput; + } + + private CommandProperty extractCommands(String displayName, String inputName){ + CommandProperty commandProperty = new CommandProperty(); + commandProperty.setDisplayName(displayName); + commandProperty.setCommand(Constants.getInput); + commandProperty.setInputName(inputName); + return commandProperty; + } + + private Map setPropertiesOfVnf(List properties) { + Map propertiesMap = new HashMap(); + for (Property property : properties) { + propertiesMap.put(property.getName(), property.getValue().toString()); + } + return propertiesMap; + } + + private String validateInstantiationType(ISdcCsarHelper csarHelper){ + String instantiationType = csarHelper.getServiceMetadata().getValue(Constants.instantiationType); + String validatedInstantiationType = Constants.clientConfig; + if(instantiationType != null && !instantiationType.isEmpty()){ + if(instantiationType.equalsIgnoreCase(Constants.macro) || instantiationType.equalsIgnoreCase(Constants.both)) + validatedInstantiationType = Constants.macro; + else if(instantiationType.equalsIgnoreCase(Constants.aLaCarte)) + validatedInstantiationType = Constants.aLaCarte; + } + return validatedInstantiationType; + } + + +} \ No newline at end of file -- cgit 1.2.3-korg