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