openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/consolidation/NestedConsolidationDataHandler.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.RequirementAssignment;
  20 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  21 import org.openecomp.core.utilities.file.FileUtils;
  22 import org.openecomp.sdc.common.errors.CoreException;
  23 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  24 import org.openecomp.sdc.tosca.services.ToscaUtil;
  25 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  26 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  27 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
  28 import org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator;
  29
  30
  31 import java.util.Objects;
  32
  33 public class NestedConsolidationDataHandler implements ConsolidationDataHandler {
  34
  35     private final NestedConsolidationData nestedConsolidationData;
  36
  37     public NestedConsolidationDataHandler(NestedConsolidationData nestedConsolidationData) {
  38         this.nestedConsolidationData = nestedConsolidationData;
  39     }
  40
  41     @Override
  42     public void addNodesConnectedOut(TranslateTo translateTo, String nodeTemplateId, String requirementId,
  43                                             RequirementAssignment requirementAssignment) {
  44         EntityConsolidationData entityConsolidationData =
  45                 getNestedTemplateConsolidationData(translateTo, translateTo.getHeatFileName(),
  46                         translateTo.getTranslatedId());
  47
  48         if (Objects.nonNull(entityConsolidationData)) {
  49             entityConsolidationData.addNodesConnectedOut(nodeTemplateId, requirementId, requirementAssignment);
  50         }
  51     }
  52
  53     @Override
  54     public void addNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
  55                                            String dependentNodeTemplateId, String targetResourceId,
  56                                            String requirementId, RequirementAssignment requirementAssignment) {
  57         EntityConsolidationData entityConsolidationData =
  58                 getNestedTemplateConsolidationData(translateTo, translateTo.getHeatFileName(), dependentNodeTemplateId);
  59
  60         if (Objects.nonNull(entityConsolidationData)) {
  61             entityConsolidationData.addNodesConnectedIn(sourceNodeTemplateId, requirementId, requirementAssignment);
  62         }
  63     }
  64
  65     @Override
  66     public void removeParamNameFromAttrFuncList(ServiceTemplate serviceTemplate,
  67                                                        HeatOrchestrationTemplate heatOrchestrationTemplate,
  68                                                        String paramName,
  69                                                        String contrailSharedResourceId,
  70                                                        String sharedTranslatedResourceId) {
  71
  72         throw new UnsupportedOperationException("API removeParamNameFromAttrFuncList "
  73                                                + "not supported for NestedConsolidationDataHandler");
  74
  75     }
  76
  77     @Override
  78     public void addNodesGetAttrOut(FunctionTranslator functionTranslator, String nodeTemplateId,
  79             String resourceTranslatedId, String propertyName, String attributeName) {
  80
  81         EntityConsolidationData entityConsolidationData =
  82                 getNestedTemplateConsolidationData(functionTranslator,
  83                         functionTranslator.getHeatFileName(), resourceTranslatedId);
  84
  85         if (Objects.nonNull(entityConsolidationData)) {
  86             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
  87             entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
  88         }
  89     }
  90
  91     @Override
  92     public void addNodesGetAttrIn(FunctionTranslator functionTranslator,String nodeTemplateId, String targetResourceId,
  93             String targetResourceTranslatedId,  String propertyName, String attributeName) {
  94
  95         EntityConsolidationData entityConsolidationData =
  96                 getNestedTemplateConsolidationData(functionTranslator, functionTranslator.getHeatFileName(),
  97                         targetResourceId);
  98
  99         if (Objects.nonNull(entityConsolidationData)) {
 100             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 101             entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
 102         }
 103     }
 104
 105     @Override
 106     public void addOutputParamGetAttrIn(FunctionTranslator functionTranslator, String targetResourceId,
 107             String targetResourceTranslatedId, String propertyName, String attributeName) {
 108
 109         EntityConsolidationData entityConsolidationData =
 110                 getNestedTemplateConsolidationData(functionTranslator, functionTranslator.getHeatFileName(),
 111                         targetResourceId);
 112
 113         if (Objects.nonNull(entityConsolidationData)) {
 114             GetAttrFuncData getAttrFuncData = createGetAttrFuncData(propertyName, attributeName);
 115             entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
 116         }
 117     }
 118
 119     /**
 120      * Add nested consolidation data base on given parameters.
 121      */
 122     public void addConsolidationData(String serviceTemplateFileName,  TranslationContext context,
 123                                             String nestedHeatFileName, String nestedNodeTemplateId) {
 124         getNestedTemplateConsolidationData(serviceTemplateFileName, context,
 125                 nestedHeatFileName, nestedNodeTemplateId);
 126     }
 127
 128     private GetAttrFuncData createGetAttrFuncData(String propertyName, String attributeName) {
 129         GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
 130         getAttrFuncData.setFieldName(propertyName);
 131         getAttrFuncData.setAttributeName(attributeName);
 132         return getAttrFuncData;
 133     }
 134
 135     private NestedTemplateConsolidationData getNestedTemplateConsolidationData(FunctionTranslator functionTranslator,
 136             String nestedHeatFileName, String nestedNodeTemplateId) {
 137         ServiceTemplate serviceTemplate = functionTranslator.getServiceTemplate();
 138         TranslationContext context = functionTranslator.getContext();
 139         return getNestedTemplateConsolidationData(ToscaUtil
 140                .getServiceTemplateFileName(serviceTemplate), context, nestedHeatFileName, nestedNodeTemplateId);
 141
 142     }
 143
 144     private NestedTemplateConsolidationData getNestedTemplateConsolidationData(TranslateTo translateTo,
 145             String nestedHeatFileName, String nestedNodeTemplateId) {
 146         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 147         TranslationContext context = translateTo.getContext();
 148         return getNestedTemplateConsolidationData(ToscaUtil
 149                 .getServiceTemplateFileName(serviceTemplate), context, nestedHeatFileName, nestedNodeTemplateId);
 150     }
 151
 152     private NestedTemplateConsolidationData getNestedTemplateConsolidationData(
 153             String serviceTemplateFileName,  TranslationContext context,
 154             String nestedHeatFileName, String nestedNodeTemplateId) {
 155
 156         if (isNestedResourceIdOccursInDifferentNestedFiles(context, nestedHeatFileName, nestedNodeTemplateId)) {
 157             throw new CoreException(new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
 158         }
 159
 160         if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
 161                 nestedNodeTemplateId, nestedHeatFileName, context)) {
 162             return null;
 163         }
 164         return nestedConsolidationData
 165                 .addNestedTemplateConsolidationData(serviceTemplateFileName, nestedNodeTemplateId);
 166     }
 167
 168     private boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String nestedNodeTemplateId,
 169                      String nestedHeatFileName, TranslationContext context) {
 170
 171         return context.isServiceTemplateWithoutNodeTemplatesSection(
 172                 FileUtils.getFileWithoutExtention(nestedHeatFileName))
 173                        || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
 174     }
 175
 176     private boolean isNestedResourceIdOccursInDifferentNestedFiles(TranslationContext context,
 177                     String nestedHeatFileName, String nestedNodeTemplateId) {
 178         return Objects.nonNull(nestedHeatFileName) && context.getAllTranslatedResourceIdsFromDiffNestedFiles(
 179                 nestedHeatFileName).contains(nestedNodeTemplateId);
 180     }
 181
 182     public boolean isNestedConsolidationDataExist(String serviceTemplateName) {
 183         return nestedConsolidationData.isNestedConsolidationDataExist(serviceTemplateName);
 184     }
 185 }