gerrit.onap Code Review - sdc.git/blob

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