openecomp-be/lib/openecomp-sdc-enrichment-lib/openecomp-sdc-enrichment-impl/src/main/java/org/openecomp/sdc/enrichment/impl/tosca/AbstractSubstituteToscaEnricher.java

   1 package org.openecomp.sdc.enrichment.impl.tosca;
   2
   3 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.HIGH_AVAIL_MODE;
   4 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MANDATORY;
   5 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MAX_INSTANCES;
   6 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MIN_INSTANCES;
   7 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VFC_NAMING_CODE;
   8 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VM_TYPE_TAG;
   9 import static org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType.NATIVE_NODE;
  10 import static org.openecomp.sdc.tosca.datatypes.ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE;
  11 import static org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType.NATIVE_DEPENDS_ON;
  12 import static org.openecomp.sdc.tosca.services.ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME;
  13 import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
  14
  15 import org.apache.commons.lang3.StringUtils;
  16 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  17 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  18 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  19 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  20 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  21 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  22 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  23 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  24 import org.openecomp.sdc.versioning.dao.types.Version;
  25
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.Optional;
  31
  32 public class AbstractSubstituteToscaEnricher {
  33   private ToscaAnalyzerService toscaAnalyzerService ;
  34   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  35   private ComponentQuestionnaireData componentQuestionnaireData;
  36
  37
  38   public Map<String,List<ErrorMessage>> enrich(ToscaServiceModel toscaModel, String vspId, Version
  39       version) {
  40
  41     mdcDataDebugMessage.debugEntryMessage(vspId, version.toString());
  42
  43     componentQuestionnaireData = getComponentQuestionnaireData();
  44     toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  45
  46     Map<String, Map<String, Object>> componentProperties =
  47         componentQuestionnaireData.getPropertiesfromCompQuestionnaire(vspId, version);
  48
  49     final Map<String, List<String>> sourceToTargetDependencies =
  50         componentQuestionnaireData.populateDependencies(vspId, version,
  51             componentQuestionnaireData.getSourceToTargetComponent());
  52
  53     Map<String, List<ErrorMessage>> errors = new HashMap<>();
  54
  55     final ServiceTemplate serviceTemplate = toscaModel.getServiceTemplates()
  56         .get(toscaModel.getEntryDefinitionServiceTemplate());
  57
  58     if (serviceTemplate == null) return errors;
  59
  60     final Map<String, NodeTemplate> node_templates =
  61         serviceTemplate.getTopology_template().getNode_templates();
  62
  63     final Map<String, List<String>> componentDisplayNameToNodeTempalteIds =
  64         populateAllNodeTemplateIdForComponent(node_templates, serviceTemplate, toscaModel);
  65
  66     node_templates.keySet()
  67         .stream()
  68         .forEach(nodeTemplateId -> {
  69           final Optional<NodeTemplate> nodeTemplateById =
  70               toscaAnalyzerService.getNodeTemplateById(serviceTemplate, nodeTemplateId);
  71           final NodeTemplate nodeTemplate =
  72               nodeTemplateById.isPresent() ? nodeTemplateById.get() : null;
  73
  74           if (toscaAnalyzerService.isTypeOf(nodeTemplate, VFC_ABSTRACT_SUBSTITUTE, serviceTemplate,
  75               toscaModel)) {
  76
  77             String componentDisplayName = getComponentDisplayName(nodeTemplateId);
  78
  79             setProperty(nodeTemplate, VM_TYPE_TAG, componentDisplayName);
  80
  81             if (componentProperties != null && componentProperties.containsKey
  82                 (componentDisplayName)) {
  83               final String mandatory =
  84                   getValueFromQuestionnaireDetails(componentProperties, componentDisplayName,
  85                       MANDATORY);
  86
  87               boolean isServiceTemplateFilterNotExists = false;
  88               if (!StringUtils.isEmpty(mandatory)) {
  89                 Map innerProps = (Map<String, Object>) nodeTemplate.getProperties()
  90                     .get(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
  91
  92                 if (innerProps == null) {
  93                   innerProps = new HashMap<String, Object>();
  94                   isServiceTemplateFilterNotExists = true;
  95                 }
  96
  97                 innerProps.put(MANDATORY, getValue(mandatory));
  98
  99                 if(isServiceTemplateFilterNotExists)
 100                   nodeTemplate.getProperties().put(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME,
 101                     innerProps);
 102               }
 103
 104               setProperty(nodeTemplate, HIGH_AVAIL_MODE, getValueFromQuestionnaireDetails
 105                   (componentProperties, componentDisplayName, HIGH_AVAIL_MODE));
 106
 107               setProperty(nodeTemplate, VFC_NAMING_CODE, getValueFromQuestionnaireDetails
 108                   (componentProperties, componentDisplayName, VFC_NAMING_CODE));
 109
 110
 111               if(componentProperties.get(componentDisplayName).get(MIN_INSTANCES) != null) {
 112                 nodeTemplate.getProperties().put(MIN_INSTANCES,
 113                     componentProperties.get(componentDisplayName).get(MIN_INSTANCES));
 114               }
 115
 116               if(componentProperties.get(componentDisplayName).get(MAX_INSTANCES) != null) {
 117                 nodeTemplate.getProperties().put(MAX_INSTANCES,
 118                     componentProperties.get(componentDisplayName).get(MAX_INSTANCES));
 119               }
 120             }
 121
 122             enrichRequirements(sourceToTargetDependencies, componentDisplayName, nodeTemplate,
 123                 componentDisplayNameToNodeTempalteIds);
 124           }
 125         });
 126
 127     mdcDataDebugMessage.debugExitMessage(vspId, version.toString());
 128     return errors;
 129   }
 130
 131   private Map<String,List<String>> populateAllNodeTemplateIdForComponent(Map<String,
 132       NodeTemplate> node_templates, ServiceTemplate serviceTemplate, ToscaServiceModel
 133       toscaModel) {
 134
 135
 136     Map<String,List<String>> componentDisplayNameToNodeTempalteIds = new HashMap<String,
 137         List<String>>();
 138
 139     //set dependency target
 140     node_templates.keySet()
 141         .stream()
 142         .forEach(nodeTemplateId -> {
 143
 144           final Optional<NodeTemplate> nodeTemplateById =
 145               toscaAnalyzerService.getNodeTemplateById(serviceTemplate, nodeTemplateId);
 146           final NodeTemplate nodeTemplate =
 147               nodeTemplateById.isPresent() ? nodeTemplateById.get() : null;
 148
 149           if (toscaAnalyzerService.isTypeOf(nodeTemplate, VFC_ABSTRACT_SUBSTITUTE, serviceTemplate,
 150               toscaModel)) {
 151
 152             String componentDisplayName = getComponentDisplayName(nodeTemplateId);
 153
 154             if (componentDisplayNameToNodeTempalteIds.containsKey(componentDisplayName)) {
 155               componentDisplayNameToNodeTempalteIds.get(componentDisplayName).add(nodeTemplateId);
 156             } else {
 157               List<String> nodeTemplateIds = new ArrayList<String>();
 158               nodeTemplateIds.add(nodeTemplateId);
 159               componentDisplayNameToNodeTempalteIds.put(componentDisplayName, nodeTemplateIds);
 160             }
 161
 162           }
 163         });
 164
 165     return componentDisplayNameToNodeTempalteIds;
 166   }
 167
 168   private void enrichRequirements(Map<String, List<String>> sourceToTargetDependencies,
 169                                   String componentDisplayName, NodeTemplate nodeTemplate,
 170                                   Map<String, List<String>> componentDisplayNameToNodeTempalteIds) {
 171     List<Map<String, RequirementAssignment>> requirements =
 172         nodeTemplate.getRequirements();
 173
 174     if(requirements == null) {
 175       requirements = new ArrayList<Map<String, RequirementAssignment>>();
 176     }
 177
 178     final List<String> targets = sourceToTargetDependencies.get(componentDisplayName);
 179     if(targets != null) {
 180       for (String target : targets) {
 181         List<String> targetNodeTemplateIds = componentDisplayNameToNodeTempalteIds.get(target);
 182         if(targetNodeTemplateIds != null) {
 183           for (String targetNodeTemplateId : targetNodeTemplateIds) {
 184             Map<String, RequirementAssignment> requirement = new HashMap<String,
 185                 RequirementAssignment>();
 186             RequirementAssignment requirementAssignment = new RequirementAssignment();
 187             requirementAssignment.setCapability(NATIVE_NODE);
 188             requirementAssignment.setRelationship(NATIVE_DEPENDS_ON);
 189             requirementAssignment.setNode(targetNodeTemplateId);
 190             requirement.put("dependency", requirementAssignment);
 191             requirements.add(requirement);
 192           }
 193         }
 194       }
 195     }
 196
 197     if (!requirements.isEmpty())
 198       nodeTemplate.setRequirements(requirements);
 199   }
 200
 201   private String getComponentDisplayName(String nodeTemplateId ) {
 202     String componentDisplayName = null;
 203     if (nodeTemplateId.contains(ABSTRACT_NODE_TEMPLATE_ID_PREFIX)) {
 204       String removedPrefix = nodeTemplateId.split(ABSTRACT_NODE_TEMPLATE_ID_PREFIX)[1];
 205       final String[] removedSuffix = removedPrefix.split("_\\d");
 206       componentDisplayName = removedSuffix[0];
 207     }
 208     return componentDisplayName;
 209   }
 210
 211   private String getValueFromQuestionnaireDetails(
 212       Map<String, Map<String, Object>> componentTypetoParams, String componentDisplayName, String
 213       propertyName) {
 214     return (String) componentTypetoParams.get(componentDisplayName).get(propertyName);
 215   }
 216
 217   private void setProperty(NodeTemplate nodeTemplate, String key, String value) {
 218     if (!StringUtils.isEmpty(value)) {
 219       //YamlUtil throws IllegalStateException("duplicate key: " + key) if key is already present.
 220       // So first removing and then populating same key with new updated value
 221       nodeTemplate.getProperties().remove(key);
 222       nodeTemplate.getProperties().put(key, value);
 223     }
 224   }
 225
 226   private Boolean getValue(String value) {
 227     String returnValue = null;
 228     switch (value) {
 229       case "YES" :
 230         return true;
 231       case "NO" :
 232           return false;
 233       default: return null;
 234     }
 235   }
 236
 237   private ComponentQuestionnaireData getComponentQuestionnaireData() {
 238     if (componentQuestionnaireData == null) {
 239       componentQuestionnaireData = new ComponentQuestionnaireData();
 240     }
 241     return componentQuestionnaireData;
 242   }
 243 }