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     if(node_templates == null) return errors;
  63
  64     final Map<String, List<String>> componentDisplayNameToNodeTempalteIds =
  65         populateAllNodeTemplateIdForComponent(node_templates, serviceTemplate, toscaModel);
  66
  67     node_templates.keySet()
  68         .stream()
  69         .forEach(nodeTemplateId -> {
  70           final Optional<NodeTemplate> nodeTemplateById =
  71               toscaAnalyzerService.getNodeTemplateById(serviceTemplate, nodeTemplateId);
  72           final NodeTemplate nodeTemplate =
  73               nodeTemplateById.isPresent() ? nodeTemplateById.get() : null;
  74
  75           if (toscaAnalyzerService.isTypeOf(nodeTemplate, VFC_ABSTRACT_SUBSTITUTE, serviceTemplate,
  76               toscaModel)) {
  77
  78             String componentDisplayName = getComponentDisplayName(nodeTemplateId);
  79
  80             setProperty(nodeTemplate, VM_TYPE_TAG, componentDisplayName);
  81
  82             if (componentProperties != null && componentProperties.containsKey
  83                 (componentDisplayName)) {
  84               final String mandatory =
  85                   getValueFromQuestionnaireDetails(componentProperties, componentDisplayName,
  86                       MANDATORY);
  87
  88               boolean isServiceTemplateFilterNotExists = false;
  89               if (!StringUtils.isEmpty(mandatory)) {
  90                 Map innerProps = (Map<String, Object>) nodeTemplate.getProperties()
  91                     .get(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
  92
  93                 if (innerProps == null) {
  94                   innerProps = new HashMap<String, Object>();
  95                   isServiceTemplateFilterNotExists = true;
  96                 }
  97
  98                 innerProps.put(MANDATORY, getValue(mandatory));
  99
 100                 if(isServiceTemplateFilterNotExists)
 101                   nodeTemplate.getProperties().put(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME,
 102                     innerProps);
 103               }
 104
 105               setProperty(nodeTemplate, HIGH_AVAIL_MODE, getValueFromQuestionnaireDetails
 106                   (componentProperties, componentDisplayName, HIGH_AVAIL_MODE));
 107
 108               setProperty(nodeTemplate, VFC_NAMING_CODE, getValueFromQuestionnaireDetails
 109                   (componentProperties, componentDisplayName, VFC_NAMING_CODE));
 110
 111
 112               if(componentProperties.get(componentDisplayName).get(MIN_INSTANCES) != null) {
 113                 nodeTemplate.getProperties().put(MIN_INSTANCES,
 114                     componentProperties.get(componentDisplayName).get(MIN_INSTANCES));
 115               }
 116
 117               if(componentProperties.get(componentDisplayName).get(MAX_INSTANCES) != null) {
 118                 nodeTemplate.getProperties().put(MAX_INSTANCES,
 119                     componentProperties.get(componentDisplayName).get(MAX_INSTANCES));
 120               }
 121             }
 122
 123             enrichRequirements(sourceToTargetDependencies, componentDisplayName, nodeTemplate,
 124                 componentDisplayNameToNodeTempalteIds);
 125           }
 126         });
 127
 128     mdcDataDebugMessage.debugExitMessage(vspId, version.toString());
 129     return errors;
 130   }
 131
 132   private Map<String,List<String>> populateAllNodeTemplateIdForComponent(Map<String,
 133       NodeTemplate> node_templates, ServiceTemplate serviceTemplate, ToscaServiceModel
 134       toscaModel) {
 135
 136
 137     Map<String,List<String>> componentDisplayNameToNodeTempalteIds = new HashMap<String,
 138         List<String>>();
 139
 140     //set dependency target
 141     node_templates.keySet()
 142         .stream()
 143         .forEach(nodeTemplateId -> {
 144
 145           final Optional<NodeTemplate> nodeTemplateById =
 146               toscaAnalyzerService.getNodeTemplateById(serviceTemplate, nodeTemplateId);
 147           final NodeTemplate nodeTemplate =
 148               nodeTemplateById.isPresent() ? nodeTemplateById.get() : null;
 149
 150           if (toscaAnalyzerService.isTypeOf(nodeTemplate, VFC_ABSTRACT_SUBSTITUTE, serviceTemplate,
 151               toscaModel)) {
 152
 153             String componentDisplayName = getComponentDisplayName(nodeTemplateId);
 154
 155             if (componentDisplayNameToNodeTempalteIds.containsKey(componentDisplayName)) {
 156               componentDisplayNameToNodeTempalteIds.get(componentDisplayName).add(nodeTemplateId);
 157             } else {
 158               List<String> nodeTemplateIds = new ArrayList<String>();
 159               nodeTemplateIds.add(nodeTemplateId);
 160               componentDisplayNameToNodeTempalteIds.put(componentDisplayName, nodeTemplateIds);
 161             }
 162
 163           }
 164         });
 165
 166     return componentDisplayNameToNodeTempalteIds;
 167   }
 168
 169   private void enrichRequirements(Map<String, List<String>> sourceToTargetDependencies,
 170                                   String componentDisplayName, NodeTemplate nodeTemplate,
 171                                   Map<String, List<String>> componentDisplayNameToNodeTempalteIds) {
 172     List<Map<String, RequirementAssignment>> requirements =
 173         nodeTemplate.getRequirements();
 174
 175     if(requirements == null) {
 176       requirements = new ArrayList<Map<String, RequirementAssignment>>();
 177     }
 178
 179     final List<String> targets = sourceToTargetDependencies.get(componentDisplayName);
 180     if(targets != null) {
 181       for (String target : targets) {
 182         List<String> targetNodeTemplateIds = componentDisplayNameToNodeTempalteIds.get(target);
 183         if(targetNodeTemplateIds != null) {
 184           for (String targetNodeTemplateId : targetNodeTemplateIds) {
 185             Map<String, RequirementAssignment> requirement = new HashMap<String,
 186                 RequirementAssignment>();
 187             RequirementAssignment requirementAssignment = new RequirementAssignment();
 188             requirementAssignment.setCapability(NATIVE_NODE);
 189             requirementAssignment.setRelationship(NATIVE_DEPENDS_ON);
 190             requirementAssignment.setNode(targetNodeTemplateId);
 191             requirement.put("dependency", requirementAssignment);
 192             requirements.add(requirement);
 193           }
 194         }
 195       }
 196     }
 197
 198     if (!requirements.isEmpty())
 199       nodeTemplate.setRequirements(requirements);
 200   }
 201
 202   private String getComponentDisplayName(String nodeTemplateId ) {
 203     String componentDisplayName = null;
 204     if (nodeTemplateId.contains(ABSTRACT_NODE_TEMPLATE_ID_PREFIX)) {
 205       String removedPrefix = nodeTemplateId.split(ABSTRACT_NODE_TEMPLATE_ID_PREFIX)[1];
 206       final String[] removedSuffix = removedPrefix.split("_\\d");
 207       componentDisplayName = removedSuffix[0];
 208     }
 209     return componentDisplayName;
 210   }
 211
 212   private String getValueFromQuestionnaireDetails(
 213       Map<String, Map<String, Object>> componentTypetoParams, String componentDisplayName, String
 214       propertyName) {
 215     return (String) componentTypetoParams.get(componentDisplayName).get(propertyName);
 216   }
 217
 218   private void setProperty(NodeTemplate nodeTemplate, String key, String value) {
 219     if (!StringUtils.isEmpty(value)) {
 220       //YamlUtil throws IllegalStateException("duplicate key: " + key) if key is already present.
 221       // So first removing and then populating same key with new updated value
 222       nodeTemplate.getProperties().remove(key);
 223       nodeTemplate.getProperties().put(key, value);
 224     }
 225   }
 226
 227   private Boolean getValue(String value) {
 228     String returnValue = null;
 229     switch (value) {
 230       case "YES" :
 231         return true;
 232       case "NO" :
 233           return false;
 234       default: return null;
 235     }
 236   }
 237
 238   private ComponentQuestionnaireData getComponentQuestionnaireData() {
 239     if (componentQuestionnaireData == null) {
 240       componentQuestionnaireData = new ComponentQuestionnaireData();
 241     }
 242     return componentQuestionnaireData;
 243   }
 244 }