openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/ComputeConsolidationDataHandler.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
  18
  19 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  20 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  21 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  22 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  23 import org.openecomp.sdc.heat.datatypes.model.Resource;
  24 import org.openecomp.sdc.tosca.services.DataModelUtil;
  25 import org.openecomp.sdc.tosca.services.ToscaUtil;
  26 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  27 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  28 import org.openecomp.sdc.translator.services.heattotosca.NameExtractor;
  29 import org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator;
  30
  31 import java.util.Objects;
  32
  33 public class ComputeConsolidationDataHandler implements ConsolidationDataHandler {
  34
  35     private final ComputeConsolidationData computeConsolidationData;
  36
  37     ComputeConsolidationDataHandler(ComputeConsolidationData computeConsolidationData) {
  38         this.computeConsolidationData = computeConsolidationData;
  39     }
  40
  41     @Override
  42     public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
  43                                      RequirementAssignment requirementAssignment) {
  44
  45         String translatedSourceNodeId = translateTo.getTranslatedId();
  46         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  47         NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, translatedSourceNodeId);
  48         String nodeType = computeNodeTemplate.getType();
  49
  50         EntityConsolidationData entityConsolidationData =
  51                 getComputeTemplateConsolidationData(translateTo, nodeType, translatedSourceNodeId);
  52
  53         if (Objects.nonNull(entityConsolidationData)) {
  54             entityConsolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
  55         }
  56     }
  57
  58     @Override
  59     public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
  60                                     String dependentNodeTemplateId, String targetResourceId, String requirementId,
  61                                     RequirementAssignment requirementAssignment) {
  62
  63         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  64         NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, dependentNodeTemplateId);
  65         String nodeType = getNodeType(nodeTemplate, translateTo.getHeatOrchestrationTemplate(),
  66                 targetResourceId, dependentNodeTemplateId, dependentNodeTemplateId);
  67
  68         EntityConsolidationData entityConsolidationData =
  69                 getComputeTemplateConsolidationData(translateTo, nodeType, dependentNodeTemplateId);
  70
  71         if (Objects.nonNull(entityConsolidationData)) {
  72             entityConsolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment);
  73         }
  74     }
  75
  76     @Override
  77     public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
  78             HeatOrchestrationTemplate heatOrchestrationTemplate, String paramName, String contrailSharedResourceId,
  79             String sharedTranslatedResourceId) {
  80
  81         NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, sharedTranslatedResourceId);
  82         EntityConsolidationData entityConsolidationData =
  83                 getComputeTemplateConsolidationData(ToscaUtil
  84                     .getServiceTemplateFileName(serviceTemplate), nodeTemplate.getType(), sharedTranslatedResourceId);
  85
  86         if (Objects.nonNull(entityConsolidationData)) {
  87             entityConsolidationData.removeParamNameFromAttrFuncList(paramName);
  88         }
  89     }
  90
  91     @Override
  92     public void addNodesGetAttrOut(FunctionTranslator functionTranslator, String nodeTemplateId,
  93             String resourceTranslatedId, String propertyName, String attributeName) {
  94         EntityConsolidationData entityConsolidationData =
  95                 getComputeTemplateConsolidationData(functionTranslator,
  96                         functionTranslator.getResourceId(), resourceTranslatedId);
  97
  98         if (Objects.nonNull(entityConsolidationData)) {
  99             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 100             entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
 101         }
 102     }
 103
 104     @Override
 105     public void addNodesGetAttrIn(FunctionTranslator functionTranslator,String nodeTemplateId, String targetResourceId,
 106             String targetResourceTranslatedId,  String propertyName, String attributeName) {
 107
 108         EntityConsolidationData entityConsolidationData =
 109                 getComputeTemplateConsolidationData(functionTranslator, targetResourceId, targetResourceTranslatedId);
 110
 111         if (Objects.nonNull(entityConsolidationData)) {
 112             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 113             entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 114         }
 115
 116     }
 117
 118     @Override
 119     public void addOutputParamGetAttrIn(FunctionTranslator functionTranslator, String targetResourceId,
 120             String targetResourceTranslatedId, String propertyName, String attributeName) {
 121
 122         EntityConsolidationData entityConsolidationData =
 123                 getComputeTemplateConsolidationData(functionTranslator, targetResourceId, targetResourceTranslatedId);
 124
 125         if (Objects.nonNull(entityConsolidationData)) {
 126             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 127             entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 128         }
 129     }
 130
 131     /**
 132      * Add compute in consolidation data entity base on given keys.
 133      *
 134      */
 135     public void addConsolidationData(String serviceTemplateFileName,
 136             String computeNodeType, String computeNodeTemplateId) {
 137         getComputeTemplateConsolidationData(serviceTemplateFileName, computeNodeType,  computeNodeTemplateId);
 138     }
 139
 140     /**
 141      * Add port to compute consolidation data entity base on given keys.
 142      *
 143      */
 144     public void addPortToConsolidationData(TranslateTo translateTo, String computeNodeType,
 145                 String computeNodeTemplateId, String portType, String portNodeTemplateId) {
 146         ComputeTemplateConsolidationData consolidationData =
 147                 getComputeTemplateConsolidationData(translateTo, computeNodeType, computeNodeTemplateId);
 148         consolidationData.addPort(portType, portNodeTemplateId);
 149     }
 150
 151     /**
 152      * Add volume to consolidation data.
 153      *
 154      */
 155     public void addVolumeToConsolidationData(TranslateTo translateTo, String computeNodeType,
 156             String computeNodeTemplateId, String requirementId, RequirementAssignment requirementAssignment) {
 157         ComputeTemplateConsolidationData consolidationData =
 158                 getComputeTemplateConsolidationData(translateTo, computeNodeType,
 159                         computeNodeTemplateId);
 160         consolidationData.addVolume(requirementId, requirementAssignment);
 161     }
 162
 163     /**
 164      * Add group id information to consolidation data.
 165      *
 166      * @param translatedGroupId Group id of which compute node is a part
 167      */
 168
 169     public void addGroupIdToConsolidationData(TranslateTo translateTo, String computeNodeType,
 170             String computeNodeTemplateId, String translatedGroupId) {
 171         ComputeTemplateConsolidationData consolidationData =
 172                 getComputeTemplateConsolidationData(translateTo, computeNodeType,
 173                         computeNodeTemplateId);
 174         consolidationData.addGroupId(translatedGroupId);
 175     }
 176
 177     public boolean isNumberOfComputeTypesLegal(String serviceTemplateName) {
 178         return computeConsolidationData.isNumberOfComputeTypesLegal(serviceTemplateName);
 179     }
 180
 181     private EntityConsolidationData getComputeTemplateConsolidationData(FunctionTranslator functionTranslator,
 182                                                                       String resourceId, String computeNodeTemplateId) {
 183         HeatOrchestrationTemplate heatOrchestrationTemplate = functionTranslator.getHeatOrchestrationTemplate();
 184         TranslationContext context = functionTranslator.getContext();
 185         String heatFileName = functionTranslator.getHeatFileName();
 186         String translatedId = context.getTranslatedIds().get(heatFileName).get(resourceId);
 187         ServiceTemplate serviceTemplate = functionTranslator.getServiceTemplate();
 188         String computeType = getNodeType(heatOrchestrationTemplate, resourceId, resourceId, translatedId);
 189         return getComputeTemplateConsolidationData(
 190                 ToscaUtil.getServiceTemplateFileName(serviceTemplate), computeType, computeNodeTemplateId);
 191     }
 192
 193     private ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
 194             TranslateTo translateTo, String computeNodeType, String computeNodeTemplateId) {
 195         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 196         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 197         return getComputeTemplateConsolidationData(serviceTemplateFileName, computeNodeType, computeNodeTemplateId);
 198     }
 199
 200     private ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
 201             String serviceTemplateFileName, String computeNodeType, String computeNodeTemplateId) {
 202
 203         return computeConsolidationData.addComputeTemplateConsolidationData(serviceTemplateFileName, computeNodeType,
 204                 computeNodeTemplateId);
 205
 206     }
 207
 208     private String getNodeType(HeatOrchestrationTemplate heatOrchestrationTemplate,
 209                                       String targetResourceId, String nodeTemplateId, String translatedId) {
 210         return getNodeType(null, heatOrchestrationTemplate, targetResourceId,
 211                 nodeTemplateId, translatedId);
 212     }
 213
 214     private String getNodeType(NodeTemplate computeNodeTemplate, HeatOrchestrationTemplate heatOrchestrationTemplate,
 215                                       String targetResourceId, String nodeTemplateId, String translatedId) {
 216         if (Objects.isNull(computeNodeTemplate)) {
 217             Resource targetResource = heatOrchestrationTemplate.getResources().get(targetResourceId);
 218             NameExtractor nodeTypeNameExtractor = TranslationContext.getNameExtractorImpl(targetResource.getType());
 219             return nodeTypeNameExtractor.extractNodeTypeName(heatOrchestrationTemplate.getResources()
 220                     .get(nodeTemplateId), nodeTemplateId, translatedId);
 221         }
 222         return computeNodeTemplate.getType();
 223     }
 224
 225     private GetAttrFuncData createGetAttrFuncData(String propertyName, String attributeName) {
 226         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 227         getAttrFuncData.setFieldName(propertyName);
 228         getAttrFuncData.setAttributeName(attributeName);
 229         return getAttrFuncData;
 230     }
 231 }