gerrit.onap Code Review - sdc.git/blob

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