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.Map;
  20 import java.util.Objects;
  21 import java.util.Optional;
  22
  23 import org.apache.commons.collections4.MapUtils;
  24 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  25 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  26 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  27 import org.openecomp.sdc.heat.datatypes.model.Resource;
  28 import org.openecomp.sdc.tosca.services.ToscaUtil;
  29 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  30 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  31 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  32 import org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator;
  33
  34 public class SubInterfaceConsolidationDataHandler implements ConsolidationDataHandler {
  35
  36     private final PortConsolidationData portConsolidationData;
  37
  38     SubInterfaceConsolidationDataHandler(PortConsolidationData portConsolidationData) {
  39         this.portConsolidationData = portConsolidationData;
  40     }
  41
  42     @Override
  43     public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
  44                                             RequirementAssignment requirementAssignment) {
  45         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  46         if (Objects.nonNull(
  47                 serviceTemplate.getTopology_template().getNode_templates().get(translateTo.getTranslatedId()))) {
  48             Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
  49                     getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
  50
  51             subInterfaceTemplateConsolidationData.ifPresent(consolidationData ->
  52                     consolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment));
  53         }
  54     }
  55
  56     @Override
  57     public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
  58                                            String dependentNodeTemplateId, String targetResourceId,
  59                                            String requirementId, RequirementAssignment requirementAssignment) {
  60         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  61         TranslationContext translationContext = translateTo.getContext();
  62         Resource targetResource = translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
  63         TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate,
  64                                                             translateTo.getHeatOrchestrationTemplate(), targetResource,
  65                                                             targetResourceId, null, translationContext);
  66         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
  67                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
  68
  69         subInterfaceTemplateConsolidationData.ifPresent(consolidationData ->
  70                 consolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment));
  71
  72     }
  73
  74     @Override
  75     public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
  76                                                        HeatOrchestrationTemplate heatOrchestrationTemplate,
  77                                                        String paramName, String contrailSharedResourceId,
  78                                                        String sharedTranslatedResourceId) {
  79
  80
  81         throw new UnsupportedOperationException(
  82                 "API removeParamNameFromAttrFuncList doesn't supported for SubInterfaceConsolidationDataHandler");
  83     }
  84
  85     @Override
  86     public void addNodesGetAttrOut(FunctionTranslator functionTranslator, String nodeTemplateId,
  87             String resourceTranslatedId, String propertyName, String attributeName) {
  88         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, functionTranslator.getResourceId(),
  89                 resourceTranslatedId);
  90
  91         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
  92                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, resourceTranslatedId);
  93
  94         subInterfaceConsolidationData.ifPresent(consolidationData -> {
  95             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
  96             consolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
  97         });
  98     }
  99
 100     @Override
 101     public void addNodesGetAttrIn(FunctionTranslator functionTranslator,String nodeTemplateId, String targetResourceId,
 102             String targetResourceTranslatedId,  String propertyName, String attributeName) {
 103
 104         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, targetResourceId,
 105                 targetResourceTranslatedId);
 106
 107         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
 108                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceTranslatedId);
 109
 110         subInterfaceConsolidationData.ifPresent(consolidationData -> {
 111             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 112             consolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 113         });
 114     }
 115
 116     @Override
 117     public void addOutputParamGetAttrIn(FunctionTranslator functionTranslator, String targetResourceId,
 118             String targetResourceTranslatedId, String propertyName, String attributeName) {
 119         TranslateTo subInterfaceTo = createTranslateTo(functionTranslator, targetResourceId,
 120                 targetResourceTranslatedId);
 121
 122         Optional<SubInterfaceTemplateConsolidationData> subInterfaceConsolidationData =
 123                 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceTranslatedId);
 124
 125         subInterfaceConsolidationData.ifPresent(consolidationData -> {
 126             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 127             consolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 128         });
 129     }
 130
 131     public void setNetworkRole(TranslateTo translateTo, String translatedId, String networkRole) {
 132         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 133                 getSubInterfaceTemplateConsolidationData(translateTo, translatedId);
 134
 135         subInterfaceTemplateConsolidationData.ifPresent(
 136                 consolidationData -> consolidationData.setNetworkRole(networkRole));
 137     }
 138
 139     public void setResourceGroupCount(TranslateTo translateTo, String translatedId,
 140             Object resourceGroupCount) {
 141         Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
 142                 getSubInterfaceTemplateConsolidationData(translateTo, translatedId);
 143
 144         subInterfaceTemplateConsolidationData.ifPresent(
 145                 consolidationData -> consolidationData.setResourceGroupCount(resourceGroupCount));
 146     }
 147
 148     private Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
 149             TranslateTo subInterfaceTo, String subInterfaceNodeTemplateId) {
 150         Optional<String> parentPortNodeTemplateId =
 151                 HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
 152         return parentPortNodeTemplateId.map(s -> getSubInterfaceTemplateConsolidationData(subInterfaceTo,
 153                 s, subInterfaceNodeTemplateId));
 154     }
 155
 156     private SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(TranslateTo subInterfaceTo,
 157             String parentPortNodeTemplateId, String subInterfaceNodeTemplateId) {
 158         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
 159         Resource resource = subInterfaceTo.getResource();
 160         Optional<String> portResourceId = getPortResourceId(subInterfaceTo, parentPortNodeTemplateId);
 161
 162         if (portResourceId.isPresent()) {
 163             String portResourceType = getPortResourceType(subInterfaceTo, portResourceId.get());
 164             return portConsolidationData
 165                     .addSubInterfaceTemplateConsolidationData(serviceTemplateFileName, resource,
 166                             subInterfaceNodeTemplateId, parentPortNodeTemplateId,
 167                                    portResourceId.get(), portResourceType);
 168         } else {
 169             return portConsolidationData
 170                     .addSubInterfaceTemplateConsolidationData(serviceTemplateFileName, resource,
 171                             subInterfaceNodeTemplateId, parentPortNodeTemplateId);
 172         }
 173     }
 174
 175     private String getPortResourceType(TranslateTo subInterfaceTo, String portResourceId) {
 176         return HeatToToscaUtil.getResourceType(portResourceId, subInterfaceTo
 177         .getHeatOrchestrationTemplate(), subInterfaceTo.getHeatFileName());
 178     }
 179
 180     private Optional<String> getPortResourceId(TranslateTo subInterfaceTo, String parentPortNodeTemplateId) {
 181         Map<String, String> resourceIdTranslatedResourceIdMap =
 182                 subInterfaceTo.getContext().getTranslatedIds().get(subInterfaceTo.getHeatFileName());
 183         return getSubInterfaceParentPortResourceId(parentPortNodeTemplateId,
 184                 resourceIdTranslatedResourceIdMap);
 185     }
 186
 187     private Optional<String> getSubInterfaceParentPortResourceId(String parentPortNodeTemplateId,
 188             Map<String, String> resourceIdTranslatedResourceIdMap) {
 189         if (MapUtils.isEmpty(resourceIdTranslatedResourceIdMap)) {
 190             return Optional.empty();
 191         }
 192         return resourceIdTranslatedResourceIdMap.entrySet().stream()
 193                .filter(entry -> entry.getValue().equals(parentPortNodeTemplateId))
 194                         .findFirst().map(Map.Entry::getKey);
 195     }
 196
 197     private TranslateTo createTranslateTo(FunctionTranslator functionTranslator, String resourceId,
 198             String resourceTranslatedId) {
 199         Resource resource = functionTranslator.getHeatOrchestrationTemplate().getResources().get(resourceId);
 200         return new TranslateTo(ToscaUtil.getServiceTemplateFileName(functionTranslator.getServiceTemplate()),
 201             functionTranslator.getServiceTemplate(), functionTranslator.getHeatOrchestrationTemplate(),
 202             resource, resourceId, resourceTranslatedId, functionTranslator.getContext());
 203     }
 204
 205     private GetAttrFuncData createGetAttrFuncData(String propertyName, String attributeName) {
 206         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 207         getAttrFuncData.setFieldName(propertyName);
 208         getAttrFuncData.setAttributeName(attributeName);
 209         return getAttrFuncData;
 210     }
 211 }