gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.enrichment.impl.tosca;
   2
   3 import org.apache.commons.lang3.StringUtils;
   4 import org.openecomp.sdc.datatypes.error.ErrorMessage;
   5 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
   6 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
   7 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
   8 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
   9 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  10 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  11 import org.openecomp.sdc.versioning.dao.types.Version;
  12
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Optional;
  18
  19 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.HIGH_AVAIL_MODE;
  20 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MANDATORY;
  21 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MAX_INSTANCES;
  22 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.MIN_INSTANCES;
  23 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VFC_CODE;
  24 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VFC_FUNCTION;
  25 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VFC_NAMING_CODE;
  26 import static org.openecomp.sdc.enrichment.impl.util.EnrichmentConstants.VM_TYPE_TAG;
  27 import static org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType.NATIVE_NODE;
  28 import static org.openecomp.sdc.tosca.datatypes.ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE;
  29 import static org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType.NATIVE_DEPENDS_ON;
  30 import static org.openecomp.sdc.tosca.services.ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME;
  31 import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
  32
  33 public class AbstractSubstituteToscaEnricher {
  34   private ToscaAnalyzerService toscaAnalyzerService ;
  35   private ComponentQuestionnaireData componentQuestionnaireData;
  36
  37
  38   public Map<String,List<ErrorMessage>> enrich(ToscaServiceModel toscaModel, String vspId, Version
  39       version) {
  40     componentQuestionnaireData = getComponentQuestionnaireData();
  41     toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  42
  43     Map<String, Map<String, Object>> componentProperties =
  44         componentQuestionnaireData.getPropertiesfromCompQuestionnaire(vspId, version);
  45
  46     final Map<String, List<String>> sourceToTargetDependencies =
  47         componentQuestionnaireData.populateDependencies(vspId, version,
  48             componentQuestionnaireData.getSourceToTargetComponent());
  49
  50     Map<String, List<ErrorMessage>> errors = new HashMap<>();
  51
  52     final ServiceTemplate serviceTemplate = toscaModel.getServiceTemplates()
  53         .get(toscaModel.getEntryDefinitionServiceTemplate());
  54
  55     if (serviceTemplate == null) return errors;
  56
  57     final Map<String, NodeTemplate> node_templates =
  58         serviceTemplate.getTopology_template().getNode_templates();
  59     if(node_templates == null) return errors;
  60
  61     final Map<String, List<String>> componentDisplayNameToNodeTempalteIds =
  62         populateAllNodeTemplateIdForComponent(node_templates, serviceTemplate, toscaModel);
  63
  64     node_templates.keySet()
  65         .stream()
  66         .forEach(nodeTemplateId -> {
  67           final Optional<NodeTemplate> nodeTemplateById =
  68               toscaAnalyzerService.getNodeTemplateById(serviceTemplate, nodeTemplateId);
  69           final NodeTemplate nodeTemplate =
  70               nodeTemplateById.isPresent() ? nodeTemplateById.get() : null;
  71
  72           if (toscaAnalyzerService.isTypeOf(nodeTemplate, VFC_ABSTRACT_SUBSTITUTE, serviceTemplate,
  73               toscaModel)) {
  74
  75             String componentDisplayName = getComponentDisplayName(nodeTemplateId, nodeTemplate);
  76
  77             setProperty(nodeTemplate, VM_TYPE_TAG, componentDisplayName);
  78
  79             if (componentProperties != null && componentProperties.containsKey
  80                 (componentDisplayName)) {
  81               final String mandatory =
  82                   getValueFromQuestionnaireDetails(componentProperties, componentDisplayName,
  83                       MANDATORY);
  84
  85               boolean isServiceTemplateFilterNotExists = false;
  86               if (!StringUtils.isEmpty(mandatory)) {
  87                 Map innerProps = (Map<String, Object>) nodeTemplate.getProperties()
  88                     .get(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
  89
  90                 if (innerProps == null) {
  91                   innerProps = new HashMap<String, Object>();
  92                   isServiceTemplateFilterNotExists = true;
  93                 }
  94
  95                 innerProps.put(MANDATORY, getValue(mandatory));
  96
  97                 if(isServiceTemplateFilterNotExists)
  98                   nodeTemplate.getProperties().put(SERVICE_TEMPLATE_FILTER_PROPERTY_NAME,
  99                     innerProps);
 100               }
 101
 102               setProperty(nodeTemplate, HIGH_AVAIL_MODE, getValueFromQuestionnaireDetails
 103                   (componentProperties, componentDisplayName, HIGH_AVAIL_MODE));
 104
 105               setProperty(nodeTemplate, VFC_NAMING_CODE, getValueFromQuestionnaireDetails
 106                   (componentProperties, componentDisplayName, VFC_NAMING_CODE));
 107
 108               setProperty(nodeTemplate, VFC_CODE, getValueFromQuestionnaireDetails
 109                   (componentProperties, componentDisplayName, VFC_CODE));
 110
 111               setProperty(nodeTemplate, VFC_FUNCTION, getValueFromQuestionnaireDetails
 112                   (componentProperties, componentDisplayName, VFC_FUNCTION));
 113
 114               if(componentProperties.get(componentDisplayName).get(MIN_INSTANCES) != null) {
 115                 nodeTemplate.getProperties().put(MIN_INSTANCES,
 116                     componentProperties.get(componentDisplayName).get(MIN_INSTANCES));
 117               }
 118
 119               if(componentProperties.get(componentDisplayName).get(MAX_INSTANCES) != null) {
 120                 nodeTemplate.getProperties().put(MAX_INSTANCES,
 121                     componentProperties.get(componentDisplayName).get(MAX_INSTANCES));
 122               }
 123             }
 124
 125             enrichRequirements(sourceToTargetDependencies, componentDisplayName, nodeTemplate,
 126                 componentDisplayNameToNodeTempalteIds);
 127           }
 128         });
 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, nodeTemplate);
 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, NodeTemplate nodeTemplate) {
 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     } else {
 209       final String type = nodeTemplate.getType();
 210       final String[] splitted = type.split("\\.");
 211       componentDisplayName = splitted[splitted.length - 1];
 212
 213     }
 214     return componentDisplayName;
 215   }
 216
 217   private String getValueFromQuestionnaireDetails(
 218       Map<String, Map<String, Object>> componentTypetoParams, String componentDisplayName, String
 219       propertyName) {
 220     return (String) componentTypetoParams.get(componentDisplayName).get(propertyName);
 221   }
 222
 223   private void setProperty(NodeTemplate nodeTemplate, String key, String value) {
 224     if (!StringUtils.isEmpty(value)) {
 225       //YamlUtil throws IllegalStateException("duplicate key: " + key) if key is already present.
 226       // So first removing and then populating same key with new updated value
 227       nodeTemplate.getProperties().remove(key);
 228       nodeTemplate.getProperties().put(key, value);
 229     }
 230   }
 231
 232   private Boolean getValue(String value) {
 233     String returnValue = null;
 234     switch (value) {
 235       case "YES" :
 236         return true;
 237       case "NO" :
 238           return false;
 239       default: return null;
 240     }
 241   }
 242
 243   private ComponentQuestionnaireData getComponentQuestionnaireData() {
 244     if (componentQuestionnaireData == null) {
 245       componentQuestionnaireData = new ComponentQuestionnaireData();
 246     }
 247     return componentQuestionnaireData;
 248   }
 249 }