gerrit.onap Code Review - sdc.git/blob

   1 /*
   2 /*
   3  * Copyright © 2016-2018 European Support Limited
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation;
  19
  20 import java.util.Map;
  21 import java.util.Objects;
  22 import java.util.Optional;
  23
  24 import org.apache.commons.collections4.MapUtils;
  25 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  26 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  27 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  28 import org.openecomp.sdc.heat.datatypes.model.Resource;
  29 import org.openecomp.sdc.tosca.services.ToscaUtil;
  30 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  31 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  32 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  33 import org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator;
  34
  35 public class SubInterfaceConsolidationDataHandler implements ConsolidationDataHandler {
  36
  37     private final PortConsolidationData portConsolidationData;
  38
  39     SubInterfaceConsolidationDataHandler(PortConsolidationData portConsolidationData) {
  40         this.portConsolidationData = portConsolidationData;
  41     }
  42
  43     @Override
  44     public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
  45                                             RequirementAssignment requirementAssignment) {
  46         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  47         if (Objects.nonNull(
  48                 serviceTemplate.getTopology_template().getNode_templates().get(translateTo.getTranslatedId()))) {
  49             Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
  50                     getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
  51
  52             subInterfaceTemplateConsolidationData.ifPresent(consolidationData ->
  53                     consolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment));
  54         }
  55     }
  56
  57     @Override
  58     public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
  59                                            String dependentNodeTemplateId, String targetResourceId,
  60                                            String requirementId, RequirementAssignment requirementAssignment) {
  61         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  62         TranslationContext translationContext = translateTo.getContext();
  63         Resource targetResource = translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
  64         TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate,
  65                                                             translateTo.getHeatOrchestrationTemplate(), targetResource,
  66                                                             targetResourceId, null, translationContext);
  67         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
  68                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
  69
  70         subInterfaceTemplateConsolidationData.ifPresent(consolidationData ->
  71                 consolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment));
  72
  73     }
  74
  75     @Override
  76     public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
  77                                                        HeatOrchestrationTemplate heatOrchestrationTemplate,
  78                                                        String paramName, String contrailSharedResourceId,
  79                                                        String sharedTranslatedResourceId) {
  80
  81
  82         throw new UnsupportedOperationException(
  83                 "API removeParamNameFromAttrFuncList " + "not supported for SubInterfaceConsolidationDataHandler");
  84     }
  85
  86     @Override
  87     public void addNodesGetAttrOut(FunctionTranslator functionTranslator, String nodeTemplateId,
  88             String resourceTranslatedId, String propertyName, String attributeName) {
  89         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, functionTranslator.getResourceId(),
  90                 resourceTranslatedId);
  91
  92         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
  93                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, resourceTranslatedId);
  94
  95         subInterfaceConsolidationData.ifPresent(consolidationData -> {
  96             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
  97             consolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
  98         });
  99     }
 100
 101     @Override
 102     public void addNodesGetAttrIn(FunctionTranslator functionTranslator,String nodeTemplateId, String targetResourceId,
 103             String targetResourceTranslatedId,  String propertyName, String attributeName) {
 104
 105         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, targetResourceId,
 106                 targetResourceTranslatedId);
 107
 108         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
 109                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceTranslatedId);
 110
 111         subInterfaceConsolidationData.ifPresent(consolidationData -> {
 112             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 113             consolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 114         });
 115     }
 116
 117     @Override
 118     public void addOutputParamGetAttrIn(FunctionTranslator functionTranslator, String targetResourceId,
 119             String targetResourceTranslatedId, String propertyName, String attributeName) {
 120         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, targetResourceId,
 121                 targetResourceTranslatedId);
 122
 123         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
 124                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceTranslatedId);
 125
 126         subInterfaceConsolidationData.ifPresent(consolidationData -> {
 127             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 128             consolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 129         });
 130     }
 131
 132     public void setNetworkRole(TranslateTo translateTo, String translatedId, String networkRole) {
 133         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 134                 getSubInterfaceTemplateConsolidationData(translateTo, translatedId);
 135
 136         subInterfaceTemplateConsolidationData.ifPresent(
 137                 consolidationData -> consolidationData.setNetworkRole(networkRole));
 138     }
 139
 140     public void setResourceGroupCount(TranslateTo translateTo, String translatedId,
 141             Object resourceGroupCount) {
 142         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 143                 getSubInterfaceTemplateConsolidationData(translateTo, translatedId);
 144
 145         subInterfaceTemplateConsolidationData.ifPresent(
 146                 consolidationData -> consolidationData.setResourceGroupCount(resourceGroupCount));
 147     }
 148
 149     private Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
 150             TranslateTo subInterfaceTo, String subInterfaceNodeTemplateId) {
 151         Optional<String> parentPortNodeTemplateId =
 152                 HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
 153         return parentPortNodeTemplateId.map(s -> getSubInterfaceTemplateConsolidationData(subInterfaceTo,
 154                 s, subInterfaceNodeTemplateId));
 155     }
 156
 157     private SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(TranslateTo subInterfaceTo,
 158             String parentPortNodeTemplateId, String subInterfaceNodeTemplateId) {
 159         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 160         Resource resource = subInterfaceTo.getResource();
 161         Optional<String> portResourceId = getPortResourceId(subInterfaceTo, parentPortNodeTemplateId);
 162
 163         if (portResourceId.isPresent()) {
 164             String portResourceType = getPortResourceType(subInterfaceTo, portResourceId.get());
 165             return portConsolidationData
 166                     .addSubInterfaceTemplateConsolidationData(serviceTemplateFileName, resource,
 167                             subInterfaceNodeTemplateId, parentPortNodeTemplateId,
 168                                    portResourceId.get(), portResourceType);
 169         } else {
 170             return portConsolidationData
 171                     .addSubInterfaceTemplateConsolidationData(serviceTemplateFileName, resource,
 172                             subInterfaceNodeTemplateId, parentPortNodeTemplateId);
 173         }
 174     }
 175
 176     private String getPortResourceType(TranslateTo subInterfaceTo, String portResourceId) {
 177         return HeatToToscaUtil.getResourceType(portResourceId, subInterfaceTo
 178         .getHeatOrchestrationTemplate(), subInterfaceTo.getHeatFileName());
 179     }
 180
 181     private Optional<String> getPortResourceId(TranslateTo subInterfaceTo, String parentPortNodeTemplateId) {
 182         Map<String, String> resourceIdTranslatedResourceIdMap =
 183                 subInterfaceTo.getContext().getTranslatedIds().get(subInterfaceTo.getHeatFileName());
 184         return getSubInterfaceParentPortResourceId(parentPortNodeTemplateId,
 185                 resourceIdTranslatedResourceIdMap);
 186     }
 187
 188     private Optional<String> getSubInterfaceParentPortResourceId(String parentPortNodeTemplateId,
 189             Map<String, String> resourceIdTranslatedResourceIdMap) {
 190         if (MapUtils.isEmpty(resourceIdTranslatedResourceIdMap)) {
 191             return Optional.empty();
 192         }
 193         for (Map.Entry<String, String> entry : resourceIdTranslatedResourceIdMap.entrySet()) {
 194             if (entry.getValue().equals(parentPortNodeTemplateId)) {
 195                 return Optional.of(entry.getKey());
 196             }
 197         }
 198         return Optional.empty();
 199     }
 200
 201     private TranslateTo createTranslateTo(FunctionTranslator functionTranslator, String resourceId,
 202             String resourceTranslatedId) {
 203         Resource resource = functionTranslator.getHeatOrchestrationTemplate().getResources().get(resourceId);
 204         return new TranslateTo(ToscaUtil.getServiceTemplateFileName(functionTranslator.getServiceTemplate()),
 205             functionTranslator.getServiceTemplate(), functionTranslator.getHeatOrchestrationTemplate(),
 206             resource, resourceId, resourceTranslatedId, functionTranslator.getContext());
 207     }
 208
 209     private GetAttrFuncData createGetAttrFuncData(String propertyName, String attributeName) {
 210         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 211         getAttrFuncData.setFieldName(propertyName);
 212         getAttrFuncData.setAttributeName(attributeName);
 213         return getAttrFuncData;
 214     }
 215 }