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