openecomp-be/lib/openecomp-sdc-tosca-generator-lib/openecomp-sdc-tosca-generator-core/src/main/java/org/openecomp/sdc/generator/core/utils/GeneratorUtils.java

   1 package org.openecomp.sdc.generator.core.utils;
   2
   3 import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes;
   4 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
   5 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
   6 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
   7 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
   8 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
   9 import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
  10 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  11 import org.openecomp.sdc.tosca.services.DataModelUtil;
  12 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  13 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
  14 import org.openecomp.sdc.tosca.services.ToscaUtil;
  15 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  16
  17 import java.util.ArrayList;
  18 import java.util.Arrays;
  19 import java.util.Collections;
  20 import java.util.HashMap;
  21 import java.util.Iterator;
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import static org.openecomp.sdc.tosca.services.DataModelUtil.addSubstitutionNodeTypeRequirements;
  26
  27 /**
  28  * The type Generator utils.
  29  */
  30 public class GeneratorUtils {
  31
  32   private GeneratorUtils() {
  33     // prevent instantiation
  34   }
  35
  36   //TODO : Read from configuration
  37   private static final List<String> SUPPORTED_CAPABILITIES = Arrays.asList("host", "os", "endpoint", "scalable");
  38   private static final List<String> SUPPORTED_REQUIREMENTS = Collections.singletonList("link");
  39
  40   /**
  41    * Add service template to tosca service model.
  42    *
  43    * @param toscaServiceModel the tosca service model
  44    * @param serviceTemplate   the service template
  45    */
  46   public static void addServiceTemplateToToscaServiceModel(ToscaServiceModel toscaServiceModel,
  47                                                            ServiceTemplate serviceTemplate) {
  48
  49     String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
  50     Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
  51     if (!serviceTemplates.containsKey(serviceTemplateFileName)) {
  52       ToscaUtil.addServiceTemplateToMapWithKeyFileName(serviceTemplates, serviceTemplate);
  53     }
  54     toscaServiceModel.setServiceTemplates(serviceTemplates);
  55   }
  56
  57   /**
  58    * Gets substitution node type exposed connection points.
  59    *
  60    * @param substitutionNodeType        the substitution node type
  61    * @param substitutionServiceTemplate the substitution service template
  62    * @param toscaServiceModel           the tosca service model
  63    * @return the substitution node type exposed connection points
  64    */
  65   public static Map<String, Map<String, List<String>>>
  66       getSubstitutionNodeTypeExposedConnectionPoints(NodeType substitutionNodeType,
  67                                                  ServiceTemplate substitutionServiceTemplate,
  68                                                  ToscaServiceModel toscaServiceModel) {
  69
  70     Map<String, NodeTemplate> nodeTemplates =
  71         substitutionServiceTemplate.getTopology_template().getNode_templates();
  72     String nodeTemplateId;
  73     NodeTemplate nodeTemplate;
  74     String nodeType;
  75     Map<String, Map<String, List<String>>> substitutionMapping = new HashMap<>();
  76     if (nodeTemplates == null) {
  77       return substitutionMapping;
  78     }
  79
  80     try {
  81       Map<String, List<String>> capabilitySubstitutionMapping = new HashMap<>();
  82       Map<String, List<String>> requirementSubstitutionMapping = new HashMap<>();
  83       substitutionMapping.put("capability", capabilitySubstitutionMapping);
  84       substitutionMapping.put("requirement", requirementSubstitutionMapping);
  85       List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition;
  86       Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment;
  87       List<Map<String, RequirementDefinition>> exposedRequirementsDefinition;
  88       Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition =
  89           new HashMap<>();
  90       Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition = new HashMap<>();
  91       Map<String, CapabilityDefinition> exposedCapabilitiesDefinition;
  92
  93       ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  94       for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
  95         nodeTemplateId = entry.getKey();
  96         nodeTemplate = entry.getValue();
  97         nodeType = nodeTemplate.getType();
  98         NodeType flatNodeType = (NodeType) toscaAnalyzerService
  99             .getFlatEntity(ToscaElementTypes.NODE_TYPE, nodeType, substitutionServiceTemplate,
 100                 toscaServiceModel);
 101         // get requirements
 102         nodeTypeRequirementsDefinition =
 103             getNodeTypeRequirements(flatNodeType, nodeTemplateId, substitutionServiceTemplate,
 104                 requirementSubstitutionMapping);
 105         nodeTemplateRequirementsAssignment =
 106             DataModelUtil.getNodeTemplateRequirements(nodeTemplate);
 107         fullFilledRequirementsDefinition.put(nodeTemplateId, nodeTemplateRequirementsAssignment);
 108         //set substitution node type requirements
 109         exposedRequirementsDefinition =
 110             toscaAnalyzerService.calculateExposedRequirements(nodeTypeRequirementsDefinition,
 111                 nodeTemplateRequirementsAssignment);
 112
 113
 114         //Filter unsupported requirements
 115         Iterator<Map<String, RequirementDefinition>> iterator =
 116             exposedRequirementsDefinition.iterator();
 117         while (iterator.hasNext()) {
 118           Map<String, RequirementDefinition> requirementDefinitionMap = iterator.next();
 119           for (Map.Entry<String, RequirementDefinition> requirementDefinitionEntry :
 120               requirementDefinitionMap.entrySet()) {
 121             String requirementKey = requirementDefinitionEntry.getKey();
 122             if (!SUPPORTED_REQUIREMENTS.contains(requirementKey)) {
 123               iterator.remove();
 124             }
 125           }
 126         }
 127         addSubstitutionNodeTypeRequirements(substitutionNodeType, exposedRequirementsDefinition,
 128             nodeTemplateId);
 129         //get capabilities
 130         addNodeTypeCapabilitiesToSubMapping(nodeTypeCapabilitiesDefinition,
 131             capabilitySubstitutionMapping, nodeType,
 132             nodeTemplateId, substitutionServiceTemplate, toscaServiceModel);
 133       }
 134
 135       exposedCapabilitiesDefinition =
 136           toscaAnalyzerService.calculateExposedCapabilities(nodeTypeCapabilitiesDefinition,
 137               fullFilledRequirementsDefinition);
 138
 139       //Filter unsupported capabilities
 140       Iterator<Map.Entry<String, CapabilityDefinition>> iterator = exposedCapabilitiesDefinition
 141           .entrySet().iterator();
 142       while (iterator.hasNext()) {
 143         Map.Entry<String, CapabilityDefinition> capabilityDefinitionEntry = iterator.next();
 144         //Expected Capability is of the format <capabilityId>_<componentName>
 145         String capabilityKey = capabilityDefinitionEntry.getKey().split("_")[0];
 146         if (!SUPPORTED_CAPABILITIES.contains(capabilityKey)) {
 147           iterator.remove();
 148         }
 149       }
 150
 151       DataModelUtil.addNodeTypeCapabilitiesDef(substitutionNodeType, exposedCapabilitiesDefinition);
 152     } catch (Exception ex) {
 153       return null;
 154     }
 155     return substitutionMapping;
 156   }
 157
 158   /**
 159    * Gets node type requirements.
 160    *
 161    * @param flatNodeType                   the flat node type
 162    * @param templateName                   the template name
 163    * @param serviceTemplate                the service template
 164    * @param requirementSubstitutionMapping the requirement substitution mapping
 165    * @return the node type requirements
 166    */
 167   public static List<Map<String, RequirementDefinition>> getNodeTypeRequirements(
 168       NodeType flatNodeType,
 169       String templateName,
 170       ServiceTemplate serviceTemplate,
 171       Map<String, List<String>> requirementSubstitutionMapping) {
 172     List<Map<String, RequirementDefinition>> requirementList = new ArrayList<>();
 173     List<String> requirementMapping;
 174     if (flatNodeType.getRequirements() != null) {
 175       for (Map<String, RequirementDefinition> requirementMap : flatNodeType.getRequirements()) {
 176         for (Map.Entry<String, RequirementDefinition> requirementNodeEntry : requirementMap
 177             .entrySet()) {
 178           ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 179           RequirementDefinition requirementNodeEntryValue = toscaExtensionYamlUtil
 180               .yamlToObject(toscaExtensionYamlUtil.objectToYaml(requirementNodeEntry.getValue()),
 181                   RequirementDefinition.class);
 182           if (requirementNodeEntryValue.getOccurrences() == null) {
 183             requirementNodeEntryValue.setOccurrences(new Object[]{1, 1});
 184           }
 185           Map<String, RequirementDefinition> requirementDef = new HashMap<>();
 186           requirementDef.put(requirementNodeEntry.getKey(), requirementNodeEntryValue);
 187           DataModelUtil.addRequirementToList(requirementList, requirementDef);
 188           requirementMapping = new ArrayList<>();
 189           requirementMapping.add(templateName);
 190           requirementMapping.add(requirementNodeEntry.getKey());
 191           requirementSubstitutionMapping
 192               .put(requirementNodeEntry.getKey() + "_" + templateName, requirementMapping);
 193           if (requirementNodeEntryValue.getNode() == null) {
 194             requirementNodeEntryValue.setOccurrences(new Object[]{1, 1});
 195           }
 196         }
 197       }
 198     }
 199     return requirementList;
 200   }
 201
 202   private static void addNodeTypeCapabilitiesToSubMapping(
 203       Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition,
 204       Map<String, List<String>> capabilitySubstitutionMapping, String type, String templateName,
 205       ServiceTemplate substitutionServiceTemplate, ToscaServiceModel toscaServiceModel) {
 206     ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 207     NodeType flatNodeType = (NodeType) toscaAnalyzerService
 208         .getFlatEntity(ToscaElementTypes.NODE_TYPE, type, substitutionServiceTemplate,
 209             toscaServiceModel);
 210     String capabilityKey;
 211     List<String> capabilityMapping;
 212     if (flatNodeType.getCapabilities() != null) {
 213       for (Map.Entry<String, CapabilityDefinition> capabilityNodeEntry : flatNodeType
 214           .getCapabilities()
 215           .entrySet()) {
 216         capabilityKey = capabilityNodeEntry.getKey() + "_" + templateName;
 217         nodeTypeCapabilitiesDefinition.put(capabilityKey, capabilityNodeEntry.getValue().clone());
 218         capabilityMapping = new ArrayList<>();
 219         capabilityMapping.add(templateName);
 220         capabilityMapping.add(capabilityNodeEntry.getKey());
 221         capabilitySubstitutionMapping.put(capabilityKey, capabilityMapping);
 222       }
 223     }
 224   }
 225
 226 }