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