private Set<String> serviceTemplatesWithoutNodeTemplateSection = new HashSet<>();
+ private Set<String> nodeTemplateIdsPointingToStWithoutNodeTemplates = new HashSet<>();
+
public static Map<String, ImplementationConfiguration>
getSupportedConsolidationComputeResources() {
return supportedConsolidationComputeResources;
}
- public Set<String> getServiceTemplatesWithoutNodeTemplateSection() {
- return serviceTemplatesWithoutNodeTemplateSection;
- }
-
- public void setServiceTemplatesWithoutNodeTemplateSection(
- Set<String> serviceTemplatesWithoutNodeTemplateSection) {
- this.serviceTemplatesWithoutNodeTemplateSection = serviceTemplatesWithoutNodeTemplateSection;
+ public boolean isServiceTemplateWithoutNodeTemplatesSection(String serviceTemplateName){
+ return Objects.nonNull(serviceTemplateName)
+ && serviceTemplatesWithoutNodeTemplateSection.contains(serviceTemplateName);
}
public void addServiceTemplateWithoutNodeTemplates(String serviceTemplateName){
this.serviceTemplatesWithoutNodeTemplateSection.add(serviceTemplateName);
}
- public boolean isServiceTemplateWithoutNodeTemplates(String serviceTemplateName){
- return !Objects.isNull(serviceTemplateName) &&
- this.serviceTemplatesWithoutNodeTemplateSection.contains(serviceTemplateName);
+ public void addNestedNodeTemplateIdPointsToStWithoutNodeTemplates(String nodeTemplateId){
+ this.nodeTemplateIdsPointingToStWithoutNodeTemplates.add(nodeTemplateId);
+ }
+
+ public boolean isNodeTemplateIdPointsToStWithoutNodeTemplates(String nodeTemplateId){
+ return Objects.nonNull(nodeTemplateId)
+ && nodeTemplateIdsPointingToStWithoutNodeTemplates.contains(nodeTemplateId);
}
public void updateRequirementAssignmentIdIndex(String serviceTemplateName,
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.math.NumberUtils;
+import org.openecomp.core.utilities.file.FileUtils;
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
import org.openecomp.sdc.translator.services.heattotosca.errors.DuplicateResourceIdsInDifferentFilesErrorBuilder;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
*
* @param context the context
* @param serviceTemplate the service template
- * @param nestedHeatFileName
- *@param nestedNodeTemplateId the nested node template id @return the nested template consolidation data
+ * @param nestedNodeTemplateId the nested node template id @return the nested template
+ * consolidation data
*/
public static NestedTemplateConsolidationData getNestedTemplateConsolidationData(
TranslationContext context,
ServiceTemplate serviceTemplate,
String nestedHeatFileName, String nestedNodeTemplateId) {
- if(isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
- nestedNodeTemplateId)){
- throw new CoreException(new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
+ if (isNestedResourceIdOccuresInDifferentNestedFiles(context, nestedHeatFileName,
+ nestedNodeTemplateId)) {
+ throw new CoreException(
+ new DuplicateResourceIdsInDifferentFilesErrorBuilder(nestedNodeTemplateId).build());
+ }
+
+ if (isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(
+ nestedNodeTemplateId, nestedHeatFileName, context)) {
+ return null;
}
ConsolidationData consolidationData = context.getConsolidationData();
return nestedTemplateConsolidationData;
}
+ public static boolean isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates(String
+ nestedNodeTemplateId,
+ String nestedHeatFileName,
+ TranslationContext context) {
+
+ return context.isServiceTemplateWithoutNodeTemplatesSection(
+ FileUtils.getFileWithoutExtention(nestedHeatFileName))
+ || context.isNodeTemplateIdPointsToStWithoutNodeTemplates(nestedNodeTemplateId);
+ }
+
private static boolean isNestedResourceIdOccuresInDifferentNestedFiles(TranslationContext context,
String nestedHeatFileName,
String nestedNodeTemplateId) {
return Objects.nonNull(nestedHeatFileName)
- && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName).contains(nestedNodeTemplateId);
+ && context.getAllTranslatedResourceIdsFromDiffNestedFiles(nestedHeatFileName)
+ .contains(nestedNodeTemplateId);
}
/**
|| consolidationEntityType == ConsolidationEntityType.NESTED) {
entityConsolidationData =
getNestedTemplateConsolidationData(translationContext, serviceTemplate,
- null,
+ translateTo.getHeatFileName(),
translateTo.getTranslatedId());
}
- if(Objects.isNull(entityConsolidationData)){
+ if (Objects.isNull(entityConsolidationData)) {
return;
}
- if (entityConsolidationData != null) {
- if (entityConsolidationData.getNodesConnectedOut() == null) {
- entityConsolidationData.setNodesConnectedOut(new HashMap<>());
- }
- entityConsolidationData.getNodesConnectedOut()
- .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
- .add(requirementAssignmentData);
+ if (Objects.isNull(entityConsolidationData.getNodesConnectedOut())) {
+ entityConsolidationData.setNodesConnectedOut(new HashMap<>());
}
+
+ entityConsolidationData.getNodesConnectedOut()
+ .computeIfAbsent(nodeTemplateId, k -> new ArrayList<>())
+ .add(requirementAssignmentData);
}
/**
/**
* Checks if the current HEAT resource if of type compute.
*
- * @param resource the resource
+ * @param resource the resource
* @return true if the resource is of compute type and false otherwise
*/
public static boolean isComputeResource(Resource resource) {
/**
* Checks if the current HEAT resource if of type port.
*
- * @param resource the resource
+ * @param resource the resource
* @return true if the resource is of port type and false otherwise
*/
public static boolean isPortResource(Resource resource) {
/**
* Checks if the current HEAT resource if of type volume.
*
- * @param resource the resource
+ * @param resource the resource
* @return true if the resource is of volume type and false otherwise
*/
public static boolean isVolumeResource(Resource resource) {
throw new CoreException(
new ResourceNotFoundInHeatFileErrorBuilder(resourceId, heatFileName).build());
}
+
+ mdcDataDebugMessage.debugExitMessage(null, null);
+ return getTranslatedResourceId(resourceId, heatFileName, resource, heatOrchestrationTemplate,
+ context
+ );
+ }
+
+ private static Optional<String> getTranslatedResourceId(String resourceId,
+ String heatFileName,
+ Resource resource,
+ HeatOrchestrationTemplate heatOrchestrationTemplate,
+ TranslationContext context) {
TranslateTo translateTo =
generateTranslationTo(heatFileName, null, heatOrchestrationTemplate, resource, resourceId,
null, context);
- translatedId =
+
+ String translatedId =
ResourceTranslationFactory.getInstance(resource).generateTranslatedId(translateTo);
+
+ if (ConsolidationDataUtil.isNodeTemplatePointsToServiceTemplateWithoutNodeTemplates
+ (translatedId, heatFileName, context)) {
+ return Optional.empty();
+ }
+
if (translatedId != null) {
context.getTranslatedIds().get(heatFileName).put(resourceId, translatedId);
}
- mdcDataDebugMessage.debugExitMessage(null, null);
return Optional.ofNullable(translatedId);
}
package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;
-import org.apache.commons.collections4.MapUtils;
import org.openecomp.core.utilities.file.FileUtils;
import org.openecomp.sdc.heat.datatypes.manifest.FileData;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
import org.openecomp.sdc.translator.services.heattotosca.TranslationService;
-import java.util.Objects;
-
public class ResourceTranslationNestedImpl extends ResourceTranslationBase {
protected static Logger logger =
.get(translateTo.getResource().getType());
if(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(substitutionServiceTemplate)){
- handleSubstitutionServiceTemplateWithoutNodeTemplates(translateTo, context, templateName);
+ handleSubstitutionServiceTemplateWithoutNodeTemplates(
+ templateName, translateTo);
mdcDataDebugMessage.debugExitMessage(null, null);
return;
}
mdcDataDebugMessage.debugExitMessage(null, null);
}
- private void handleSubstitutionServiceTemplateWithoutNodeTemplates(TranslateTo translateTo,
- TranslationContext context,
- String templateName) {
- context.addServiceTemplateWithoutNodeTemplates(templateName);
- context.getTranslatedServiceTemplates().remove(translateTo.getResource().getType());
+ private void handleSubstitutionServiceTemplateWithoutNodeTemplates(String templateName,
+ TranslateTo translateTo) {
+ translateTo.getContext().addServiceTemplateWithoutNodeTemplates(templateName);
+ translateTo.getContext()
+ .addNestedNodeTemplateIdPointsToStWithoutNodeTemplates(translateTo.getTranslatedId());
+ translateTo.getContext().getTranslatedServiceTemplates().remove(translateTo.getResource().getType());
}
private ServiceTemplate createSubstitutionServiceTemplate(TranslateTo translateTo,