openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/impl/resourcetranslation/ResourceTranslationNovaServerImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;
  22
  23 import org.apache.commons.collections4.CollectionUtils;
  24 import org.apache.commons.collections4.MapUtils;
  25 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  26 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  27 import org.openecomp.sdc.heat.datatypes.model.Resource;
  28 import org.openecomp.sdc.heat.services.HeatConstants;
  29 import org.openecomp.sdc.logging.api.Logger;
  30 import org.openecomp.sdc.logging.api.LoggerFactory;
  31 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  32 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  33 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  34 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
  35 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  36 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  37 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
  38 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  39 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  40 import org.openecomp.sdc.tosca.services.DataModelUtil;
  41 import org.openecomp.sdc.tosca.services.ToscaConstants;
  42 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
  43 import org.openecomp.sdc.translator.datatypes.heattotosca.PropertyRegexMatcher;
  44 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
  45 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  46 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
  47
  48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
  49 import org.openecomp.sdc.translator.services.heattotosca.ConfigConstants;
  50 import org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil;
  51 import org.openecomp.sdc.translator.services.heattotosca.Constants;
  52 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  53 import org.openecomp.sdc.translator.services.heattotosca.NameExtractor;
  54 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  55
  56 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter;
  57
  58 import java.util.ArrayList;
  59 import java.util.Arrays;
  60 import java.util.Collections;
  61 import java.util.HashMap;
  62 import java.util.List;
  63 import java.util.Map;
  64 import java.util.Objects;
  65 import java.util.Optional;
  66
  67
  68 public class ResourceTranslationNovaServerImpl extends ResourceTranslationBase {
  69   protected static Logger logger =
  70       (Logger) LoggerFactory.getLogger(ResourceTranslationNovaServerImpl.class);
  71
  72   @Override
  73   protected void translate(TranslateTo translateTo) {
  74
  75
  76     mdcDataDebugMessage.debugEntryMessage(null, null);
  77
  78     TranslationContext context = translateTo.getContext();
  79     Map<String, Object> properties = translateTo.getResource().getProperties();
  80     String heatFileName = translateTo.getHeatFileName();
  81
  82     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
  83     String nodeTypeRef = createLocalNodeType(serviceTemplate, translateTo.getResource(),
  84         translateTo.getResourceId(), translateTo.getTranslatedId(), context);
  85
  86     //create compute in consolidation data
  87     ConsolidationDataUtil.getComputeTemplateConsolidationData(context, serviceTemplate,
  88         nodeTypeRef, translateTo.getTranslatedId());
  89
  90     NodeTemplate novaNodeTemplate = new NodeTemplate();
  91     novaNodeTemplate.setType(nodeTypeRef);
  92     HeatOrchestrationTemplate heatOrchestrationTemplate =
  93         translateTo.getHeatOrchestrationTemplate();
  94     novaNodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
  95         .getToscaPropertiesSimpleConversion(serviceTemplate, translateTo.getResourceId(),
  96             properties, novaNodeTemplate.getProperties(), heatFileName,
  97             heatOrchestrationTemplate, translateTo.getResource().getType(),
  98             novaNodeTemplate, context));
  99
 100     HeatToToscaUtil.mapBoolean(novaNodeTemplate, HeatToToscaUtil
 101         .getToscaPropertyName(translateTo, HeatConstants.CONFIG_DRIVE_PROPERTY_NAME));
 102
 103     manageNovaServerNetwork(translateTo, novaNodeTemplate);
 104     manageNovaServerBlockDeviceMapping(translateTo, novaNodeTemplate);
 105     manageNovaServerGroupMapping(translateTo, context, properties, heatFileName, serviceTemplate,
 106         novaNodeTemplate, heatOrchestrationTemplate);
 107     DataModelUtil.addNodeTemplate(serviceTemplate, translateTo.getTranslatedId(), novaNodeTemplate);
 108
 109     mdcDataDebugMessage.debugExitMessage(null, null);
 110   }
 111
 112   private void manageNovaServerGroupMapping(TranslateTo translateTo, TranslationContext context,
 113                                             Map<String, Object> properties, String heatFileName,
 114                                             ServiceTemplate serviceTemplate,
 115                                             NodeTemplate novaNodeTemplate,
 116                                             HeatOrchestrationTemplate heatOrchestrationTemplate) {
 117
 118
 119     mdcDataDebugMessage.debugEntryMessage(null, null);
 120
 121     if (isSchedulerHintsPropExist(properties)) {
 122       Object schedulerHints = properties.get("scheduler_hints");
 123       if (schedulerHints instanceof Map) {
 124         addServerGroupHintsToPoliciesGroups(translateTo, context, heatFileName, serviceTemplate,
 125             novaNodeTemplate, heatOrchestrationTemplate, (Map<String, Object>) schedulerHints);
 126       } else {
 127         logger.warn("'scheduler_hints' property of resource '" + translateTo.getResourceId()
 128             + "' is not valid. This property should be a map");
 129       }
 130     }
 131
 132     mdcDataDebugMessage.debugExitMessage(null, null);
 133   }
 134
 135   private void addServerGroupHintsToPoliciesGroups(TranslateTo translateTo,
 136                                                    TranslationContext context, String heatFileName,
 137                                                    ServiceTemplate serviceTemplate,
 138                                                    NodeTemplate novaNodeTemplate,
 139                                                    HeatOrchestrationTemplate
 140                                                        heatOrchestrationTemplate,
 141                                                    Map<String, Object> schedulerHints) {
 142
 143
 144     mdcDataDebugMessage.debugEntryMessage(null, null);
 145
 146     for (Object hint : schedulerHints.values()) {
 147       Optional<AttachedResourceId> attachedResourceId = HeatToToscaUtil
 148           .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context, hint);
 149       if (attachedResourceId.isPresent()) {
 150         AttachedResourceId serverGroupResourceId = attachedResourceId.get();
 151         Object serverGroupResourceToTranslate = serverGroupResourceId.getEntityId();
 152         if (serverGroupResourceId.isGetResource()) {
 153           boolean isHintOfTypeNovaServerGroup =
 154               isHintOfTypeNovaServerGroup(heatOrchestrationTemplate,
 155                   serverGroupResourceToTranslate);
 156           if (isHintOfTypeNovaServerGroup) {
 157             addNovaServerToPolicyGroup(translateTo, context, heatFileName, serviceTemplate,
 158                 heatOrchestrationTemplate, (String) serverGroupResourceToTranslate,
 159                 novaNodeTemplate);
 160           }
 161         } else if (serverGroupResourceId.isGetParam()
 162             && serverGroupResourceToTranslate instanceof String) {
 163           TranslatedHeatResource
 164               translatedServerGroupResource =
 165               context.getHeatSharedResourcesByParam().get(serverGroupResourceToTranslate);
 166           if (Objects.nonNull(translatedServerGroupResource)
 167               && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())
 168               && isResourceTypeServerGroup(translatedServerGroupResource)) {
 169             Map<String, GroupDefinition> groups =
 170                 serviceTemplate.getTopology_template().getGroups();
 171             if(MapUtils.isNotEmpty(groups) && Objects.nonNull(groups.get(translatedServerGroupResource
 172                 .getTranslatedId()))) {
 173               groups
 174                   .get(translatedServerGroupResource.getTranslatedId()).getMembers()
 175                   .add(translateTo.getTranslatedId());
 176               //Add group Id to compute consolidation data
 177               updateComputeConsolidationDataGroup(translateTo, novaNodeTemplate,
 178                   translatedServerGroupResource.getTranslatedId());
 179             }
 180           }
 181         }
 182       }
 183     }
 184
 185     mdcDataDebugMessage.debugExitMessage(null, null);
 186   }
 187
 188   private boolean isResourceTypeServerGroup(TranslatedHeatResource translatedServerGroupResource) {
 189     return translatedServerGroupResource.getHeatResource().getType().equals(HeatResourcesTypes.NOVA_SERVER_GROUP_RESOURCE_TYPE.getHeatResource());
 190   }
 191
 192   private void updateComputeConsolidationDataGroup(TranslateTo translateTo,
 193                                                    NodeTemplate novaNodeTemplate,
 194                                                    String groupId) {
 195     TranslationContext translationContext = translateTo.getContext();
 196     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 197     ComputeTemplateConsolidationData computeTemplateConsolidationData = ConsolidationDataUtil
 198         .getComputeTemplateConsolidationData(translationContext, serviceTemplate,
 199             novaNodeTemplate.getType(),
 200             translateTo.getTranslatedId());
 201     ConsolidationDataUtil.updateGroupIdInConsolidationData(computeTemplateConsolidationData,
 202         groupId);
 203   }
 204
 205   private boolean isHintOfTypeNovaServerGroup(HeatOrchestrationTemplate heatOrchestrationTemplate,
 206                                               Object resourceToTranslate) {
 207     return heatOrchestrationTemplate.getResources().get(resourceToTranslate).getType()
 208         .equals(HeatResourcesTypes.NOVA_SERVER_GROUP_RESOURCE_TYPE.getHeatResource());
 209   }
 210
 211   private void addNovaServerToPolicyGroup(TranslateTo translateTo, TranslationContext context,
 212                                           String heatFileName, ServiceTemplate serviceTemplate,
 213                                           HeatOrchestrationTemplate heatOrchestrationTemplate,
 214                                           String resourceToTranslate,
 215                                           NodeTemplate novaNodeTemplate) {
 216     mdcDataDebugMessage.debugEntryMessage(null, null);
 217
 218     Resource serverGroup =
 219         HeatToToscaUtil.getResource(heatOrchestrationTemplate, resourceToTranslate, heatFileName);
 220     Optional<String> serverGroupTranslatedId = ResourceTranslationFactory.getInstance(serverGroup)
 221         .translateResource(heatFileName, serviceTemplate, heatOrchestrationTemplate, serverGroup,
 222             resourceToTranslate, context);
 223     if (serverGroupTranslatedId.isPresent()) {
 224       serviceTemplate.getTopology_template().getGroups().get(serverGroupTranslatedId.get())
 225           .getMembers().add(translateTo.getTranslatedId());
 226       updateComputeConsolidationDataGroup(translateTo, novaNodeTemplate,
 227           serverGroupTranslatedId.get());
 228
 229     }
 230     mdcDataDebugMessage.debugExitMessage(null, null);
 231   }
 232
 233   private boolean isSchedulerHintsPropExist(Map<String, Object> properties) {
 234     return !MapUtils.isEmpty(properties) && Objects.nonNull(properties.get("scheduler_hints"));
 235   }
 236
 237   private void manageNovaServerBlockDeviceMapping(TranslateTo translateTo,
 238                                                   NodeTemplate novaNodeTemplate) {
 239     mdcDataDebugMessage.debugEntryMessage(null, null);
 240     String heatFileName = translateTo.getHeatFileName();
 241     TranslationContext context = translateTo.getContext();
 242     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 243     Resource resource = translateTo.getResource();
 244     String resourceId = translateTo.getResourceId();
 245     String novaServerTranslatedId = translateTo.getTranslatedId();
 246     HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo
 247         .getHeatOrchestrationTemplate();
 248     List<Map<String, Object>> blockDeviceMappingList = getBlockDeviceMappingList(resource);
 249     if (CollectionUtils.isEmpty(blockDeviceMappingList)) {
 250       return;
 251     }
 252
 253     Object volumeIdObject;
 254     Object snapshotIdObject;
 255     String volumeResourceId;
 256     int index = 0;
 257     for (Map<String, Object> blockDeviceMapping : blockDeviceMappingList) {
 258       volumeIdObject = blockDeviceMapping.get("volume_id");
 259       snapshotIdObject = blockDeviceMapping.get("snapshot_id");
 260
 261       if (volumeIdObject == null && snapshotIdObject == null) {
 262         logger.warn("Resource '" + resourceId
 263             + "' has block_device_mapping property with empty/missing volume_id and snapshot_id "
 264             + "properties. Entry number "
 265             + (index + 1) + ", this entry will be ignored in TOSCA translation.");
 266         index++;
 267         continue;
 268       }
 269       if (volumeIdObject == null) {
 270         Optional<AttachedResourceId> attachedSnapshotId = HeatToToscaUtil
 271             .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context,
 272                 snapshotIdObject);
 273         if (attachedSnapshotId.isPresent()) {
 274           volumeResourceId = novaServerTranslatedId + "_" + attachedSnapshotId.get().getEntityId();
 275           String deviceName = (String) blockDeviceMapping.get("device_name");
 276           String relationshipId = novaServerTranslatedId + "_" + index;
 277
 278           createVolumeAttachesToRelationship(serviceTemplate, deviceName, novaServerTranslatedId,
 279               volumeResourceId, relationshipId);
 280           createCinderVolumeNodeTemplate(serviceTemplate, translateTo.getResourceId(),
 281               volumeResourceId, heatFileName, blockDeviceMapping, heatOrchestrationTemplate,
 282               context);
 283           connectNovaServerToVolume(novaNodeTemplate, volumeResourceId, relationshipId,
 284               translateTo);
 285         }
 286       } else {
 287         Optional<AttachedResourceId> attachedVolumeId = HeatToToscaUtil
 288             .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context,
 289                 volumeIdObject);
 290         if (attachedVolumeId.isPresent() && attachedVolumeId.get().isGetResource()) {
 291           connectNovaServerToVolume(novaNodeTemplate,
 292               (String) attachedVolumeId.get().getTranslatedId(), null, translateTo);
 293         }
 294       }
 295       index++;
 296     }
 297
 298     mdcDataDebugMessage.debugExitMessage(null, null);
 299   }
 300
 301   private void connectNovaServerToVolume(NodeTemplate novaNodeTemplate, String volumeResourceId,
 302                                          String relationshipId, TranslateTo translateTo) {
 303
 304
 305     mdcDataDebugMessage.debugEntryMessage(null, null);
 306
 307     RequirementAssignment requirementAssignment = new RequirementAssignment();
 308     requirementAssignment.setCapability(ToscaCapabilityType.NATIVE_ATTACHMENT);
 309     requirementAssignment.setNode(volumeResourceId);
 310     if (relationshipId != null) {
 311       requirementAssignment.setRelationship(relationshipId);
 312     } else {
 313       requirementAssignment
 314           .setRelationship(ToscaRelationshipType.NATIVE_ATTACHES_TO);
 315     }
 316     DataModelUtil
 317         .addRequirementAssignment(novaNodeTemplate, ToscaConstants.LOCAL_STORAGE_REQUIREMENT_ID,
 318             requirementAssignment);
 319     //Add volume consolidation data
 320     ConsolidationDataUtil.updateComputeConsolidationDataVolumes(translateTo, novaNodeTemplate
 321             .getType(), translateTo.getTranslatedId(), ToscaConstants.LOCAL_STORAGE_REQUIREMENT_ID,
 322         requirementAssignment);
 323
 324     mdcDataDebugMessage.debugExitMessage(null, null);
 325   }
 326
 327   private void createCinderVolumeNodeTemplate(ServiceTemplate serviceTemplate, String resourceId,
 328                                               String volumeResourceId, String heatFileName,
 329                                               Map<String, Object> blockDeviceMapping,
 330                                               HeatOrchestrationTemplate heatOrchestrationTemplate,
 331                                               TranslationContext context) {
 332
 333
 334     mdcDataDebugMessage.debugEntryMessage(null, null);
 335
 336     NodeTemplate cinderVolumeNodeTemplate = new NodeTemplate();
 337     cinderVolumeNodeTemplate.setType(ToscaNodeType.CINDER_VOLUME);
 338     cinderVolumeNodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
 339         .getToscaPropertiesSimpleConversion(serviceTemplate, resourceId, blockDeviceMapping, null,
 340             heatFileName, heatOrchestrationTemplate,
 341             HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource(),
 342             cinderVolumeNodeTemplate, context));
 343     DataModelUtil.addNodeTemplate(serviceTemplate, volumeResourceId, cinderVolumeNodeTemplate);
 344
 345     mdcDataDebugMessage.debugExitMessage(null, null);
 346   }
 347
 348   private void createVolumeAttachesToRelationship(ServiceTemplate serviceTemplate,
 349                                                   String deviceName, String novaServerTranslatedId,
 350                                                   String volumeId, String relationshipId) {
 351
 352
 353     mdcDataDebugMessage.debugEntryMessage(null, null);
 354
 355     RelationshipTemplate relationshipTemplate = new RelationshipTemplate();
 356     relationshipTemplate.setType(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO);
 357     Map<String, Object> properties = new HashMap<>();
 358     properties.put("instance_uuid", novaServerTranslatedId);
 359     properties.put("volume_id", volumeId);
 360     if (deviceName != null) {
 361       properties.put("device", deviceName);
 362     }
 363     relationshipTemplate.setProperties(properties);
 364
 365     DataModelUtil.addRelationshipTemplate(serviceTemplate, relationshipId, relationshipTemplate);
 366
 367     mdcDataDebugMessage.debugExitMessage(null, null);
 368   }
 369
 370   private List<Map<String, Object>> getBlockDeviceMappingList(Resource resource) {
 371
 372
 373     mdcDataDebugMessage.debugEntryMessage(null, null);
 374
 375     if (Objects.isNull(resource.getProperties())) {
 376       return Collections.emptyList();
 377     }
 378     List<Map<String, Object>> blockDeviceMappingList =
 379         (List<Map<String, Object>>) resource.getProperties().get("block_device_mapping");
 380     List<Map<String, Object>> blockDeviceMappingV2List =
 381         (List<Map<String, Object>>) resource.getProperties().get("block_device_mapping_v2");
 382
 383     if (blockDeviceMappingList != null && blockDeviceMappingV2List != null) {
 384       blockDeviceMappingList.addAll(blockDeviceMappingV2List);
 385     } else if (CollectionUtils.isEmpty(blockDeviceMappingList)
 386         && CollectionUtils.isEmpty(blockDeviceMappingV2List)) {
 387
 388       mdcDataDebugMessage.debugExitMessage(null, null);
 389       return null;
 390
 391     } else {
 392       blockDeviceMappingList =
 393           blockDeviceMappingList != null ? blockDeviceMappingList : blockDeviceMappingV2List;
 394     }
 395
 396     mdcDataDebugMessage.debugExitMessage(null, null);
 397     return blockDeviceMappingList;
 398   }
 399
 400   private void manageNovaServerNetwork(TranslateTo translateTo,
 401                                        NodeTemplate novaNodeTemplate) {
 402
 403
 404     String heatFileName = translateTo.getHeatFileName();
 405     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 406     HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo
 407         .getHeatOrchestrationTemplate();
 408     Resource resource = translateTo.getResource();
 409     String translatedId = translateTo.getTranslatedId();
 410     TranslationContext context = translateTo.getContext();
 411
 412     mdcDataDebugMessage.debugEntryMessage(null, null);
 413
 414     if (resource.getProperties() == null) {
 415       return;
 416     }
 417     List<Map<String, Object>> heatNetworkList =
 418         (List<Map<String, Object>>) resource.getProperties().get("networks");
 419
 420     if (CollectionUtils.isEmpty(heatNetworkList)) {
 421       return;
 422     }
 423
 424     for (Map<String, Object> heatNetwork : heatNetworkList) {
 425       getOrTranslatePortTemplate(translateTo, heatNetwork.get(
 426           Constants.PORT_PROPERTY_NAME), translatedId, novaNodeTemplate);
 427     }
 428
 429     mdcDataDebugMessage.debugExitMessage(null, null);
 430
 431   }
 432
 433   private void getOrTranslatePortTemplate(TranslateTo translateTo,
 434                                           Object port,
 435                                           String novaServerResourceId,
 436                                           NodeTemplate novaNodeTemplate) {
 437
 438
 439     mdcDataDebugMessage.debugEntryMessage(null, null);
 440
 441     String heatFileName = translateTo.getHeatFileName();
 442     HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo
 443         .getHeatOrchestrationTemplate();
 444     ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
 445     TranslationContext context = translateTo.getContext();
 446
 447     Optional<AttachedResourceId> attachedPortId = HeatToToscaUtil
 448         .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context, port);
 449
 450     if (!attachedPortId.isPresent()) {
 451       return;
 452     }
 453
 454     if (attachedPortId.get().isGetResource()) {
 455       String resourceId = (String) attachedPortId.get().getEntityId();
 456       Resource portResource =
 457           HeatToToscaUtil.getResource(heatOrchestrationTemplate, resourceId, heatFileName);
 458       if (!Arrays.asList(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource(),
 459           HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE.getHeatResource())
 460           .contains(portResource.getType())) {
 461         logger.warn("NovaServer connect to port resource with id : " + resourceId + " and type : "
 462             + portResource.getType()
 463             + ". This resource type is not supported, therefore the connection to the port is "
 464             + "ignored. Supported types are: "
 465             + HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource() + ", "
 466             + HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE
 467             .getHeatResource());
 468         mdcDataDebugMessage.debugExitMessage(null, null);
 469         return;
 470       } else if (HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE
 471           .getHeatResource().equals(portResource.getType())) {
 472         Map<String, Object> properties = portResource.getProperties();
 473         if (!MapUtils.isEmpty(properties) && Objects.nonNull(properties.get("port_tuple_refs"))) {
 474           novaNodeTemplate.getProperties().put("contrail_service_instance_ind", true);
 475         }
 476       }
 477       Optional<String> translatedPortId = ResourceTranslationFactory.getInstance(portResource)
 478           .translateResource(heatFileName, serviceTemplate, heatOrchestrationTemplate, portResource,
 479               resourceId, context);
 480       if (translatedPortId.isPresent()) {
 481         NodeTemplate portNodeTemplate =
 482             DataModelUtil.getNodeTemplate(serviceTemplate, translatedPortId.get());
 483         HeatToToscaUtil.addBindingReqFromPortToCompute(novaServerResourceId, portNodeTemplate);
 484
 485         // Add ports
 486         ConsolidationDataUtil.updatePortInConsolidationData(translateTo, novaNodeTemplate.getType(),
 487             translatedPortId.get());
 488       } else {
 489         logger.warn("NovaServer connect to port resource with id : " + resourceId + " and type : "
 490             + portResource.getType()
 491             + ". This resource type is not supported, therefore the connection to the port is "
 492             + "ignored.");
 493       }
 494     }
 495
 496     mdcDataDebugMessage.debugExitMessage(null, null);
 497   }
 498
 499
 500   private String createLocalNodeType(ServiceTemplate serviceTemplate, Resource resource, String
 501       resourceId,
 502                                      String translatedId, TranslationContext context) {
 503     mdcDataDebugMessage.debugEntryMessage(null, null);
 504     NameExtractor nodeTypeNameExtractor = context.getNameExtractorImpl(resource.getType());
 505     String nodeTypeName =
 506         nodeTypeNameExtractor.extractNodeTypeName(resource, resourceId, translatedId);
 507
 508     if (!isNodeTypeCreated(serviceTemplate, nodeTypeName)) {
 509       DataModelUtil.addNodeType(serviceTemplate, nodeTypeName, createNodeType());
 510     }
 511
 512     mdcDataDebugMessage.debugExitMessage(null, null);
 513     return nodeTypeName;
 514   }
 515
 516   /**
 517    * Get property Regx matcher list.
 518    *
 519    * @return Regex exprission per nova resource property, while nova node type name is consider when
 520    * setting the name value.
 521    */
 522   public List<PropertyRegexMatcher> getPropertyRegexMatchersForNovaNodeType() {
 523     List<PropertyRegexMatcher> propertyRegexMatchers = new ArrayList<>();
 524     propertyRegexMatchers
 525         .add(new PropertyRegexMatcher(Constants.NAME_PROPERTY_NAME,
 526             Arrays.asList(".+_name$", ".+_names$", ".+_name_[0-9]+"), "_name"));
 527     propertyRegexMatchers
 528         .add(new PropertyRegexMatcher("image", Collections.singletonList(".+_image_name$"),
 529             "_image_name"));
 530     propertyRegexMatchers
 531         .add(new PropertyRegexMatcher("flavor", Collections.singletonList(".+_flavor_name$"),
 532             "_flavor_name"));
 533     return propertyRegexMatchers;
 534   }
 535
 536   private boolean isNodeTypeCreated(ServiceTemplate serviceTemplate, String nodeTypeName) {
 537     return !MapUtils.isEmpty(serviceTemplate.getNode_types())
 538         && Objects.nonNull(serviceTemplate.getNode_types().get(nodeTypeName));
 539   }
 540
 541   private NodeType createNodeType() {
 542     NodeType nodeType = new NodeType();
 543     nodeType.setDerived_from(ToscaNodeType.NOVA_SERVER);
 544     return nodeType;
 545   }
 546 }