gerrit.onap Code Review - sdc.git/blob

   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.onap.sdc.tosca.datatypes.model.CapabilityDefinition;
   6 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
   7 import org.onap.sdc.tosca.datatypes.model.NodeType;
   8 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
   9 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
  10 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  11 import org.openecomp.sdc.tosca.services.DataModelUtil;
  12 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  13 import org.onap.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>>> getSubstitutionNodeTypeExposedConnectionPoints(NodeType substitutionNodeType,
  66                                                                                                                ServiceTemplate substitutionServiceTemplate,
  67                                                                                                                ToscaServiceModel toscaServiceModel) {
  68
  69         Map<String, NodeTemplate> nodeTemplates =
  70                 substitutionServiceTemplate.getTopology_template().getNode_templates();
  71         String nodeTemplateId;
  72         NodeTemplate nodeTemplate;
  73         String nodeType;
  74         Map<String, Map<String, List<String>>> substitutionMapping = new HashMap<>();
  75         if (nodeTemplates == null) {
  76             return substitutionMapping;
  77         }
  78
  79         try {
  80             Map<String, List<String>> capabilitySubstitutionMapping = new HashMap<>();
  81             Map<String, List<String>> requirementSubstitutionMapping = new HashMap<>();
  82             substitutionMapping.put("capability", capabilitySubstitutionMapping);
  83             substitutionMapping.put("requirement", requirementSubstitutionMapping);
  84             List<Map<String, RequirementDefinition>> nodeTypeRequirementsDefinition;
  85             Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment;
  86             List<Map<String, RequirementDefinition>> exposedRequirementsDefinition;
  87             Map<String, Map<String, RequirementAssignment>> fullFilledRequirementsDefinition = new HashMap<>();
  88             Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition = new HashMap<>();
  89             Map<String, CapabilityDefinition> exposedCapabilitiesDefinition;
  90
  91             ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  92             for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
  93                 nodeTemplateId = entry.getKey();
  94                 nodeTemplate = entry.getValue();
  95                 nodeType = nodeTemplate.getType();
  96                 NodeType flatNodeType = (NodeType) toscaAnalyzerService
  97                                                            .getFlatEntity(ToscaElementTypes.NODE_TYPE, nodeType,
  98                                                                    substitutionServiceTemplate, toscaServiceModel)
  99                                                            .getFlatEntity();
 100                 // get requirements
 101                 nodeTypeRequirementsDefinition =
 102                         getNodeTypeRequirements(flatNodeType, nodeTemplateId, substitutionServiceTemplate,
 103                                 requirementSubstitutionMapping);
 104                 nodeTemplateRequirementsAssignment = DataModelUtil.getNodeTemplateRequirements(nodeTemplate);
 105                 fullFilledRequirementsDefinition.put(nodeTemplateId, nodeTemplateRequirementsAssignment);
 106                 //set substitution node type requirements
 107                 exposedRequirementsDefinition = toscaAnalyzerService
 108                                                         .calculateExposedRequirements(nodeTypeRequirementsDefinition,
 109                                                                 nodeTemplateRequirementsAssignment);
 110
 111
 112                 //Filter unsupported requirements
 113                 Iterator<Map<String, RequirementDefinition>> iterator = exposedRequirementsDefinition.iterator();
 114                 while (iterator.hasNext()) {
 115                     Map<String, RequirementDefinition> requirementDefinitionMap = iterator.next();
 116                     for (Map.Entry<String, RequirementDefinition> requirementDefinitionEntry : requirementDefinitionMap
 117                                                                                                        .entrySet()) {
 118                         String requirementKey = requirementDefinitionEntry.getKey();
 119                         if (!SUPPORTED_REQUIREMENTS.contains(requirementKey)) {
 120                             iterator.remove();
 121                         }
 122                     }
 123                 }
 124                 addSubstitutionNodeTypeRequirements(substitutionNodeType, exposedRequirementsDefinition,
 125                         nodeTemplateId);
 126                 //get capabilities
 127                 addNodeTypeCapabilitiesToSubMapping(nodeTypeCapabilitiesDefinition, capabilitySubstitutionMapping,
 128                         nodeType, nodeTemplateId, substitutionServiceTemplate, toscaServiceModel);
 129             }
 130
 131             exposedCapabilitiesDefinition = toscaAnalyzerService
 132                                                     .calculateExposedCapabilities(nodeTypeCapabilitiesDefinition,
 133                                                             fullFilledRequirementsDefinition);
 134
 135             //Filter unsupported capabilities
 136             Iterator<Map.Entry<String, CapabilityDefinition>> iterator =
 137                     exposedCapabilitiesDefinition.entrySet().iterator();
 138             while (iterator.hasNext()) {
 139                 Map.Entry<String, CapabilityDefinition> capabilityDefinitionEntry = iterator.next();
 140                 //Expected Capability is of the format <capabilityId>_<componentName>
 141                 String capabilityKey = capabilityDefinitionEntry.getKey().split("_")[0];
 142                 if (!SUPPORTED_CAPABILITIES.contains(capabilityKey)) {
 143                     iterator.remove();
 144                 }
 145             }
 146
 147             DataModelUtil.addNodeTypeCapabilitiesDef(substitutionNodeType, exposedCapabilitiesDefinition);
 148         } catch (Exception ex) {
 149             return null;
 150         }
 151         return substitutionMapping;
 152     }
 153
 154     /**
 155      * Gets node type requirements.
 156      *
 157      * @param flatNodeType                   the flat node type
 158      * @param templateName                   the template name
 159      * @param serviceTemplate                the service template
 160      * @param requirementSubstitutionMapping the requirement substitution mapping
 161      * @return the node type requirements
 162      */
 163     public static List<Map<String, RequirementDefinition>> getNodeTypeRequirements(NodeType flatNodeType,
 164                                                                                           String templateName,
 165                                                                                           ServiceTemplate serviceTemplate,
 166                                                                                           Map<String, List<String>> requirementSubstitutionMapping) {
 167         List<Map<String, RequirementDefinition>> requirementList = new ArrayList<>();
 168         List<String> requirementMapping;
 169         if (flatNodeType.getRequirements() != null) {
 170             for (Map<String, RequirementDefinition> requirementMap : flatNodeType.getRequirements()) {
 171                 for (Map.Entry<String, RequirementDefinition> requirementNodeEntry : requirementMap.entrySet()) {
 172                     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 173                     RequirementDefinition requirementNodeEntryValue = toscaExtensionYamlUtil.yamlToObject(
 174                             toscaExtensionYamlUtil.objectToYaml(requirementNodeEntry.getValue()),
 175                             RequirementDefinition.class);
 176                     if (requirementNodeEntryValue.getOccurrences() == null) {
 177                         requirementNodeEntryValue.setOccurrences(new Object[] {1, 1});
 178                     }
 179                     Map<String, RequirementDefinition> requirementDef = new HashMap<>();
 180                     requirementDef.put(requirementNodeEntry.getKey(), requirementNodeEntryValue);
 181                     DataModelUtil.addRequirementToList(requirementList, requirementDef);
 182                     requirementMapping = new ArrayList<>();
 183                     requirementMapping.add(templateName);
 184                     requirementMapping.add(requirementNodeEntry.getKey());
 185                     requirementSubstitutionMapping
 186                             .put(requirementNodeEntry.getKey() + "_" + templateName, requirementMapping);
 187                     if (requirementNodeEntryValue.getNode() == null) {
 188                         requirementNodeEntryValue.setOccurrences(new Object[] {1, 1});
 189                     }
 190                 }
 191             }
 192         }
 193         return requirementList;
 194     }
 195
 196     private static void addNodeTypeCapabilitiesToSubMapping(Map<String, CapabilityDefinition> nodeTypeCapabilitiesDefinition,
 197                                                                    Map<String, List<String>> capabilitySubstitutionMapping,
 198                                                                    String type, String templateName,
 199                                                                    ServiceTemplate substitutionServiceTemplate,
 200                                                                    ToscaServiceModel toscaServiceModel) {
 201         ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 202         NodeType flatNodeType = (NodeType) toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, type,
 203                 substitutionServiceTemplate, toscaServiceModel).getFlatEntity();
 204         String capabilityKey;
 205         List<String> capabilityMapping;
 206         if (flatNodeType.getCapabilities() != null) {
 207             for (Map.Entry<String, CapabilityDefinition> capabilityNodeEntry : flatNodeType.getCapabilities()
 208                                                                                            .entrySet()) {
 209                 capabilityKey = capabilityNodeEntry.getKey() + "_" + templateName;
 210                 nodeTypeCapabilitiesDefinition.put(capabilityKey, capabilityNodeEntry.getValue().clone());
 211                 capabilityMapping = new ArrayList<>();
 212                 capabilityMapping.add(templateName);
 213                 capabilityMapping.add(capabilityNodeEntry.getKey());
 214                 capabilitySubstitutionMapping.put(capabilityKey, capabilityMapping);
 215             }
 216         }
 217     }
 218
 219 }