diff options
Diffstat (limited to 'openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java')
-rw-r--r-- | openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java | 621 |
1 files changed, 621 insertions, 0 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java new file mode 100644 index 0000000000..a89d08bcf6 --- /dev/null +++ b/openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/services/heattotosca/ConsolidationDataUtil.java @@ -0,0 +1,621 @@ +package org.openecomp.sdc.translator.services.heattotosca; + +import org.apache.commons.collections4.MapUtils; +import org.apache.commons.lang3.math.NumberUtils; +import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration; +import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate; +import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes; +import org.openecomp.sdc.heat.datatypes.model.Resource; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; +import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; +import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; +import org.openecomp.sdc.tosca.services.DataModelUtil; +import org.openecomp.sdc.tosca.services.ToscaUtil; +import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext; +import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileNestedConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData; +import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Objects; + + +/** + * Utility class for consolidation data collection helper methods. + */ +public class ConsolidationDataUtil { + + protected static Logger logger = (Logger) LoggerFactory.getLogger(ConsolidationDataUtil.class); + + /** + * Gets compute template consolidation data. + * + * @param context the translation context + * @param serviceTemplate the service template + * @param computeNodeType the compute node type + * @param computeNodeTemplateId the compute node template id + * @return the compute template consolidation data + */ + public static ComputeTemplateConsolidationData getComputeTemplateConsolidationData( + TranslationContext context, + ServiceTemplate serviceTemplate, + String computeNodeType, + String computeNodeTemplateId) { + + ConsolidationData consolidationData = context.getConsolidationData(); + String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); + + ComputeConsolidationData computeConsolidationData = consolidationData + .getComputeConsolidationData(); + + FileComputeConsolidationData fileComputeConsolidationData = computeConsolidationData + .getFileComputeConsolidationData(serviceTemplateFileName); + + if (fileComputeConsolidationData == null) { + fileComputeConsolidationData = new FileComputeConsolidationData(); + computeConsolidationData.setFileComputeConsolidationData(serviceTemplateFileName, + fileComputeConsolidationData); + } + + TypeComputeConsolidationData typeComputeConsolidationData = fileComputeConsolidationData + .getTypeComputeConsolidationData(computeNodeType); + if (typeComputeConsolidationData == null) { + typeComputeConsolidationData = new TypeComputeConsolidationData(); + fileComputeConsolidationData.setTypeComputeConsolidationData(computeNodeType, + typeComputeConsolidationData); + } + + ComputeTemplateConsolidationData computeTemplateConsolidationData = + typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId); + if (computeTemplateConsolidationData == null) { + computeTemplateConsolidationData = new ComputeTemplateConsolidationData(); + computeTemplateConsolidationData.setNodeTemplateId(computeNodeTemplateId); + typeComputeConsolidationData.setComputeTemplateConsolidationData(computeNodeTemplateId, + computeTemplateConsolidationData); + } + + return computeTemplateConsolidationData; + } + + + /** + * Gets port template consolidation data. + * + * @param context the context + * @param serviceTemplate the service template + * @param portNodeTemplateId the port node template id + * @return the port template consolidation data + */ + public static PortTemplateConsolidationData getPortTemplateConsolidationData( + TranslationContext context, + ServiceTemplate serviceTemplate, + String portNodeTemplateId) { + + ConsolidationData consolidationData = context.getConsolidationData(); + String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); + + PortConsolidationData portConsolidationData = consolidationData.getPortConsolidationData(); + + FilePortConsolidationData filePortConsolidationData = portConsolidationData + .getFilePortConsolidationData(serviceTemplateFileName); + + if (filePortConsolidationData == null) { + filePortConsolidationData = new FilePortConsolidationData(); + portConsolidationData.setFilePortConsolidationData(serviceTemplateFileName, + filePortConsolidationData); + } + + PortTemplateConsolidationData portTemplateConsolidationData = + filePortConsolidationData.getPortTemplateConsolidationData(portNodeTemplateId); + if (portTemplateConsolidationData == null) { + portTemplateConsolidationData = new PortTemplateConsolidationData(); + portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId); + filePortConsolidationData.setPortTemplateConsolidationData(portNodeTemplateId, + portTemplateConsolidationData); + } + + return portTemplateConsolidationData; + } + + + /** + * Gets nested template consolidation data. + * + * @param context the context + * @param serviceTemplate the service template + * @param nestedNodeTemplateId the nested node template id + * @return the nested template consolidation data + */ + public static NestedTemplateConsolidationData getNestedTemplateConsolidationData( + TranslationContext context, + ServiceTemplate serviceTemplate, + String nestedNodeTemplateId) { + + ConsolidationData consolidationData = context.getConsolidationData(); + String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate); + + NestedConsolidationData nestedConsolidationData = consolidationData + .getNestedConsolidationData(); + + FileNestedConsolidationData fileNestedConsolidationData = nestedConsolidationData + .getFileNestedConsolidationData(serviceTemplateFileName); + + if (fileNestedConsolidationData == null) { + fileNestedConsolidationData = new FileNestedConsolidationData(); + nestedConsolidationData.setFileNestedConsolidationData(serviceTemplateFileName, + fileNestedConsolidationData); + } + + NestedTemplateConsolidationData nestedTemplateConsolidationData = + fileNestedConsolidationData.getNestedTemplateConsolidationData(nestedNodeTemplateId); + if (nestedTemplateConsolidationData == null) { + nestedTemplateConsolidationData = new NestedTemplateConsolidationData(); + nestedTemplateConsolidationData.setNodeTemplateId(nestedNodeTemplateId); + fileNestedConsolidationData.setNestedTemplateConsolidationData(nestedNodeTemplateId, + nestedTemplateConsolidationData); + } + + return nestedTemplateConsolidationData; + } + + /** + * Update group id information in consolidation data. + * + * @param entityConsolidationData Entity consolidation data (Port/Compute) + * @param translatedGroupId Group id of which compute node is a part + */ + public static void updateGroupIdInConsolidationData(EntityConsolidationData + entityConsolidationData, + String translatedGroupId) { + if (entityConsolidationData.getGroupIds() == null) { + entityConsolidationData.setGroupIds(new ArrayList<>()); + } + entityConsolidationData.getGroupIds().add(translatedGroupId); + } + + /** + * Update volume information in consolidation data. + * + * @param translateTo {@link TranslateTo} object + * @param computeType Local type of the compute node + * @param computeNodeTemplateId Node template id of the compute node + * @param requirementAssignment RequirementAssignment object + */ + public static void updateComputeConsolidationDataVolumes(TranslateTo translateTo, + String computeType, + String computeNodeTemplateId, + String requirementId, + RequirementAssignment + requirementAssignment) { + TranslationContext translationContext = translateTo.getContext(); + ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); + ComputeTemplateConsolidationData computeTemplateConsolidationData = + getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeType, + computeNodeTemplateId); + computeTemplateConsolidationData.addVolume(requirementId, requirementAssignment); + } + + + /** + * Update port in consolidation data. + * + * @param translateTo the translate to + * @param computeNodeType the compute node type + * @param portNodeTemplateId the port node template id + */ + public static void updatePortInConsolidationData(TranslateTo translateTo, + String computeNodeType, + String portNodeTemplateId) { + TranslationContext translationContext = translateTo.getContext(); + ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); + ComputeTemplateConsolidationData computeTemplateConsolidationData = + getComputeTemplateConsolidationData(translationContext, serviceTemplate, computeNodeType, + translateTo.getTranslatedId()); + computeTemplateConsolidationData.addPort(getPortType(portNodeTemplateId), portNodeTemplateId); + // create port in consolidation data + getPortTemplateConsolidationData(translationContext, serviceTemplate, portNodeTemplateId); + } + + /** + * Update nodes connected in and out for Depends on and connectivity in consolidation data. + * + * @param translateTo the translate to + * @param targetResourceId the target resource id + * @param nodeTemplateId the source node template id + * @param requirementAssignment the requirement assignment + */ + public static void updateNodesConnectedData(TranslateTo translateTo, String targetResourceId, + Resource targetResource, Resource sourceResource, + String nodeTemplateId, String requirementId, + RequirementAssignment requirementAssignment) { + ConsolidationEntityType consolidationEntityType = ConsolidationEntityType.OTHER; + HeatOrchestrationTemplate heatOrchestrationTemplate = translateTo + .getHeatOrchestrationTemplate(); + TranslationContext translationContext = translateTo.getContext(); + + consolidationEntityType.setEntityType(heatOrchestrationTemplate, sourceResource, + targetResource, translateTo.getContext()); + // Add resource dependency information in nodesConnectedIn if the target node + // is a consolidation entity + if (isConsolidationEntity(consolidationEntityType.getTargetEntityType()) + && HeatToToscaUtil + .isValidDependsOnCandidate(heatOrchestrationTemplate, sourceResource, + targetResource, consolidationEntityType, translationContext)) { + ConsolidationDataUtil.updateNodesConnectedIn(translateTo, + nodeTemplateId, consolidationEntityType.getTargetEntityType(), targetResourceId, + requirementId, requirementAssignment); + } + + //Add resource dependency information in nodesConnectedOut if the source node + //is a consolidation entity + if (isConsolidationEntity(consolidationEntityType.getSourceEntityType()) + && HeatToToscaUtil + .isValidDependsOnCandidate(heatOrchestrationTemplate, sourceResource, + targetResource, consolidationEntityType, translationContext)) { + ConsolidationDataUtil.updateNodesConnectedOut(translateTo, + requirementAssignment.getNode(), consolidationEntityType.getSourceEntityType(), + requirementId, requirementAssignment); + } + } + + + private static boolean isConsolidationEntity(ConsolidationEntityType consolidationEntityType) { + return (consolidationEntityType == ConsolidationEntityType.COMPUTE + || consolidationEntityType == ConsolidationEntityType.PORT + || consolidationEntityType == ConsolidationEntityType.NESTED + || consolidationEntityType == ConsolidationEntityType.VFC_NESTED); + } + + /** + * Update nodes connected from this node in consolidation data. + * + * @param translateTo the translate to + * @param nodeTemplateId the node template id of the target node + * @param consolidationEntityType the entity type (compute or port) + * @param requirementId the requirement id + * @param requirementAssignment the requirement assignment + */ + public static void updateNodesConnectedOut(TranslateTo translateTo, + String nodeTemplateId, + ConsolidationEntityType consolidationEntityType, + String requirementId, + RequirementAssignment requirementAssignment) { + EntityConsolidationData entityConsolidationData = null; + TranslationContext translationContext = translateTo.getContext(); + ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); + RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData( + requirementId, requirementAssignment); + + if (consolidationEntityType == ConsolidationEntityType.COMPUTE) { + String nodeType = DataModelUtil.getNodeTemplate(serviceTemplate, translateTo + .getTranslatedId()).getType(); + entityConsolidationData = getComputeTemplateConsolidationData(translationContext, + serviceTemplate, nodeType, translateTo.getTranslatedId()); + } else if (consolidationEntityType == ConsolidationEntityType.PORT) { + entityConsolidationData = getPortTemplateConsolidationData(translationContext, + serviceTemplate, translateTo.getTranslatedId()); + } else if (consolidationEntityType == ConsolidationEntityType.VFC_NESTED + || consolidationEntityType == ConsolidationEntityType.NESTED) { + //ConnectedOut data for nested is not updated + return; + } + + if (entityConsolidationData.getNodesConnectedOut() == null) { + entityConsolidationData.setNodesConnectedOut(new HashMap<>()); + } + + entityConsolidationData.getNodesConnectedOut() + .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>()) + .add(requirementAssignmentData); + } + + /** + * Update nodes connected from this node in consolidation data. + * + * @param translateTo the translate to + * @param sourceNodeTemplateId the node template id of the source node + * @param consolidationEntityType Entity type (compute or port) + * @param requirementId Requirement Id + * @param requirementAssignment the requirement assignment + */ + public static void updateNodesConnectedIn(TranslateTo translateTo, String sourceNodeTemplateId, + ConsolidationEntityType consolidationEntityType, + String targetResourceId, + String requirementId, + RequirementAssignment requirementAssignment) { + EntityConsolidationData entityConsolidationData = null; + TranslationContext translationContext = translateTo.getContext(); + ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); + RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData( + requirementId, requirementAssignment); + String dependentNodeTemplateId = requirementAssignment.getNode(); + if (consolidationEntityType == ConsolidationEntityType.COMPUTE) { + NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + dependentNodeTemplateId); + String nodeType = null; + if (Objects.isNull(computeNodeTemplate)) { + Resource targetResource = + translateTo.getHeatOrchestrationTemplate().getResources().get(targetResourceId); + NameExtractor nodeTypeNameExtractor = + translateTo.getContext().getNameExtractorImpl(targetResource.getType()); + nodeType = + nodeTypeNameExtractor.extractNodeTypeName(translateTo.getHeatOrchestrationTemplate() + .getResources().get(dependentNodeTemplateId), + dependentNodeTemplateId, dependentNodeTemplateId); + } else { + nodeType = computeNodeTemplate.getType(); + } + + entityConsolidationData = getComputeTemplateConsolidationData(translationContext, + serviceTemplate, nodeType, dependentNodeTemplateId); + } else if (consolidationEntityType == ConsolidationEntityType.PORT) { + entityConsolidationData = getPortTemplateConsolidationData(translationContext, + serviceTemplate, dependentNodeTemplateId); + } else if (consolidationEntityType == ConsolidationEntityType.NESTED + || consolidationEntityType == ConsolidationEntityType.VFC_NESTED) { + entityConsolidationData = getNestedTemplateConsolidationData(translationContext, + serviceTemplate, dependentNodeTemplateId); + } + + if (entityConsolidationData.getNodesConnectedIn() == null) { + entityConsolidationData.setNodesConnectedIn(new HashMap<>()); + } + + entityConsolidationData.getNodesConnectedIn() + .computeIfAbsent(sourceNodeTemplateId, k -> new ArrayList<>()) + .add(requirementAssignmentData); + + } + + /** + * Checks if the current HEAT resource if of type compute. + * + * @param heatOrchestrationTemplate the heat orchestration template + * @param resourceId the resource id + * @return true if the resource is of compute type and false otherwise + */ + public static boolean isComputeResource(HeatOrchestrationTemplate heatOrchestrationTemplate, + String resourceId) { + String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType(); + Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext + .getSupportedConsolidationComputeResources(); + if (supportedComputeResources.containsKey(resourceType)) { + if (supportedComputeResources.get(resourceType).isEnable()) { + return true; + } + return false; + } + return false; + } + + /** + * Checks if the current HEAT resource if of type compute. + * + * @param resource the resource + * @return true if the resource is of compute type and false otherwise + */ + public static boolean isComputeResource(Resource resource) { + String resourceType = resource.getType(); + Map<String, ImplementationConfiguration> supportedComputeResources = TranslationContext + .getSupportedConsolidationComputeResources(); + if (supportedComputeResources.containsKey(resourceType)) { + if (supportedComputeResources.get(resourceType).isEnable()) { + return true; + } + return false; + } + return false; + } + + /** + * Checks if the current HEAT resource if of type port. + * + * @param heatOrchestrationTemplate the heat orchestration template + * @param resourceId the resource id + * @return true if the resource is of port type and false otherwise + */ + public static boolean isPortResource(HeatOrchestrationTemplate heatOrchestrationTemplate, + String resourceId) { + String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType(); + Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext + .getSupportedConsolidationPortResources(); + if (supportedPortResources.containsKey(resourceType)) { + if (supportedPortResources.get(resourceType).isEnable()) { + return true; + } + return false; + } + return false; + } + + /** + * Checks if the current HEAT resource if of type port. + * + * @param resource the resource + * @return true if the resource is of port type and false otherwise + */ + public static boolean isPortResource(Resource resource) { + String resourceType = resource.getType(); + Map<String, ImplementationConfiguration> supportedPortResources = TranslationContext + .getSupportedConsolidationPortResources(); + if (supportedPortResources.containsKey(resourceType)) { + if (supportedPortResources.get(resourceType).isEnable()) { + return true; + } + return false; + } + return false; + } + + /** + * Checks if the current HEAT resource if of type volume. + * + * @param heatOrchestrationTemplate the heat orchestration template + * @param resourceId the resource id + * @return true if the resource is of volume type and false otherwise + */ + public static boolean isVolumeResource(HeatOrchestrationTemplate heatOrchestrationTemplate, + String resourceId) { + String resourceType = heatOrchestrationTemplate.getResources().get(resourceId).getType(); + return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) + || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE + .getHeatResource())); + } + + /** + * Checks if the current HEAT resource if of type volume. + * + * @param resource the resource + * @return true if the resource is of volume type and false otherwise + */ + public static boolean isVolumeResource(Resource resource) { + String resourceType = resource.getType(); + return (resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_RESOURCE_TYPE.getHeatResource()) + || resourceType.equals(HeatResourcesTypes.CINDER_VOLUME_ATTACHMENT_RESOURCE_TYPE + .getHeatResource())); + } + + /** + * Gets port type. + * + * @param portNodeTemplateId the port node template id + * @return the port type + */ + public static String getPortType(String portNodeTemplateId) { + String[] portSplitArr = portNodeTemplateId.split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)"); + String finalValue = ""; + if (NumberUtils.isNumber(portSplitArr[portSplitArr.length - 1])) { + for (String id : portSplitArr) { + finalValue = finalValue + id; + } + while (finalValue.length() > 0) { + if (Character.isLetter(finalValue.charAt(finalValue.length() - 1))) { + break; + } + finalValue = finalValue.substring(0, finalValue.length() - 1); + } + } else { + for (String id : portSplitArr) { + if (!NumberUtils.isNumber(id)) { + finalValue = finalValue + id; + } + } + } + return finalValue; + } + + /** + * Update node template id for the nested node templates in the consolidation data. + * + * @param translateTo the translate to + */ + public static void updateNestedNodeTemplateId(TranslateTo translateTo) { + TranslationContext context = translateTo.getContext(); + ServiceTemplate serviceTemplate = translateTo.getServiceTemplate(); + getNestedTemplateConsolidationData(context, serviceTemplate, translateTo.getTranslatedId()); + } + + public static void removeSharedResource(ServiceTemplate serviceTemplate, + HeatOrchestrationTemplate heatOrchestrationTemplate, + TranslationContext context, + String paramName, + String contrailSharedResourceId, + String sharedTranslatedResourceId) { + if (ConsolidationDataUtil.isComputeResource(heatOrchestrationTemplate, + contrailSharedResourceId)) { + NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + sharedTranslatedResourceId); + EntityConsolidationData entityConsolidationData = getComputeTemplateConsolidationData( + context, serviceTemplate, nodeTemplate.getType(), sharedTranslatedResourceId); + List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData + .getOutputParametersGetAttrIn(); + removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList); + } + if (ConsolidationDataUtil.isPortResource(heatOrchestrationTemplate, + contrailSharedResourceId)) { + NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, + sharedTranslatedResourceId); + EntityConsolidationData entityConsolidationData = getPortTemplateConsolidationData(context, + serviceTemplate, sharedTranslatedResourceId); + List<GetAttrFuncData> getAttrFuncDataList = entityConsolidationData + .getOutputParametersGetAttrIn(); + removeParamNameFromAttrFuncList(paramName, getAttrFuncDataList); + } + } + + private static void removeParamNameFromAttrFuncList(String paramName, + List<GetAttrFuncData> getAttrFuncDataList) { + Iterator<GetAttrFuncData> itr = getAttrFuncDataList.iterator(); + while (itr.hasNext()) { + GetAttrFuncData getAttrFuncData = itr.next(); + if (paramName.equals(getAttrFuncData.getFieldName())) { + itr.remove(); + } + } + } + + public static void updateNodeGetAttributeIn(EntityConsolidationData entityConsolidationData, + String nodeTemplateId, String propertyName, + String attributeName) { + GetAttrFuncData getAttrFuncData = new GetAttrFuncData(); + getAttrFuncData.setFieldName(propertyName); + getAttrFuncData.setAttributeName(attributeName); + entityConsolidationData.addNodesGetAttrIn(nodeTemplateId, getAttrFuncData); + + } + + public static void updateNodeGetAttributeOut(EntityConsolidationData entityConsolidationData, + String nodeTemplateId, String propertyName, + String attributeName) { + GetAttrFuncData getAttrFuncData = new GetAttrFuncData(); + getAttrFuncData.setFieldName(propertyName); + getAttrFuncData.setAttributeName(attributeName); + entityConsolidationData.addNodesGetAttrOut(nodeTemplateId, getAttrFuncData); + + } + + public static void updateOutputGetAttributeInConsolidationData(EntityConsolidationData + entityConsolidationData, + String outputParameterName, + String attributeName) { + + + GetAttrFuncData getAttrFuncData = new GetAttrFuncData(); + getAttrFuncData.setFieldName(outputParameterName); + getAttrFuncData.setAttributeName(attributeName); + entityConsolidationData.addOutputParamGetAttrIn(getAttrFuncData); + + } + + public static boolean isComputeReferenceToPortId(ComputeTemplateConsolidationData compute, + String portId) { + if (MapUtils.isEmpty(compute.getPorts())) { + return false; + } + for (List<String> portIdsPerType : compute.getPorts().values()) { + if (portIdsPerType.contains(portId)) { + return true; + } + } + return false; + } + +} |