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