2 * Copyright © 2016-2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package org.openecomp.sdc.translator.services.heattotosca;
19 import org.apache.commons.collections4.MapUtils;
20 import org.apache.commons.lang3.StringUtils;
21 import org.openecomp.core.utilities.file.FileUtils;
22 import org.openecomp.sdc.common.errors.CoreException;
23 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
24 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
25 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
26 import org.openecomp.sdc.heat.datatypes.model.Resource;
27 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
28 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
29 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
30 import org.openecomp.sdc.tosca.services.DataModelUtil;
31 import org.openecomp.sdc.tosca.services.ToscaUtil;
32 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
33 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
34 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData;
35 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
37 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
38 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
39 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData;
40 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
41 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
42 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData;
43 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
44 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData;
45 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
46 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
47 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.SubInterfaceTemplateConsolidationData;
48 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
49 import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
51 import java.util.ArrayList;
52 import java.util.HashMap;
53 import java.util.Iterator;
54 import java.util.List;
56 import java.util.Objects;
57 import java.util.Optional;
61 * Utility class for consolidation data collection helper methods.
63 public class ConsolidationDataUtil {
65 private static final String UNDERSCORE = "_";
66 private static final String DIGIT_REGEX = "\\d+";
68 private ConsolidationDataUtil() {
72 * Gets compute template consolidation data.
74 * @param context the translation context
75 * @param serviceTemplate the service template
76 * @param computeNodeType the compute node type
77 * @param computeNodeTemplateId the compute node template id
78 * @return the compute template consolidation data
80 public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData(
81 TranslationContext context,
82 ServiceTemplate serviceTemplate,
83 String computeNodeType,
84 String computeNodeTemplateId) {
86 ConsolidationData consolidationData = context.getConsolidationData();
87 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
89 ComputeConsolidationData computeConsolidationData = consolidationData
90 .getComputeConsolidationData();
92 FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData
93 .getFileComputeConsolidationData(serviceTemplateFileName);
95 if (fileComputeConsolidationData == null) {
96 fileComputeConsolidationData = new FileComputeConsolidationData();
97 computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName,
98 fileComputeConsolidationData);
101 TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData
102 .getTypeComputeConsolidationData(computeNodeType);
103 if (typeComputeConsolidationData == null) {
104 typeComputeConsolidationData = new TypeComputeConsolidationData();
105 fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType,
106 typeComputeConsolidationData);
109 ComputeTemplateConsolidationData computeTemplateConsolidationData =
110 typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId);
111 if (computeTemplateConsolidationData == null) {
112 computeTemplateConsolidationData = new ComputeTemplateConsolidationData();
113 computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId);
114 typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId,
115 computeTemplateConsolidationData);
118 return computeTemplateConsolidationData;
123 * Gets port template consolidation data.
125 * @param context the context
126 * @param serviceTemplate the service template
127 * @param portNodeTemplateId the port node template id
128 * @return the port template consolidation data
130 public static PortTemplateConsolidationData getPortTemplateConsolidationData(TranslationContext context,
131 ServiceTemplate serviceTemplate,
132 String portResourceId,
133 String portResourceType,
134 String portNodeTemplateId) {
136 ConsolidationData consolidationData = context.getConsolidationData();
137 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
139 PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
141 FilePortConsolidationData filePortConsolidationData = portConsolidationData
142 .getFilePortConsolidationData(serviceTemplateFileName);
144 if (filePortConsolidationData == null) {
145 filePortConsolidationData = new FilePortConsolidationData();
146 portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
147 filePortConsolidationData);
150 PortTemplateConsolidationData portTemplateConsolidationData =
151 filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId);
152 if (portTemplateConsolidationData == null) {
153 portTemplateConsolidationData = getInitPortTemplateConsolidationData(portNodeTemplateId,
154 portResourceId, portResourceType);
155 filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
158 return portTemplateConsolidationData;
161 private static PortTemplateConsolidationData getInitPortTemplateConsolidationData(String portNodeTemplateId,
162 String portResourceId,
163 String portResourceType) {
164 PortTemplateConsolidationData portTemplateConsolidationData = new PortTemplateConsolidationData();
165 portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
166 Optional<String> portNetworkRole = HeatToToscaUtil.evaluateNetworkRoleFromResourceId(portResourceId,
168 portNetworkRole.ifPresent(portTemplateConsolidationData::setNetworkRole);
169 return portTemplateConsolidationData;
172 public static Optional<SubInterfaceTemplateConsolidationData> getSubInterfaceTemplateConsolidationData(
173 TranslateTo subInterfaceTo,
174 String subInterfaceNodeTemplateId) {
175 Optional<String> parentPortNodeTemplateId =
176 HeatToToscaUtil.getSubInterfaceParentPortNodeTemplateId(subInterfaceTo);
177 if (parentPortNodeTemplateId.isPresent()) {
178 return Optional.ofNullable(getSubInterfaceTemplateConsolidationData(subInterfaceTo,
179 parentPortNodeTemplateId.get(), subInterfaceNodeTemplateId));
181 return Optional.empty();
184 private static SubInterfaceTemplateConsolidationData getSubInterfaceTemplateConsolidationData(
185 TranslateTo subInterfaceTo,
186 String parentPortNodeTemplateId,
187 String subInterfaceNodeTemplateId) {
189 ConsolidationData consolidationData = subInterfaceTo.getContext().getConsolidationData();
190 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(subInterfaceTo.getServiceTemplate());
192 PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData();
194 FilePortConsolidationData filePortConsolidationData = portConsolidationData
195 .getFilePortConsolidationData(serviceTemplateFileName);
197 if (filePortConsolidationData == null) {
198 filePortConsolidationData = new FilePortConsolidationData();
199 portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName,
200 filePortConsolidationData);
203 PortTemplateConsolidationData portTemplateConsolidationData =
204 filePortConsolidationData.getPortTemplateConsolidationData(parentPortNodeTemplateId);
205 if (portTemplateConsolidationData == null) {
206 portTemplateConsolidationData = new PortTemplateConsolidationData();
207 portTemplateConsolidationData.setNodeTemplateId(parentPortNodeTemplateId);
208 filePortConsolidationData.setPortTemplateConsolidationData(parentPortNodeTemplateId,
209 portTemplateConsolidationData);
212 return portTemplateConsolidationData.getSubInterfaceResourceTemplateConsolidationData(subInterfaceTo.getResource(),
213 subInterfaceNodeTemplateId, parentPortNodeTemplateId);
217 * Gets nested template consolidation data.
219 * @param context the context
220 * @param serviceTemplate the service template
221 * @param nestedNodeTemplateId the nested node template id @return the nested template
224 public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
225 TranslationContext context,
226 ServiceTemplate serviceTemplate,
227 String nestedHeatFileName, String nestedNodeTemplateId) {
229 if (isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
230 nestedNodeTemplateId)) {
231 throw new CoreException(
232 new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
235 if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
236 nestedNodeTemplateId, nestedHeatFileName, context)) {
240 ConsolidationData consolidationData = context.getConsolidationData();
241 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
243 NestedConsolidationData nestedConsolidationData = consolidationData
244 .getNestedConsolidationData();
246 FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData
247 .getFileNestedConsolidationData(serviceTemplateFileName);
249 if (fileNestedConsolidationData == null) {
250 fileNestedConsolidationData = new FileNestedConsolidationData();
251 nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName,
252 fileNestedConsolidationData);
255 NestedTemplateConsolidationData nestedTemplateConsolidationData =
256 fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId);
257 if (nestedTemplateConsolidationData == null) {
258 nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
259 nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId);
260 fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId,
261 nestedTemplateConsolidationData);
264 return nestedTemplateConsolidationData;
267 public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
268 nestedNodeTemplateId,
269 String nestedHeatFileName,
270 TranslationContext context) {
272 return context.isServiceTemplateWithoutNodeTemplatesSection(
273 FileUtils.getFileWithoutExtention(nestedHeatFileName))
274 || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
277 private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
278 String nestedHeatFileName,
279 String nestedNodeTemplateId) {
280 return Objects.nonNull(nestedHeatFileName)
281 && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
282 .contains(nestedNodeTemplateId);
286 * Update group id information in consolidation data.
288 * @param entityConsolidationData Entity consolidation data (Port/Compute)
289 * @param translatedGroupId Group id of which compute node is a part
291 public static void updateGroupIdInConsolidationData(EntityConsolidationData
292 entityConsolidationData,
293 String translatedGroupId) {
294 if (entityConsolidationData.getGroupIds() == null) {
295 entityConsolidationData.setGroupIds(new ArrayList<>());
297 entityConsolidationData.getGroupIds().add(translatedGroupId);
301 * Update volume information in consolidation data.
303 * @param translateTo {@link TranslateTo} object
304 * @param computeType Local type of the compute node
305 * @param computeNodeTemplateId Node template id of the compute node
306 * @param requirementAssignment RequirementAssignment object
308 public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo,
310 String computeNodeTemplateId,
311 String requirementId,
312 RequirementAssignment
313 requirementAssignment) {
314 TranslationContext translationContext = translateTo.getContext();
315 ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
316 ComputeTemplateConsolidationData computeTemplateConsolidationData =
317 getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType,
318 computeNodeTemplateId);
319 computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment);
324 * Update port in consolidation data.
326 * @param translateTo the translate to
327 * @param computeNodeType the compute node type
328 * @param portResourceId the port resource id
329 * @param portNodeTemplateId the port node template id
331 public static void updatePortInConsolidationData(TranslateTo translateTo,
332 String computeNodeType,
333 String portResourceId,
334 String portResourceType,
335 String portNodeTemplateId) {
336 TranslationContext translationContext = translateTo.getContext();
337 ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
338 ComputeTemplateConsolidationData computeTemplateConsolidationData =
339 getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType,
340 translateTo.getTranslatedId());
341 computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId);
342 // create port in consolidation data
343 getPortTemplateConsolidationData(translationContext, serviceTemplate, portResourceId,
344 portResourceType, portNodeTemplateId);
348 * Update nodes connected in and out for Depends on and connectivity in consolidation data.
350 * @param translateTo the translate to
351 * @param targetResourceId the target resource id
352 * @param nodeTemplateId the source node template id
353 * @param requirementAssignment the requirement assignment
355 public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId,
356 Resource targetResource, Resource sourceResource,
357 String nodeTemplateId, String requirementId,
358 RequirementAssignment requirementAssignment) {
359 ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER;
360 consolidationEntityType.setEntityType(sourceResource, targetResource, translateTo.getContext());
361 // Add resource dependency information in nodesConnectedIn if the target node
362 // is a consolidation entity
363 if (isConsolidationEntity(consolidationEntityType.getTargetEntityType())) {
364 ConsolidationDataUtil.updateNodesConnectedIn(translateTo,
365 nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId,
366 requirementId, requirementAssignment);
369 //Add resource dependency information in nodesConnectedOut if the source node
370 //is a consolidation entity
371 if (isConsolidationEntity(consolidationEntityType.getSourceEntityType())) {
372 ConsolidationDataUtil.updateNodesConnectedOut(translateTo,
373 requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(),
374 requirementId, requirementAssignment);
380 private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) {
381 return ConsolidationEntityType.getSupportedConsolidationEntities().contains(consolidationEntityType);
385 * Update nodes connected from this node in consolidation data.
387 * @param translateTo the translate to
388 * @param nodeTemplateId the node template id of the target node
389 * @param consolidationEntityType the entity type (compute or port)
390 * @param requirementId the requirement id
391 * @param requirementAssignment the requirement assignment
393 public static void updateNodesConnectedOut(TranslateTo translateTo,
394 String nodeTemplateId,
395 ConsolidationEntityType consolidationEntityType,
396 String requirementId,
397 RequirementAssignment requirementAssignment) {
398 EntityConsolidationData entityConsolidationData = null;
399 TranslationContext translationContext = translateTo.getContext();
400 ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
402 translationContext.updateRequirementAssignmentIdIndex(ToscaUtil.getServiceTemplateFileName
403 (translateTo.getServiceTemplate()), translateTo.getResourceId(), requirementId);
405 RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
406 requirementId, requirementAssignment);
408 if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
409 String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo
410 .getTranslatedId()).getType();
411 entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
412 serviceTemplate, nodeType, translateTo.getTranslatedId());
413 } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
414 entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
415 translateTo.getResourceId(), translateTo.getResource().getType(), translateTo
417 } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE
418 && Objects.nonNull(serviceTemplate.getTopology_template().getNode_templates()
419 .get(translateTo.getTranslatedId()))) {
420 Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
421 getSubInterfaceTemplateConsolidationData(translateTo, translateTo.getTranslatedId());
422 if (subInterfaceTemplateConsolidationData.isPresent()) {
423 entityConsolidationData = subInterfaceTemplateConsolidationData.get();
425 } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED
426 || consolidationEntityType == ConsolidationEntityType.NESTED) {
427 entityConsolidationData =
428 getNestedTemplateConsolidationData(translationContext, serviceTemplate,
429 translateTo.getHeatFileName(),
430 translateTo.getTranslatedId());
433 if (Objects.nonNull(entityConsolidationData)) {
434 if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) {
435 entityConsolidationData.setNodesConnectedOut(new HashMap<>());
438 entityConsolidationData.getNodesConnectedOut()
439 .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
440 .add(requirementAssignmentData);
445 * Update nodes connected from this node in consolidation data.
447 * @param translateTo the translate to
448 * @param sourceNodeTemplateId the node template id of the source node
449 * @param consolidationEntityType Entity type (compute or port)
450 * @param requirementId Requirement Id
451 * @param requirementAssignment the requirement assignment
453 public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId,
454 ConsolidationEntityType consolidationEntityType,
455 String targetResourceId,
456 String requirementId,
457 RequirementAssignment requirementAssignment) {
458 EntityConsolidationData entityConsolidationData = null;
459 TranslationContext translationContext = translateTo.getContext();
460 ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
461 RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData(
462 requirementId, requirementAssignment);
463 String dependentNodeTemplateId = requirementAssignment.getNode();
464 if (consolidationEntityType == ConsolidationEntityType.COMPUTE) {
465 NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
466 dependentNodeTemplateId);
468 if (Objects.isNull(computeNodeTemplate)) {
469 Resource targetResource =
470 translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
471 NameExtractor nodeTypeNameExtractor =
472 TranslationContext.getNameExtractorImpl(targetResource.getType());
474 nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate()
475 .getResources().get(dependentNodeTemplateId),
476 dependentNodeTemplateId, dependentNodeTemplateId);
478 nodeType = computeNodeTemplate.getType();
481 entityConsolidationData = getComputeTemplateConsolidationData(translationContext,
482 serviceTemplate, nodeType, dependentNodeTemplateId);
483 } else if (consolidationEntityType == ConsolidationEntityType.PORT) {
484 entityConsolidationData = getPortTemplateConsolidationData(translationContext, serviceTemplate,
485 translateTo.getResourceId(), translateTo.getResource().getType(), dependentNodeTemplateId);
486 } else if (consolidationEntityType == ConsolidationEntityType.SUB_INTERFACE) {
487 Resource targetResource =
488 translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId);
489 TranslateTo subInterfaceTo = new TranslateTo(translateTo.getHeatFileName(), serviceTemplate, translateTo
490 .getHeatOrchestrationTemplate(), targetResource, targetResourceId, null, translationContext);
491 Optional<SubInterfaceTemplateConsolidationData> subInterfaceTemplateConsolidationData =
492 getSubInterfaceTemplateConsolidationData(subInterfaceTo, targetResourceId);
493 if (subInterfaceTemplateConsolidationData.isPresent()) {
494 entityConsolidationData = subInterfaceTemplateConsolidationData.get();
496 } else if (consolidationEntityType == ConsolidationEntityType.NESTED
497 || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) {
498 entityConsolidationData = getNestedTemplateConsolidationData(translationContext,
499 serviceTemplate, translateTo.getHeatFileName(), dependentNodeTemplateId);
502 if (entityConsolidationData != null) {
503 if (entityConsolidationData.getNodesConnectedIn() == null) {
504 entityConsolidationData.setNodesConnectedIn(new HashMap<>());
507 entityConsolidationData.getNodesConnectedIn()
508 .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>())
509 .add(requirementAssignmentData);
515 * Checks if the current HEAT resource if of type compute.
517 * @param heatOrchestrationTemplate the heat orchestration template
518 * @param resourceId the resource id
519 * @return true if the resource is of compute type and false otherwise
521 public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
523 String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
524 Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
525 .getSupportedConsolidationComputeResources();
526 if (supportedComputeResources.containsKey(resourceType)) {
527 return supportedComputeResources.get(resourceType).isEnable();
533 * Checks if the current HEAT resource if of type compute.
535 * @param resource the resource
536 * @return true if the resource is of compute type and false otherwise
538 public static boolean isComputeResource(Resource resource) {
539 String resourceType = resource.getType();
540 Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext
541 .getSupportedConsolidationComputeResources();
542 if (supportedComputeResources.containsKey(resourceType)) {
543 return supportedComputeResources.get(resourceType).isEnable();
549 * Checks if the current HEAT resource if of type port.
551 * @param heatOrchestrationTemplate the heat orchestration template
552 * @param resourceId the resource id
553 * @return true if the resource is of port type and false otherwise
555 public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
557 String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
558 Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
559 .getSupportedConsolidationPortResources();
560 if (supportedPortResources.containsKey(resourceType)) {
561 return supportedPortResources.get(resourceType).isEnable();
567 * Checks if the current HEAT resource if of type port.
569 * @param resource the resource
570 * @return true if the resource is of port type and false otherwise
572 public static boolean isPortResource(Resource resource) {
573 String resourceType = resource.getType();
574 Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext
575 .getSupportedConsolidationPortResources();
576 if (supportedPortResources.containsKey(resourceType)) {
577 return supportedPortResources.get(resourceType).isEnable();
583 * Checks if the current HEAT resource if of type volume.
585 * @param heatOrchestrationTemplate the heat orchestration template
586 * @param resourceId the resource id
587 * @return true if the resource is of volume type and false otherwise
589 public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate,
591 String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType();
592 return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
593 || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
598 * Checks if the current HEAT resource if of type volume.
600 * @param resource the resource
601 * @return true if the resource is of volume type and false otherwise
603 public static boolean isVolumeResource(Resource resource) {
604 String resourceType = resource.getType();
605 return resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource())
606 || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE
613 * @param portNodeTemplateId the port node template id
614 * @return the port type
616 public static String getPortType(String portNodeTemplateId) {
618 if (StringUtils.isBlank(portNodeTemplateId)) {
619 return portNodeTemplateId;
622 String formattedName = portNodeTemplateId.replaceAll(UNDERSCORE + DIGIT_REGEX + "$", "");
624 StringBuilder sb = new StringBuilder();
626 for (String token : formattedName.split(UNDERSCORE)) {
628 if (StringUtils.isNotBlank(token)) {
632 if (count != 2 || !token.matches(DIGIT_REGEX)) {
633 sb.append(token).append(UNDERSCORE);
637 return portNodeTemplateId.endsWith(UNDERSCORE) ? sb.toString() : sb.substring(0, sb.length() - 1);
641 * Update node template id for the nested node templates in the consolidation data.
643 * @param translateTo the translate to
645 public static void updateNestedNodeTemplateId(TranslateTo translateTo) {
646 TranslationContext context = translateTo.getContext();
647 ServiceTemplate serviceTemplate = translateTo.getServiceTemplate();
648 getNestedTemplateConsolidationData(
649 context, serviceTemplate, translateTo.getHeatFileName(), translateTo.getTranslatedId());
652 public static void removeSharedResource(ServiceTemplate serviceTemplate,
653 HeatOrchestrationTemplate heatOrchestrationTemplate,
654 TranslationContext context,
656 String contrailSharedResourceId,
657 String sharedTranslatedResourceId) {
658 if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate,
659 contrailSharedResourceId)) {
660 NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
661 sharedTranslatedResourceId);
662 EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData(
663 context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId);
664 List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
665 .getOutputParametersGetAttrIn();
666 removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
668 if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate,
669 contrailSharedResourceId)) {
670 Resource resource = heatOrchestrationTemplate.getResources().get(contrailSharedResourceId);
671 EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, serviceTemplate,
672 contrailSharedResourceId, resource.getType(), sharedTranslatedResourceId);
673 List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData
674 .getOutputParametersGetAttrIn();
675 removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList);
679 private static void removeParamNameFromAttrFuncList(String paramName,
680 List<GetAttrFuncData> getAttrFuncDataList) {
681 Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator();
682 while (itr.hasNext()) {
683 GetAttrFuncData getAttrFuncData = itr.next();
684 if (paramName.equals(getAttrFuncData.getFieldName())) {
690 public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData,
691 String nodeTemplateId, String propertyName,
692 String attributeName) {
693 GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
694 getAttrFuncData.setFieldName(propertyName);
695 getAttrFuncData.setAttributeName(attributeName);
696 entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData);
700 public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData,
701 String nodeTemplateId, String propertyName,
702 String attributeName) {
703 GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
704 getAttrFuncData.setFieldName(propertyName);
705 getAttrFuncData.setAttributeName(attributeName);
706 entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData);
710 public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData
711 entityConsolidationData,
712 String outputParameterName,
713 String attributeName) {
716 GetAttrFuncData getAttrFuncData = new GetAttrFuncData();
717 getAttrFuncData.setFieldName(outputParameterName);
718 getAttrFuncData.setAttributeName(attributeName);
719 entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData);
723 public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute,
725 if (MapUtils.isEmpty(compute.getPorts())) {
728 for (List<String> portIdsPerType : compute.getPorts().values()) {
729 if (portIdsPerType.contains(portId)) {