openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.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.services.heattotosca;
  18
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Optional;
  22
  23 import org.apache.commons.collections4.MapUtils;
  24 import org.apache.commons.lang3.StringUtils;
  25 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  26 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  27 import org.openecomp.core.utilities.file.FileUtils;
  28 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
  29 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  30 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  31 import org.openecomp.sdc.heat.datatypes.model.Resource;
  32 import org.openecomp.sdc.tosca.services.DataModelUtil;
  33 import org.openecomp.sdc.tosca.services.ToscaUtil;
  34 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  35 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationDataHandler;
  37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationDataHandler;
  39 import org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator;
  40
  41 import static org.openecomp.sdc.translator.services.heattotosca.ConfigConstants.TRANS_MAPPING_DELIMITER_CHAR;
  42
  43     /**
  44      * Utility class for consolidation data collection helper methods.
  45     */
  46     public class ConsolidationDataUtil {
  47
  48     private static final String UNDERSCORE = "_";
  49     private static final String DIGIT_REGEX = "\\d+";
  50
  51     private ConsolidationDataUtil() {
  52         // prevent instantiation of utility class
  53     }
  54
  55     public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
  56             String nestedNodeTemplateId, String nestedHeatFileName, TranslationContext context) {
  57         return context.isServiceTemplateWithoutNodeTemplatesSection(
  58                 FileUtils.getFileWithoutExtention(nestedHeatFileName))
  59                        || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
  60     }
  61
  62     /**
  63      * Update volume information in consolidation data.
  64      *
  65      * @param translateTo           {@link TranslateTo} object
  66      * @param computeType           Local type of the compute node
  67      * @param computeNodeTemplateId Node template id of the compute node
  68      * @param requirementAssignment RequirementAssignment object
  69      */
  70     public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
  71                                                                     String computeType,
  72                                                                     String computeNodeTemplateId,
  73                                                                     String requirementId,
  74                                                                     RequirementAssignment requirementAssignment) {
  75         ComputeConsolidationDataHandler handler =
  76                 translateTo.getContext().getComputeConsolidationDataHandler();
  77         handler.addVolumeToConsolidationData(
  78                 translateTo, computeType, computeNodeTemplateId, requirementId, requirementAssignment);
  79     }
  80
  81     /**
  82      * Update port in consolidation data.
  83      *
  84      * @param translateTo        the translate to
  85      * @param computeNodeType    the compute node type
  86      * @param portResourceId     the port resource id
  87      * @param portNodeTemplateId the port node template id
  88      */
  89     public static void updatePortInConsolidationData(TranslateTo translateTo,
  90                                                             String computeNodeType,
  91                                                             String portResourceId,
  92                                                             String portResourceType,
  93                                                             String portNodeTemplateId) {
  94         TranslationContext translationContext = translateTo.getContext();
  95         String computeNodeTemplateId = translateTo.getTranslatedId();
  96         String portType = getPortType(portNodeTemplateId, DataModelUtil.getNamespaceSuffix(computeNodeType));
  97
  98         translationContext.getComputeConsolidationDataHandler().addPortToConsolidationData(
  99                 translateTo, computeNodeType, computeNodeTemplateId, portType, portNodeTemplateId);
 100
 101         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 102         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 103         translationContext.getPortConsolidationDataHandler().addConsolidationData(
 104                 serviceTemplateFileName, portResourceId, portResourceType, portNodeTemplateId, portType);
 105     }
 106
 107     /**
 108      * Update nodes connected in and out for Depends on and connectivity in consolidation data.
 109      *
 110      * @param translateTo           the translate to
 111      * @param targetResourceId      the target resource id
 112      * @param nodeTemplateId        the source node template id
 113      * @param requirementAssignment the requirement assignment
 114      */
 115     public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
 116                                                        Resource targetResource, Resource sourceResource,
 117                                                        String nodeTemplateId, String requirementId,
 118                                                        RequirementAssignment requirementAssignment) {
 119         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 120         consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
 121         // Add resource dependency information in nodesConnectedIn if the target node
 122         // is a consolidation entity
 123         if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
 124             ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
 125                     nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
 126                     requirementId, requirementAssignment);
 127         }
 128
 129         //Add resource dependency information in nodesConnectedOut if the source node
 130         //is a consolidation entity
 131         if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
 132             ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
 133                     requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
 134                     requirementId, requirementAssignment);
 135
 136         }
 137     }
 138
 139
 140     private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
 141         return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
 142     }
 143
 144     /**
 145      * Update nodes connected from this node in consolidation data.
 146      *
 147      * @param translateTo             the translate to
 148      * @param nodeTemplateId          the node template id of the target node
 149      * @param consolidationEntityType the entity type (compute or port)
 150      * @param requirementId           the requirement id
 151      * @param requirementAssignment   the requirement assignment
 152      */
 153     public static void updateNodesConnectedOut(TranslateTo translateTo,
 154                                                       String nodeTemplateId,
 155                                                       ConsolidationEntityType consolidationEntityType,
 156                                                       String requirementId,
 157                                                       RequirementAssignment requirementAssignment) {
 158         TranslationContext translationContext = translateTo.getContext();
 159         translationContext.updateRequirementAssignmentIdIndex(
 160                 ToscaUtil.getServiceTemplateFileName(translateTo.getServiceTemplate()), translateTo.getResourceId(),
 161                 requirementId);
 162
 163         Optional<ConsolidationDataHandler> consolidationDataHandler =
 164                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 165         consolidationDataHandler.ifPresent(handler -> handler.addNodesConnectedOut(
 166                 translateTo, nodeTemplateId, requirementId, requirementAssignment));
 167
 168     }
 169
 170     /**
 171      * Update nodes connected from this node in consolidation data.
 172      *
 173      * @param translateTo             the translate to
 174      * @param sourceNodeTemplateId    the node template id of the source node
 175      * @param consolidationEntityType Entity type (compute or port)
 176      * @param targetResourceId        Target Resource Id
 177      * @param requirementId           Requirement Id
 178      * @param requirementAssignment   the requirement assignment
 179      */
 180     public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
 181                                                      ConsolidationEntityType consolidationEntityType,
 182                                                      String targetResourceId,
 183                                                      String requirementId,
 184                                                      RequirementAssignment requirementAssignment) {
 185
 186         TranslationContext translationContext = translateTo.getContext();
 187         Optional<ConsolidationDataHandler> consolidationDataHandler =
 188                 translationContext.getConsolidationDataHandler(consolidationEntityType);
 189         String dependentNodeTemplateId = requirementAssignment.getNode();
 190         consolidationDataHandler.ifPresent(
 191                 handler -> handler.addNodesConnectedIn(translateTo, sourceNodeTemplateId, dependentNodeTemplateId,
 192                         targetResourceId, requirementId, requirementAssignment));
 193
 194     }
 195
 196     /**
 197      * Checks if the current HEAT resource if of type compute.
 198      *
 199      * @param resource the resource
 200      * @return true if the resource is of compute type and false otherwise
 201      */
 202     public static boolean isComputeResource(Resource resource) {
 203         String resourceType = resource.getType();
 204         Map<String, ImplementationConfiguration> supportedComputeResources =
 205                 TranslationContext.getSupportedConsolidationComputeResources();
 206         if (supportedComputeResources.containsKey(resourceType)) {
 207             return supportedComputeResources.get(resourceType).isEnable();
 208         }
 209         return false;
 210     }
 211
 212     /**
 213      * Checks if the current HEAT resource if of type port.
 214      *
 215      * @param resource the resource
 216      * @return true if the resource is of port type and false otherwise
 217      */
 218     public static boolean isPortResource(Resource resource) {
 219         String resourceType = resource.getType();
 220         Map<String, ImplementationConfiguration> supportedPortResources =
 221                 TranslationContext.getSupportedConsolidationPortResources();
 222         if (supportedPortResources.containsKey(resourceType)) {
 223             return supportedPortResources.get(resourceType).isEnable();
 224         }
 225         return false;
 226     }
 227
 228     /**
 229      * Checks if the current HEAT resource if of type volume.
 230      *
 231      * @param resource the resource
 232      * @return true if the resource is of volume type and false otherwise
 233      */
 234     public static boolean isVolumeResource(Resource resource) {
 235         String resourceType = resource.getType();
 236         return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 237                        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 238                                                       .getHeatResource());
 239     }
 240
 241     /**
 242      * Gets port type.
 243      *
 244      * @param portNodeTemplateId the port node template id
 245      * @return the port type
 246      */
 247     public static String getPortType(String portNodeTemplateId, String vmType) {
 248
 249         if (StringUtils.isBlank(portNodeTemplateId) || !portNodeTemplateId.startsWith(vmType + UNDERSCORE)) {
 250             return portNodeTemplateId;
 251         }
 252         String temp = portNodeTemplateId.substring(portNodeTemplateId.indexOf(vmType) + vmType.length());
 253
 254         StringBuilder sb = new StringBuilder(vmType + UNDERSCORE);
 255         String[] tokens = temp.split(UNDERSCORE);
 256
 257         if (tokens.length == 0) {
 258             return portNodeTemplateId;
 259         }
 260
 261         for (int i=0; i<tokens.length; i++) {
 262             String token = tokens[i];
 263             if (token.matches(DIGIT_REGEX) && i != 1) {
 264                 sb.append(token);
 265                 sb.append(UNDERSCORE);
 266             }
 267
 268             if (StringUtils.isNotBlank(token) && !token.matches(DIGIT_REGEX)) {
 269                 sb.append(token);
 270                 sb.append(UNDERSCORE);
 271             }
 272         }
 273
 274         return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 275     }
 276
 277     /**
 278      * Update node template id for the nested node templates in the consolidation data.
 279      *
 280      * @param translateTo the translate to
 281      */
 282     public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 283         TranslationContext context = translateTo.getContext();
 284         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 285         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 286         // create nested in consolidation data
 287         context.getNestedConsolidationDataHandler()
 288                 .addConsolidationData(serviceTemplateFileName, context,
 289                   translateTo.getHeatFileName(), translateTo.getTranslatedId());
 290
 291     }
 292
 293     public static void removeSharedResource(ServiceTemplate serviceTemplate,
 294                                                    HeatOrchestrationTemplate heatOrchestrationTemplate,
 295                                                    TranslationContext context,
 296                                                    String paramName,
 297                                                    String contrailSharedResourceId,
 298                                                    String sharedTranslatedResourceId) {
 299         Optional<ConsolidationDataHandler> consolidationDataHandler =
 300                 ConsolidationDataUtil.getConsolidationDataHandler(heatOrchestrationTemplate, context,
 301                         contrailSharedResourceId);
 302
 303         consolidationDataHandler.ifPresent(
 304                 handler -> handler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 305                         paramName, contrailSharedResourceId, sharedTranslatedResourceId));
 306     }
 307
 308     public static void updateNodeGetAttributeIn(FunctionTranslator functionTranslator, String resourceTranslatedId,
 309             String targetResourceId, String targetResourceTranslatedId,  String attributeName) {
 310
 311         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 312             return;
 313         }
 314         Optional<ConsolidationDataHandler> consolidationDataHandler =
 315                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 316                         functionTranslator.getContext(), targetResourceId);
 317
 318         consolidationDataHandler.ifPresent(handler -> handler.addNodesGetAttrIn(functionTranslator,
 319                 resourceTranslatedId, targetResourceId, targetResourceTranslatedId,
 320                 getToscaPropertyName(functionTranslator), attributeName));
 321     }
 322
 323     public static void updateNodeGetAttributeOut(FunctionTranslator functionTranslator,
 324             String targetTranslatedResourceId, String resourceTranslatedId, String attrName) {
 325
 326         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 327             return;
 328         }
 329
 330         Optional<ConsolidationDataHandler> consolidationDataHandler =
 331                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 332                         functionTranslator.getContext(), functionTranslator.getResourceId());
 333
 334         consolidationDataHandler.ifPresent(handler -> handler.addNodesGetAttrOut(functionTranslator,
 335                 targetTranslatedResourceId, resourceTranslatedId, getToscaPropertyName(functionTranslator), attrName));
 336     }
 337
 338     public static void updateOutputParamGetAttrIn(FunctionTranslator functionTranslator,
 339             String targetResourceId, String targetResourceTranslatedId, String propertyName, String attrName) {
 340         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 341             return;
 342         }
 343
 344         Optional<ConsolidationDataHandler> consolidationDataHandler =
 345                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 346                         functionTranslator.getContext(), targetResourceId);
 347
 348         consolidationDataHandler.ifPresent(handler -> handler.addOutputParamGetAttrIn(functionTranslator,
 349                 targetResourceId, targetResourceTranslatedId, propertyName, attrName));
 350     }
 351
 352     private static Optional<ConsolidationDataHandler> getConsolidationDataHandler(
 353             HeatOrchestrationTemplate heatOrchestrationTemplate, TranslationContext context,
 354                     String contrailSharedResourceId) {
 355         Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 356         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 357         consolidationEntityType.setEntityType(resource, resource, context);
 358         return context.getConsolidationDataHandler(consolidationEntityType.getSourceEntityType());
 359     }
 360
 361     private static String getToscaPropertyName(FunctionTranslator functionTranslator) {
 362         HeatOrchestrationTemplate heatOrchestrationTemplate = functionTranslator.getHeatOrchestrationTemplate();
 363         Resource resource = heatOrchestrationTemplate.getResources().get(functionTranslator.getResourceId());
 364         String toscaPropertyName = functionTranslator.getPropertyName();
 365         if (!HeatToToscaUtil.isNestedResource(resource)) {
 366             return HeatToToscaUtil.getToscaPropertyName(functionTranslator.getContext(),
 367                     resource.getType(), getHeatPropertyName(toscaPropertyName));
 368         }
 369         return toscaPropertyName;
 370     }
 371
 372     private static String getHeatPropertyName(String toscaPropertyName) {
 373         if (toscaPropertyName.contains(TRANS_MAPPING_DELIMITER_CHAR)) {
 374             return toscaPropertyName.substring(0, toscaPropertyName.indexOf(TRANS_MAPPING_DELIMITER_CHAR));
 375         }
 376         return toscaPropertyName;
 377     }
 378
 379     public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 380                                                             String portId) {
 381         if (MapUtils.isEmpty(compute.getPorts())) {
 382             return false;
 383         }
 384
 385         for (List<String> portIdsPerType : compute.getPorts().values()) {
 386             if (portIdsPerType.contains(portId)) {
 387                 return true;
 388             }
 389         }
 390         return false;
 391     }
 392
 393 }