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