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