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