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