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