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 resource the resource
 199      * @return true if the resource is of compute type and false otherwise
 200      */
 201     public static boolean isComputeResource(Resource resource) {
 202         String resourceType = resource.getType();
 203         Map<String, ImplementationConfiguration> supportedComputeResources =
 204                 TranslationContext.getSupportedConsolidationComputeResources();
 205         if (supportedComputeResources.containsKey(resourceType)) {
 206             return supportedComputeResources.get(resourceType).isEnable();
 207         }
 208         return false;
 209     }
 210
 211     /**
 212      * Checks if the current HEAT resource if of type port.
 213      *
 214      * @param resource the resource
 215      * @return true if the resource is of port type and false otherwise
 216      */
 217     public static boolean isPortResource(Resource resource) {
 218         String resourceType = resource.getType();
 219         Map<String, ImplementationConfiguration> supportedPortResources =
 220                 TranslationContext.getSupportedConsolidationPortResources();
 221         if (supportedPortResources.containsKey(resourceType)) {
 222             return supportedPortResources.get(resourceType).isEnable();
 223         }
 224         return false;
 225     }
 226
 227     /**
 228      * Checks if the current HEAT resource if of type volume.
 229      *
 230      * @param resource the resource
 231      * @return true if the resource is of volume type and false otherwise
 232      */
 233     public static boolean isVolumeResource(Resource resource) {
 234         String resourceType = resource.getType();
 235         return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
 236                        || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
 237                                                       .getHeatResource());
 238     }
 239
 240     /**
 241      * Gets port type.
 242      *
 243      * @param portNodeTemplateId the port node template id
 244      * @return the port type
 245      */
 246     public static String getPortType(String portNodeTemplateId) {
 247
 248         if (StringUtils.isBlank(portNodeTemplateId)) {
 249             return portNodeTemplateId;
 250         }
 251
 252         String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
 253
 254         StringBuilder sb = new StringBuilder();
 255         int count = 0;
 256         for (String token : formattedName.split(UNDERSCORE)) {
 257
 258             if (StringUtils.isNotBlank(token)) {
 259                 count++;
 260             }
 261
 262             if (count != 2 || (!StringUtils.isBlank(token) && !token.matches(DIGIT_REGEX))) {
 263                 sb.append(token).append(UNDERSCORE);
 264             }
 265         }
 266
 267         return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
 268     }
 269
 270     /**
 271      * Update node template id for the nested node templates in the consolidation data.
 272      *
 273      * @param translateTo the translate to
 274      */
 275     public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
 276         TranslationContext context = translateTo.getContext();
 277         ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 278         String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
 279         // create nested in consolidation data
 280         context.getNestedConsolidationDataHandler()
 281                 .addConsolidationData(serviceTemplateFileName, context,
 282                   translateTo.getHeatFileName(), translateTo.getTranslatedId());
 283
 284     }
 285
 286     public static void removeSharedResource(ServiceTemplate serviceTemplate,
 287                                                    HeatOrchestrationTemplate heatOrchestrationTemplate,
 288                                                    TranslationContext context,
 289                                                    String paramName,
 290                                                    String contrailSharedResourceId,
 291                                                    String sharedTranslatedResourceId) {
 292         Optional<ConsolidationDataHandler> consolidationDataHandler =
 293                 ConsolidationDataUtil.getConsolidationDataHandler(heatOrchestrationTemplate, context,
 294                         contrailSharedResourceId);
 295
 296         consolidationDataHandler.ifPresent(
 297                 handler -> handler.removeParamNameFromAttrFuncList(serviceTemplate, heatOrchestrationTemplate,
 298                         paramName, contrailSharedResourceId, sharedTranslatedResourceId));
 299     }
 300
 301     public static void updateNodeGetAttributeIn(FunctionTranslator functionTranslator, String resourceTranslatedId,
 302             String targetResourceId, String targetResourceTranslatedId,  String attributeName) {
 303
 304         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 305             return;
 306         }
 307         Optional<ConsolidationDataHandler> consolidationDataHandler =
 308                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 309                         functionTranslator.getContext(), targetResourceId);
 310
 311         consolidationDataHandler.ifPresent(handler -> handler.addNodesGetAttrIn(functionTranslator,
 312                 resourceTranslatedId, targetResourceId, targetResourceTranslatedId,
 313                 getToscaPropertyName(functionTranslator), attributeName));
 314     }
 315
 316     public static void updateNodeGetAttributeOut(FunctionTranslator functionTranslator,
 317             String targetTranslatedResourceId, String resourceTranslatedId, String attrName) {
 318
 319         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 320             return;
 321         }
 322
 323         Optional<ConsolidationDataHandler> consolidationDataHandler =
 324                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 325                         functionTranslator.getContext(), functionTranslator.getResourceId());
 326
 327         consolidationDataHandler.ifPresent(handler -> handler.addNodesGetAttrOut(functionTranslator,
 328                 targetTranslatedResourceId, resourceTranslatedId, getToscaPropertyName(functionTranslator), attrName));
 329     }
 330
 331     public static void updateOutputParamGetAttrIn(FunctionTranslator functionTranslator,
 332             String targetResourceId, String targetResourceTranslatedId, String propertyName, String attrName) {
 333         if (functionTranslator == null || functionTranslator.getServiceTemplate() == null) {
 334             return;
 335         }
 336
 337         Optional<ConsolidationDataHandler> consolidationDataHandler =
 338                 ConsolidationDataUtil.getConsolidationDataHandler(functionTranslator.getHeatOrchestrationTemplate(),
 339                         functionTranslator.getContext(), targetResourceId);
 340
 341         consolidationDataHandler.ifPresent(handler -> handler.addOutputParamGetAttrIn(functionTranslator,
 342                 targetResourceId, targetResourceTranslatedId, propertyName, attrName));
 343     }
 344
 345     private static Optional<ConsolidationDataHandler> getConsolidationDataHandler(
 346             HeatOrchestrationTemplate heatOrchestrationTemplate, TranslationContext context,
 347                     String contrailSharedResourceId) {
 348         Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
 349         ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
 350         consolidationEntityType.setEntityType(resource, resource, context);
 351         return context.getConsolidationDataHandler(consolidationEntityType.getSourceEntityType());
 352     }
 353
 354     private static String getToscaPropertyName(FunctionTranslator functionTranslator) {
 355         HeatOrchestrationTemplate heatOrchestrationTemplate = functionTranslator.getHeatOrchestrationTemplate();
 356         Resource resource = heatOrchestrationTemplate.getResources().get(functionTranslator.getResourceId());
 357         String toscaPropertyName = functionTranslator.getPropertyName();
 358         if (!HeatToToscaUtil.isNestedResource(resource)) {
 359             return HeatToToscaUtil.getToscaPropertyName(functionTranslator.getContext(),
 360                     resource.getType(), getHeatPropertyName(toscaPropertyName));
 361         }
 362         return toscaPropertyName;
 363     }
 364
 365     private static String getHeatPropertyName(String toscaPropertyName) {
 366         if (toscaPropertyName.contains(TRANS_MAPPING_DELIMITER_CHAR)) {
 367             return toscaPropertyName.substring(0, toscaPropertyName.indexOf(TRANS_MAPPING_DELIMITER_CHAR));
 368         }
 369         return toscaPropertyName;
 370     }
 371
 372     public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
 373                                                             String portId) {
 374         if (MapUtils.isEmpty(compute.getPorts())) {
 375             return false;
 376         }
 377
 378         for (List<String> portIdsPerType : compute.getPorts().values()) {
 379             if (portIdsPerType.contains(portId)) {
 380                 return true;
 381             }
 382         }
 383         return false;
 384     }
 385
 386 }