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