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.ComputeConsolidationDataHandler;
  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, String groupId) {
 171         ComputeConsolidationDataHandler handler = translateTo.getContext().getComputeConsolidationDataHandler();
 172         handler.addGroupIdToConsolidationData(translateTo,novaNodeTemplate.getType(),
 173                 translateTo.getTranslatedId(), groupId);
 174     }
 175
 176     private boolean isHintOfTypeNovaServerGroup(HeatOrchestrationTemplate heatOrchestrationTemplate,
 177                                                        Object resourceToTranslate) {
 178         return heatOrchestrationTemplate.getResources().get(resourceToTranslate).getType()
 179                                         .equals(HeatResourcesTypes.NOVA_SERVER_GROUP_RESOURCE_TYPE.getHeatResource());
 180     }
 181
 182     private void addNovaServerToPolicyGroup(TranslateTo translateTo,
 183                                                    String resourceToTranslate,
 184                                                    NodeTemplate novaNodeTemplate) {
 185         Resource serverGroup =
 186                 HeatToToscaUtil.getResource(translateTo.getHeatOrchestrationTemplate(), resourceToTranslate,
 187                         translateTo.getHeatFileName());
 188         Optional<String> serverGroupTranslatedId = ResourceTranslationFactory.getInstance(serverGroup)
 189                 .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(),
 190                         translateTo.getHeatOrchestrationTemplate(), serverGroup, resourceToTranslate,
 191                         translateTo.getContext());
 192         if (serverGroupTranslatedId.isPresent()) {
 193             translateTo.getServiceTemplate().getTopology_template().getGroups().get(serverGroupTranslatedId.get())
 194                        .getMembers().add(translateTo.getTranslatedId());
 195             updateComputeConsolidationDataGroup(translateTo, novaNodeTemplate, serverGroupTranslatedId.get());
 196         }
 197     }
 198
 199     private boolean isSchedulerHintsPropExist(Map properties) {
 200         return !MapUtils.isEmpty(properties)
 201                        && Objects.nonNull(properties.get(ResourceReferenceFunctions.SCHEDULER_HINTS.getFunction()));
 202     }
 203
 204     private void manageNovaServerBlockDeviceMapping(TranslateTo translateTo,
 205                                                            NodeTemplate novaNodeTemplate) {
 206         Resource resource = translateTo.getResource();
 207         List<Map<String, Object>> blockDeviceMappingList = getBlockDeviceMappingList(resource);
 208         if (CollectionUtils.isEmpty(blockDeviceMappingList)) {
 209             return;
 210         }
 211         int index = 0;
 212         for (Map<String, Object> blockDeviceMapping : blockDeviceMappingList) {
 213             index = connectBlockDeviceToNovaServer(translateTo, novaNodeTemplate, index, blockDeviceMapping);
 214         }
 215     }
 216
 217     private int connectBlockDeviceToNovaServer(TranslateTo translateTo, NodeTemplate novaNodeTemplate, int index,
 218                                                       Map<String, Object> blockDeviceMapping) {
 219         Object volumeIdObject = blockDeviceMapping.get(VOL_ID_PROPERTY_NAME);
 220         Object snapshotIdObject = blockDeviceMapping.get(SNAPSHOT_ID_PROPERTY_NAME);
 221
 222         if (volumeIdObject == null && snapshotIdObject == null) {
 223             logger.warn("Resource '{}' has block_device_mapping property with empty/missing volume_id and snapshot_id "
 224                                 + "properties. Entry number {}, this entry will be ignored in TOSCA translation.",
 225                     translateTo.getResourceId(), (index + 1));
 226             index++;
 227             return index;
 228         }
 229         if (volumeIdObject == null) {
 230             connectBlockDeviceUsingSnapshotId(translateTo, novaNodeTemplate, snapshotIdObject, index,
 231                     blockDeviceMapping);
 232         } else {
 233             connectBlockDeviceUsingVolumeId(translateTo, novaNodeTemplate, volumeIdObject);
 234         }
 235         index++;
 236         return index;
 237     }
 238
 239     private void connectBlockDeviceUsingVolumeId(TranslateTo translateTo, NodeTemplate novaNodeTemplate,
 240                                                         Object volumeIdObject) {
 241         Optional<AttachedResourceId> attachedVolumeId = HeatToToscaUtil
 242                 .extractAttachedResourceId(translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(),
 243                         translateTo.getContext(), volumeIdObject);
 244         if (attachedVolumeId.isPresent() && attachedVolumeId.get().isGetResource()) {
 245             connectNovaServerToVolume(novaNodeTemplate, (String) attachedVolumeId.get().getTranslatedId(), null,
 246                     translateTo);
 247         }
 248     }
 249
 250     private void connectBlockDeviceUsingSnapshotId(TranslateTo translateTo, NodeTemplate novaNodeTemplate,
 251                                                           Object snapshotIdObject, int index,
 252                                                           Map<String, Object> blockDeviceMapping) {
 253         String novaServerTranslatedId = translateTo.getTranslatedId();
 254         String volumeResourceId;
 255         Optional<AttachedResourceId> attachedSnapshotId = HeatToToscaUtil
 256                 .extractAttachedResourceId(translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(),
 257                         translateTo.getContext(), snapshotIdObject);
 258         if (attachedSnapshotId.isPresent()) {
 259             volumeResourceId = novaServerTranslatedId + "_" + attachedSnapshotId.get().getEntityId();
 260             String deviceName = (String) blockDeviceMapping.get(BLOCK_DEVICE_MAPPING_DEVICE_NAME);
 261             String relationshipId = novaServerTranslatedId + "_" + index;
 262             createVolumeAttachesToRelationship(translateTo.getServiceTemplate(), deviceName, novaServerTranslatedId,
 263                     volumeResourceId, relationshipId);
 264             createCinderVolumeNodeTemplate(translateTo, volumeResourceId, blockDeviceMapping);
 265             connectNovaServerToVolume(novaNodeTemplate, volumeResourceId, relationshipId,
 266                     translateTo);
 267         }
 268     }
 269
 270     private void connectNovaServerToVolume(NodeTemplate novaNodeTemplate, String volumeResourceId,
 271                                                   String relationshipId, TranslateTo translateTo) {
 272         RequirementAssignment requirementAssignment = new RequirementAssignment();
 273         requirementAssignment.setCapability(ToscaCapabilityType.NATIVE_ATTACHMENT);
 274         requirementAssignment.setNode(volumeResourceId);
 275         if (relationshipId != null) {
 276             requirementAssignment.setRelationship(relationshipId);
 277         } else {
 278             requirementAssignment
 279                     .setRelationship(ToscaRelationshipType.NATIVE_ATTACHES_TO);
 280         }
 281         DataModelUtil.addRequirementAssignment(novaNodeTemplate, ToscaConstants.LOCAL_STORAGE_REQUIREMENT_ID,
 282                 requirementAssignment);
 283         //Add volume consolidation data
 284         ConsolidationDataUtil.updateComputeConsolidationDataVolumes(translateTo, novaNodeTemplate.getType(),
 285                 translateTo.getTranslatedId(), ToscaConstants.LOCAL_STORAGE_REQUIREMENT_ID, requirementAssignment);
 286     }
 287
 288     private void createCinderVolumeNodeTemplate(TranslateTo translateTo,
 289                                                        String volumeResourceId,
 290                                                        Map<String, Object> blockDeviceMapping) {
 291         NodeTemplate cinderVolumeNodeTemplate = new NodeTemplate();
 292         cinderVolumeNodeTemplate.setType(ToscaNodeType.CINDER_VOLUME);
 293         cinderVolumeNodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
 294                 .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(), translateTo.getResourceId(),
 295                         blockDeviceMapping, null,
 296                         translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(),
 297                         HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource(),
 298                         cinderVolumeNodeTemplate, translateTo.getContext()));
 299         DataModelUtil.addNodeTemplate(translateTo.getServiceTemplate(), volumeResourceId, cinderVolumeNodeTemplate);
 300     }
 301
 302     private void createVolumeAttachesToRelationship(ServiceTemplate serviceTemplate,
 303                                                            String deviceName, String novaServerTranslatedId,
 304                                                            String volumeId, String relationshipId) {
 305         RelationshipTemplate relationshipTemplate = new RelationshipTemplate();
 306         relationshipTemplate.setType(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO);
 307         Map<String, Object> properties = new HashMap<>();
 308         properties.put(ToscaConstants.INSTANCE_UUID_PROPERTY_NAME, novaServerTranslatedId);
 309         properties.put(ToscaConstants.VOL_ID_PROPERTY_NAME, volumeId);
 310         if (deviceName != null) {
 311             properties.put(VOL_ATTACH_DEVICE_PROPERTY_NAME, deviceName);
 312         }
 313         relationshipTemplate.setProperties(properties);
 314         DataModelUtil.addRelationshipTemplate(serviceTemplate, relationshipId, relationshipTemplate);
 315     }
 316
 317     private List<Map<String, Object>> getBlockDeviceMappingList(Resource resource) {
 318         if (Objects.isNull(resource.getProperties())) {
 319             return Collections.emptyList();
 320         }
 321         List<Map<String, Object>> blockDeviceMappingList =
 322                 (List<Map<String, Object>>) resource.getProperties().get(HeatConstants.BLOCK_DEVICE_MAPPING);
 323         List<Map<String, Object>> blockDeviceMappingV2List =
 324                 (List<Map<String, Object>>) resource.getProperties().get(HeatConstants.BLOCK_DEVICE_MAPPING_V2);
 325
 326         if (blockDeviceMappingList != null && blockDeviceMappingV2List != null) {
 327             blockDeviceMappingList.addAll(blockDeviceMappingV2List);
 328         } else if (CollectionUtils.isEmpty(blockDeviceMappingList)
 329                            && CollectionUtils.isEmpty(blockDeviceMappingV2List)) {
 330             return Collections.emptyList();
 331
 332         } else {
 333             blockDeviceMappingList =
 334                     blockDeviceMappingList != null ? blockDeviceMappingList : blockDeviceMappingV2List;
 335         }
 336         return blockDeviceMappingList;
 337     }
 338
 339     private void manageNovaServerNetwork(TranslateTo translateTo,
 340                                                 NodeTemplate novaNodeTemplate) {
 341         Resource resource = translateTo.getResource();
 342         String translatedId = translateTo.getTranslatedId();
 343
 344         if (resource.getProperties() == null) {
 345             return;
 346         }
 347         Object networks = resource.getProperties().get(PropertiesMapKeyTypes.NETWORKS.getKeyMap());
 348         if (Objects.isNull(networks) || !(networks instanceof List)) {
 349             return;
 350         }
 351
 352         List<Map<String, Object>> heatNetworkList = (List<Map<String, Object>>) networks;
 353
 354         for (Map<String, Object> heatNetwork : heatNetworkList) {
 355             getOrTranslatePortTemplate(translateTo, heatNetwork.get(
 356                     Constants.PORT_PROPERTY_NAME), translatedId, novaNodeTemplate);
 357         }
 358     }
 359
 360     private void getOrTranslatePortTemplate(TranslateTo translateTo,
 361                                                    Object port,
 362                                                    String novaServerResourceId,
 363                                                    NodeTemplate novaNodeTemplate) {
 364         String heatFileName = translateTo.getHeatFileName();
 365         HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo.getHeatOrchestrationTemplate();
 366         TranslationContext context = translateTo.getContext();
 367         Optional<AttachedResourceId> attachedPortId = HeatToToscaUtil
 368                 .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context, port);
 369         if (!attachedPortId.isPresent() || !attachedPortId.get().isGetResource()) {
 370             return;
 371         }
 372         String resourceId = (String) attachedPortId.get().getEntityId();
 373         Resource portResource = HeatToToscaUtil.getResource(heatOrchestrationTemplate, resourceId, heatFileName);
 374         if (!isSupportedPortResource(portResource)) {
 375             logger.warn("NovaServer connect to port resource with id : {} and type : {}. This resource type is "
 376                     + "not " + "supported, therefore the connection to the port is ignored. "
 377                     + "Supported types are: {}, {}", resourceId, portResource.getType(),
 378                     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"
 401                     + " is not supported, therefore the connection to the port is ignored.", resourceId,
 402                     portResource.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 }