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