Refactor Onboarding Translator code
[sdc.git] / 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 }