diff options
Diffstat (limited to 'test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ToscaParserUtils.java')
-rw-r--r-- | test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ToscaParserUtils.java | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ToscaParserUtils.java b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ToscaParserUtils.java new file mode 100644 index 0000000000..26fac7fd6e --- /dev/null +++ b/test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/ToscaParserUtils.java @@ -0,0 +1,361 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.ci.tests.utils; + +import static org.testng.AssertJUnit.assertNotNull; + +import java.io.File; +import java.io.FileInputStream; +import java.util.Map; +import java.util.Set; + +import org.openecomp.sdc.ci.tests.datatypes.enums.ToscaKeysEnum; +import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaDefinition; +import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaGroupsTopologyTemplateDefinition; +import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaNodeTemplatesTopologyTemplateDefinition; +import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaSubstitutionMappingsDefinition; +import org.openecomp.sdc.ci.tests.tosca.datatypes.ToscaTopologyTemplateDefinition; +import org.openecomp.sdc.ci.tests.utils.validation.CsarValidationUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.yaml.snakeyaml.TypeDescription; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; +import org.yaml.snakeyaml.introspector.PropertyUtils; + +public class ToscaParserUtils { + + private static Logger log = LoggerFactory.getLogger(ToscaParserUtils.class.getName()); + + public static ToscaDefinition parseToscaYamlToJavaObject(String csarUUID) throws Exception { + + ToscaDefinition toscaDefinition = null; + String TOSCAMetaLocation = "TOSCA-Metadata/TOSCA.meta"; + Map<?, ?> map = getToscaYamlMap(csarUUID, TOSCAMetaLocation); + assertNotNull("Tosca Entry-Definitions is null", map); + if (map != null) { + File definitionYamlLocation = (File) map.get("Entry-Definitions"); + toscaDefinition = parseToscaYamlToJavaObject(definitionYamlLocation); + } + return toscaDefinition; + + } + + public static ToscaDefinition parseToscaYamlToJavaObject(File path) throws Exception { + + ToscaDefinition toscaDefinition = null; + +// File path = new File("C:/Data/D2.0/TOSCA_Ex/Definitions/tosca_definition_version.yaml"); + FileInputStream fis = null; + try { + fis = new FileInputStream(path); + + } catch (Exception e) { + System.out.println("Exception: " + e); + } + + Constructor constructor = getConstructor(); + + Yaml yaml = new Yaml(constructor); + try { + toscaDefinition = (ToscaDefinition) yaml.load(fis); + } catch (Exception e) { + log.debug("Failed to parse tosca yaml file"); + System.out.println("Exception: " + e); + } finally { + fis.close(); + } + return toscaDefinition; + + } + + public static ToscaDefinition parseToscaYamlPayloadToJavaObject(String payload){ + + ToscaDefinition toscaDefinition = null; + Constructor constructor = getConstructor(); + + Yaml yaml = new Yaml(constructor); + try { + toscaDefinition = (ToscaDefinition) yaml.load(payload); + } catch (Exception e) { + log.debug("Failed to parse tosca yaml file"); + System.out.println("Exception: " + e); + } + return toscaDefinition; + + } + + + public static Constructor getConstructor() { + Constructor constructor = new Constructor(ToscaDefinition.class); + constructor.addTypeDescription(ToscaDefinition.getTypeDescription()); + constructor.addTypeDescription(ToscaTopologyTemplateDefinition.getTypeDescription()); + constructor.addTypeDescription(ToscaNodeTemplatesTopologyTemplateDefinition.getTypeDescription()); + constructor.addTypeDescription(ToscaGroupsTopologyTemplateDefinition.getTypeDescription()); + constructor.addTypeDescription(ToscaSubstitutionMappingsDefinition.getTypeDescription()); + +// Skip properties which are found in YAML, but not found in POJO + PropertyUtils propertyUtils = new PropertyUtils(); + propertyUtils.setSkipMissingProperties(true); + constructor.setPropertyUtils(propertyUtils); + return constructor; + } + + public static Map<?, ?> getToscaYamlMap(String csarUUID, String fileLocation) throws Exception { + String csarPayload = CsarValidationUtils.getCsarPayload(csarUUID, fileLocation); + if (csarPayload != null) { + Yaml yaml = new Yaml(); + Map<?, ?> map = (Map<?, ?>) yaml.load(csarPayload); + return map; + } + return null; + } + +/* public static Map<?, ?> getToscaYamlMap(String csarUUID, String fileLocation) throws Exception { + String csarPayload = CsarValidationUtils.getCsarPayload(csarUUID, fileLocation); + if (csarPayload != null) { + Yaml yaml = new Yaml(); + Map<?, ?> map = (Map<?, ?>) yaml.load(csarPayload); + return map; + } + return null; + } + + public static ToscaDefinition getToscaDefinitionObjectByCsarUuid(String csarUUID) throws Exception { + + String TOSCAMetaLocation = "TOSCA-Metadata/TOSCA.meta"; + Map<?, ?> map = getToscaYamlMap(csarUUID, TOSCAMetaLocation); + assertNotNull("Tosca Entry-Definitions is null", map); + if (map != null) { + String definitionYamlLocation = (String) map.get("Entry-Definitions"); + Map<?, ?> toscaMap = getToscaYamlMap(csarUUID, definitionYamlLocation); + assertNotNull("Tosca definition is null", toscaMap); + if (toscaMap != null) { + ToscaDefinition toscaDefinition = new ToscaDefinition(); + Set<?> keySet = toscaMap.keySet(); + for (Object key : keySet) { + ToscaKeysEnum toscaKey = ToscaKeysEnum.findToscaKey((String) key); + switch (toscaKey) { + case TOSCA_DEFINITION_VERSION: + getToscaDefinitionVersion(toscaMap, toscaDefinition); + break; + case NODE_TYPES: + getToscaNodeTypes(toscaMap, toscaDefinition); + break; + case TOPOLOGY_TEMPLATE: + getToscaTopologyTemplate(toscaMap, toscaDefinition); + break; + case IMPORTS: + // toscaMap.get("imports"); + break; + default: + break; + } + } + return toscaDefinition; + } + } + return null; + + } + + public static void getToscaDefinitionVersion(Map<?, ?> toscaMap, ToscaDefinition toscaDefinition) { + if (toscaMap.get("tosca_definitions_version") != null) { + toscaDefinition.setTosca_definitions_version((String) toscaMap.get("tosca_definitions_version")); + } + } + + // spec 90 page + public static void getToscaNodeTypes(Map<?, ?> toscaMap, ToscaDefinition toscaDefinition) { + @SuppressWarnings("unchecked") + Map<String, Map<String, String>> nodeTypes = (Map<String, Map<String, String>>) toscaMap.get("node_types"); + Map<String, ToscaNodeTypesDefinition> listToscaNodeTypes = new HashMap<String, ToscaNodeTypesDefinition>(); + if (nodeTypes != null) { + for (Map.Entry<String, Map<String, String>> entry : nodeTypes.entrySet()) { + ToscaNodeTypesDefinition toscaNodeTypes = new ToscaNodeTypesDefinition(); + String toscaNodeName = entry.getKey(); + toscaNodeTypes.setName(toscaNodeName); + + Map<String, String> toscaNodeType = entry.getValue(); + if (toscaNodeType != null) { + Set<Entry<String, String>> entrySet = toscaNodeType.entrySet(); + if (entrySet != null) { + // boolean found = false; + for (Entry<String, String> toscaNodeTypeMap : entrySet) { + String key = toscaNodeTypeMap.getKey(); + if (key.equals("derived_from")) { + String derivedFrom = toscaNodeTypeMap.getValue(); + toscaNodeTypes.setDerived_from(derivedFrom); + // found = true; + break; + } else { + continue; + } + + } + // if (found == false) { + // System.out.println("Tosca file not valid, + // derived_from not found"); + // } + } + + } +// listToscaNodeTypes.add(toscaNodeTypes); + listToscaNodeTypes.put(toscaNodeName, toscaNodeTypes); + } + toscaDefinition.setNode_types(listToscaNodeTypes); + } + } + + public static void getToscaTopologyTemplate(Map<?, ?> toscaMap, ToscaDefinition toscaDefinition) { + ToscaTopologyTemplateDefinition toscaTopologyTemplate = new ToscaTopologyTemplateDefinition(); + @SuppressWarnings("unchecked") + Map<String, Map<String, Object>> topologyTemplateMap = (Map<String, Map<String, Object>>) toscaMap.get("topology_template"); +// List<ToscaNodeTemplatesTopologyTemplateDefinition> listToscaNodeTemplates = new ArrayList<>(); + Map<String,ToscaNodeTemplatesTopologyTemplateDefinition> mapToscaNodeTemplates = new HashMap<String, ToscaNodeTemplatesTopologyTemplateDefinition>(); + + if (topologyTemplateMap != null) { + getToscaNodeTemplates(topologyTemplateMap, mapToscaNodeTemplates); + } +// toscaTopologyTemplate.setToscaNodeTemplatesTopologyTemplateDefinition(listToscaNodeTemplates); + toscaTopologyTemplate.setNode_templates(mapToscaNodeTemplates); + toscaDefinition.setTopology_template(toscaTopologyTemplate); + } + + public static void getToscaNodeTemplates(Map<String, Map<String, Object>> topologyTemplateMap, Map<String,ToscaNodeTemplatesTopologyTemplateDefinition> mapToscaNodeTemplates) { + Map<String, Object> nodeTemplatesMap = topologyTemplateMap.get("node_templates"); + if (nodeTemplatesMap != null) { + + for (Entry<String, Object> nodeTemplates : nodeTemplatesMap.entrySet()) { + ToscaNodeTemplatesTopologyTemplateDefinition toscaNodeTemplates = new ToscaNodeTemplatesTopologyTemplateDefinition(); + getToscaNodeTemplatesName(nodeTemplates, toscaNodeTemplates); + + @SuppressWarnings("unchecked") + Map<String, Object> node = (Map<String, Object>) nodeTemplates.getValue(); + getNodeTemplatesType(toscaNodeTemplates, node); + getToscaNodeTemplateProperties(toscaNodeTemplates, node); + getToscaNodeTemplateRequirements(toscaNodeTemplates, node); + mapToscaNodeTemplates.putAll(mapToscaNodeTemplates); + } + } + } + + public static void getToscaNodeTemplateRequirements(ToscaNodeTemplatesTopologyTemplateDefinition toscaNodeTemplates, Map<String, Object> node) { +//// List<ToscaRequirementsNodeTemplatesDefinition> toscaRequirements = new ArrayList<>(); +// List<Map<String, ToscaRequirementsNodeTemplatesDefinition>> toscaRequirements = new ArrayList<>(); +// if (node.get("requirements") != null) { +// @SuppressWarnings("unchecked") +// List<Map<String, Object>> requirementList = (List<Map<String, Object>>) node.get("requirements"); +// for (int i = 0; i < requirementList.size(); i++) { +// for (Map.Entry<String, Object> requirement : requirementList.get(i).entrySet()) { +// ToscaRequirementsNodeTemplatesDefinition toscaRequirement = new ToscaRequirementsNodeTemplatesDefinition(); +// if (requirement.getKey() != null) { +// String requirementName = requirement.getKey(); +// toscaRequirement.setName(requirementName); +// } else { +// log.debug("Tosca file not valid, requirements should contain name"); +// } +// +// @SuppressWarnings("unchecked") +// Map<String, String> requirementMap = (Map<String, String>) requirement.getValue(); +// Set<Entry<String, String>> entrySet = requirementMap.entrySet(); +// if (entrySet != null) { +// for (Entry<String, String> requirementField : entrySet) { +// String key = requirementField.getKey(); +// switch (key) { +// case "capability": +// if (requirementMap.get(key) != null) { +// String capability = (String) requirementMap.get(key); +// toscaRequirement.setCapability(capability); +// break; +// } else { +// continue; +// } +// case "node": +// if (requirementMap.get(key) != null) { +// String requirementNode = (String) requirementMap.get(key); +// toscaRequirement.setNode(requirementNode); +// break; +// } else { +// continue; +// } +// case "relationship": +// if (requirementMap.get(key) != null) { +// String relationship = (String) requirementMap.get(key); +// toscaRequirement.setRelationship(relationship); +// break; +// } else { +// continue; +// } +// default: +// break; +// } +// } +// } +//// toscaRequirements.add(toscaRequirement); +// toscaRequirements.add(requirementMap); +// } +// } +// } +//// toscaNodeTemplates.setRequirements(toscaRequirements); +// toscaNodeTemplates.setRequirements(requirements); + + } + + public static void getToscaNodeTemplateProperties(ToscaNodeTemplatesTopologyTemplateDefinition toscaNodeTemplates, + Map<String, Object> node) { +// List<ToscaPropertiesNodeTemplatesDefinition> listToscaProperties = new ArrayList<>(); + Map<String, Object> mapToscaProperties = new HashMap<>(); + if (node.get("properties") != null) { + @SuppressWarnings("unchecked") + Map<String, Object> properties = (Map<String, Object>) node.get("properties"); + for (Map.Entry<String, Object> property : properties.entrySet()) { + ToscaPropertiesNodeTemplatesDefinition toscaProperty = new ToscaPropertiesNodeTemplatesDefinition(); + String propertyName = property.getKey(); + Object propertyValue = property.getValue(); + toscaProperty.setName(propertyName); + toscaProperty.setValue(propertyValue); +// mapToscaProperties.add(toscaProperty); + mapToscaProperties.put(propertyName, propertyValue); + } + } + toscaNodeTemplates.setProperties(mapToscaProperties); + } + + protected static void getNodeTemplatesType(ToscaNodeTemplatesTopologyTemplateDefinition toscaNodeTemplates, + Map<String, Object> node) { + if (node.get("type") != null) { + String type = (String) node.get("type"); + toscaNodeTemplates.setType(type); + } else { + log.debug("Tosca file not valid, nodeTemplate should contain type"); + } + } + + protected static void getToscaNodeTemplatesName(Entry<String, Object> nodeTemplates, + ToscaNodeTemplatesTopologyTemplateDefinition toscaNodeTemplates) { + String name = nodeTemplates.getKey(); + toscaNodeTemplates.setName(name); + }*/ + + + +} |