X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Fmain%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Ftosca%2FToscaExportHandler.java;h=163b67a44fe29c4e33f9a3980b126048a39950af;hb=d37d9e6adead6a6568aafb2ac831237de32fbdca;hp=4f815a316dc7061b02b2ea3253a61c10d4aacc98;hpb=4f4f7fb796475bb4a332e798c80438b33ce7712a;p=sdc.git diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java index 4f815a316d..163b67a44f 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java @@ -22,17 +22,27 @@ package org.openecomp.sdc.be.tosca; import static org.apache.commons.collections.CollectionUtils.isNotEmpty; import static org.apache.commons.collections.MapUtils.isNotEmpty; import static org.openecomp.sdc.be.components.utils.PropertiesUtils.resolvePropertyValueFromInput; -import static org.openecomp.sdc.be.tosca.InterfacesOperationsConverter.addInterfaceTypeElement; +import static org.openecomp.sdc.common.api.Constants.ADDITIONAL_TYPE_DEFINITIONS; import static org.openecomp.sdc.tosca.datatypes.ToscaFunctions.GET_ATTRIBUTE; import static org.openecomp.sdc.tosca.datatypes.ToscaFunctions.GET_INPUT; import static org.openecomp.sdc.tosca.datatypes.ToscaFunctions.GET_PROPERTY; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.primitives.Ints; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.stream.JsonReader; import fj.data.Either; + +import java.io.StringReader; +import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; @@ -44,30 +54,36 @@ import java.util.Optional; import java.util.Set; import java.util.function.Supplier; import java.util.stream.Collectors; -import lombok.NoArgsConstructor; + import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.MapUtils; +import org.apache.commons.io.FilenameUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.tuple.ImmutablePair; import org.apache.commons.lang3.tuple.ImmutableTriple; import org.apache.commons.lang3.tuple.Triple; import org.onap.sdc.tosca.services.YamlUtil; import org.openecomp.sdc.be.components.impl.exceptions.SdcResourceNotFoundException; +import org.openecomp.sdc.be.config.CategoryBaseTypeConfig; import org.openecomp.sdc.be.config.Configuration; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.data.model.ToscaImportByModel; import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition; import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition; import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition; import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition; import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ToscaFunction; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields; import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; @@ -99,6 +115,9 @@ import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; +import org.openecomp.sdc.be.model.operations.impl.ModelOperation; +import org.openecomp.sdc.be.model.tosca.ToscaType; +import org.openecomp.sdc.be.model.tosca.converters.ToscaMapValueConverter; import org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType; import org.openecomp.sdc.be.tosca.builder.ToscaRelationshipBuilder; import org.openecomp.sdc.be.tosca.exception.ToscaConversionException; @@ -114,6 +133,7 @@ import org.openecomp.sdc.be.tosca.model.ToscaNodeType; import org.openecomp.sdc.be.tosca.model.ToscaPolicyTemplate; import org.openecomp.sdc.be.tosca.model.ToscaProperty; import org.openecomp.sdc.be.tosca.model.ToscaPropertyAssignment; +import org.openecomp.sdc.be.tosca.model.ToscaPropertyConstraint; import org.openecomp.sdc.be.tosca.model.ToscaRelationshipTemplate; import org.openecomp.sdc.be.tosca.model.ToscaRequirement; import org.openecomp.sdc.be.tosca.model.ToscaTemplate; @@ -125,6 +145,7 @@ import org.openecomp.sdc.be.tosca.utils.InputConverter; import org.openecomp.sdc.be.tosca.utils.OutputConverter; import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode; import org.openecomp.sdc.common.log.wrappers.Logger; +import org.openecomp.sdc.tosca.datatypes.ToscaFunctions; import org.springframework.beans.factory.annotation.Autowired; import org.yaml.snakeyaml.DumperOptions; import org.yaml.snakeyaml.DumperOptions.FlowStyle; @@ -139,7 +160,6 @@ import org.yaml.snakeyaml.nodes.Tag; import org.yaml.snakeyaml.representer.Represent; import org.yaml.snakeyaml.representer.Representer; -@NoArgsConstructor @org.springframework.stereotype.Component("tosca-export-handler") public class ToscaExportHandler { @@ -154,23 +174,23 @@ public class ToscaExportHandler { private static final String NOT_SUPPORTED_COMPONENT_TYPE = "Not supported component type {}"; private static final String NATIVE_ROOT = "tosca.nodes.Root"; private static final List EXCLUDED_CATEGORY_SPECIFIC_METADATA = List - .of("Service Function", "Service Role", "Naming Policy", "Service Type"); + .of("Service Function", "Service Role", "Naming Policy", "Service Type"); private static final YamlUtil yamlUtil = new YamlUtil(); - private static final String COULD_NOT_PARSE_COMPONENT_ATTRIBUTES_COMPONENT_UNIQUE_ID = "Could not parse component '{}' attributes. Component unique id '{}'."; - private ApplicationDataTypeCache dataTypeCache; - private ToscaOperationFacade toscaOperationFacade; - private CapabilityRequirementConverter capabilityRequirementConverter; - private PolicyExportParser policyExportParser; - private GroupExportParser groupExportParser; - private PropertyConvertor propertyConvertor; - private AttributeConverter attributeConverter; - private InputConverter inputConverter; - private OutputConverter outputConverter; - private InterfaceLifecycleOperation interfaceLifecycleOperation; - private InterfacesOperationsConverter interfacesOperationsConverter; + private final ApplicationDataTypeCache applicationDataTypeCache; + private final ToscaOperationFacade toscaOperationFacade; + private final CapabilityRequirementConverter capabilityRequirementConverter; + private final PolicyExportParser policyExportParser; + private final GroupExportParser groupExportParser; + private final PropertyConvertor propertyConvertor; + private final AttributeConverter attributeConverter; + private final InputConverter inputConverter; + private final OutputConverter outputConverter; + private final InterfaceLifecycleOperation interfaceLifecycleOperation; + private final InterfacesOperationsConverter interfacesOperationsConverter; + private final ModelOperation modelOperation; @Autowired - public ToscaExportHandler(final ApplicationDataTypeCache dataTypeCache, + public ToscaExportHandler(final ApplicationDataTypeCache applicationDataTypeCache, final ToscaOperationFacade toscaOperationFacade, final CapabilityRequirementConverter capabilityRequirementConverter, final PolicyExportParser policyExportParser, @@ -180,8 +200,9 @@ public class ToscaExportHandler { final InputConverter inputConverter, final OutputConverter outputConverter, final InterfaceLifecycleOperation interfaceLifecycleOperation, - final InterfacesOperationsConverter interfacesOperationsConverter) { - this.dataTypeCache = dataTypeCache; + final InterfacesOperationsConverter interfacesOperationsConverter, + final ModelOperation modelOperation) { + this.applicationDataTypeCache = applicationDataTypeCache; this.toscaOperationFacade = toscaOperationFacade; this.capabilityRequirementConverter = capabilityRequirementConverter; this.policyExportParser = policyExportParser; @@ -192,6 +213,7 @@ public class ToscaExportHandler { this.outputConverter = outputConverter; this.interfaceLifecycleOperation = interfaceLifecycleOperation; this.interfacesOperationsConverter = interfacesOperationsConverter; + this.modelOperation = modelOperation; } public static String getInterfaceFilename(String artifactName) { @@ -203,15 +225,61 @@ public class ToscaExportHandler { return; } proxyComponentInterfaces.values().stream().map(InterfaceDataDefinition::getOperations).filter(MapUtils::isNotEmpty) - .forEach(operations -> operations.values().forEach(operation -> operation.setImplementation(null))); + .forEach(operations -> operations.values().forEach(operation -> operation.setImplementation(null))); } public Either exportComponent(Component component) { - return convertToToscaTemplate(component).left().map(this::createToscaRepresentation); + return convertToToscaTemplate(component, false).left().map(this::createToscaRepresentation); + } + + public Either exportComponent(Component component, Boolean isSkipImports) { + return convertToToscaTemplate(component, isSkipImports).left().map(this::createToscaRepresentation); + } + + public Either exportDataType(DataTypeDefinition dataTypeDefinition) { + return convertDataTypeToToscaTemplate(dataTypeDefinition).left().map(this::createToscaRepresentation); } public Either exportComponentInterface(final Component component, final boolean isAssociatedComponent) { - final List>> imports = new ArrayList<>(getDefaultToscaImportConfig()); + final List>> imports = new ArrayList<>(getDefaultToscaImports(component.getModel(), false)); + if (CollectionUtils.isEmpty(imports)) { + log.debug(FAILED_TO_GET_DEFAULT_IMPORTS_CONFIGURATION); + return Either.right(ToscaError.GENERAL_ERROR); + } + List> dependencies = new ArrayList<>(); + if (component.getDerivedFromGenericType() != null && !component.getDerivedFromGenericType() + .startsWith("org.openecomp.resource.abstract.nodes.")) { + final Either baseType = toscaOperationFacade + .getByToscaResourceNameAndVersion(component.getDerivedFromGenericType(), component.getDerivedFromGenericVersion(), + component.getModel()); + if (baseType.isLeft() && baseType.left().value() != null) { + addDependencies(imports, dependencies, baseType.left().value(), false); + } else { + log.debug("Failed to fetch derived from type {}", component.getDerivedFromGenericType()); + } + } + + String toscaVersion = null; + if (component instanceof Resource) { + toscaVersion = ((Resource) component).getToscaVersion(); + } + ToscaTemplate toscaTemplate = new ToscaTemplate(toscaVersion != null ? toscaVersion : TOSCA_VERSION); + toscaTemplate.setImports(imports); + final Map nodeTypes = new HashMap<>(); + final Either toscaTemplateRes = convertInterfaceNodeType(new HashMap<>(), component, toscaTemplate, nodeTypes, + isAssociatedComponent); + if (toscaTemplateRes.isRight()) { + return Either.right(toscaTemplateRes.right().value()); + } + toscaTemplate = toscaTemplateRes.left().value(); + toscaTemplate.setDependencies(dependencies); + ToscaRepresentation toscaRepresentation = this.createToscaRepresentation(toscaTemplate); + return Either.left(toscaRepresentation); + } + + public Either exportComponentInterface(final Component component, final boolean isAssociatedComponent, + final boolean isSkipImports) { + final List>> imports = new ArrayList<>(getDefaultToscaImports(component.getModel(), isSkipImports)); if (CollectionUtils.isEmpty(imports)) { log.debug(FAILED_TO_GET_DEFAULT_IMPORTS_CONFIGURATION); return Either.right(ToscaError.GENERAL_ERROR); @@ -220,9 +288,10 @@ public class ToscaExportHandler { if (component.getDerivedFromGenericType() != null && !component.getDerivedFromGenericType() .startsWith("org.openecomp.resource.abstract.nodes.")) { final Either baseType = toscaOperationFacade - .getByToscaResourceNameAndVersion(component.getDerivedFromGenericType(), component.getDerivedFromGenericVersion()); + .getByToscaResourceNameAndVersion(component.getDerivedFromGenericType(), component.getDerivedFromGenericVersion(), + component.getModel()); if (baseType.isLeft() && baseType.left().value() != null) { - addDependencies(imports, dependencies, baseType.left().value()); + addDependencies(imports, dependencies, baseType.left().value(), isSkipImports); } else { log.debug("Failed to fetch derived from type {}", component.getDerivedFromGenericType()); } @@ -246,7 +315,7 @@ public class ToscaExportHandler { return Either.left(toscaRepresentation); } - public ToscaRepresentation createToscaRepresentation(ToscaTemplate toscaTemplate) { + private ToscaRepresentation createToscaRepresentation(ToscaTemplate toscaTemplate) { CustomRepresenter representer = new CustomRepresenter(); DumperOptions options = new DumperOptions(); options.setAllowReadOnlyProperties(false); @@ -255,26 +324,35 @@ public class ToscaExportHandler { options.setCanonical(false); representer.addClassTag(toscaTemplate.getClass(), Tag.MAP); representer.setPropertyUtils(new UnsortedPropertyUtils()); + Yaml yaml = new Yaml(representer, options); String yamlAsString = yaml.dumpAsMap(toscaTemplate); - StringBuilder sb = new StringBuilder(); - sb.append(getConfiguration().getHeatEnvArtifactHeader()); - sb.append(yamlAsString); - sb.append(getConfiguration().getHeatEnvArtifactFooter()); - return ToscaRepresentation.make(sb.toString().getBytes(), toscaTemplate); + String sb = getConfiguration().getHeatEnvArtifactHeader() + + yamlAsString + + getConfiguration().getHeatEnvArtifactFooter(); + return ToscaRepresentation.make(sb.getBytes(), toscaTemplate); } public Either getDependencies(Component component) { ToscaTemplate toscaTemplate = new ToscaTemplate(null); - Either>, ToscaError> fillImports = fillImports(component, toscaTemplate); + Either>, ToscaError> fillImports = fillImports(component, toscaTemplate, false); if (fillImports.isRight()) { return Either.right(fillImports.right().value()); } return Either.left(fillImports.left().value().left); } - public Either convertToToscaTemplate(final Component component) { - final List>> defaultToscaImportConfig = getDefaultToscaImportConfig(); + public Either getDependencies(Component component, boolean isSkipImports) { + ToscaTemplate toscaTemplate = new ToscaTemplate(null); + Either>, ToscaError> fillImports = fillImports(component, toscaTemplate, isSkipImports); + if (fillImports.isRight()) { + return Either.right(fillImports.right().value()); + } + return Either.left(fillImports.left().value().left); + } + + public Either convertToToscaTemplate(final Component component, final boolean isSkipImports) { + final List>> defaultToscaImportConfig = getDefaultToscaImports(component.getModel(), isSkipImports); if (CollectionUtils.isEmpty(defaultToscaImportConfig)) { log.debug(FAILED_TO_GET_DEFAULT_IMPORTS_CONFIGURATION); return Either.right(ToscaError.GENERAL_ERROR); @@ -293,12 +371,69 @@ public class ToscaExportHandler { return convertNodeType(new HashMap<>(), component, toscaTemplate, nodeTypes); } else { log.trace("convert component as topology template"); - return convertToscaTemplate(component, toscaTemplate); + return convertToscaTemplate(component, toscaTemplate, isSkipImports); + } + } + + private Either convertDataTypeToToscaTemplate(final DataTypeDefinition dataTypeDefinition) { + final ToscaTemplate toscaTemplate = new ToscaTemplate(TOSCA_VERSION); + return convertDataTypeTosca(dataTypeDefinition, toscaTemplate); + } + + private Either convertDataTypeTosca(final DataTypeDefinition dataTypeDefinition, final ToscaTemplate toscaTemplate) { + final var dataTypesEither = applicationDataTypeCache.getAll(dataTypeDefinition.getModel()); + if (dataTypesEither.isRight()) { + log.debug("Failed to fetch all data types :", dataTypesEither.right().value()); + return Either.right(ToscaError.GENERAL_ERROR); + } + Map dataTypes = dataTypesEither.left().value(); + if (!dataTypeDefinition.isEmpty()) { + Map toscaDataTypeMap = new HashMap<>(); + ToscaDataType toscaDataType = new ToscaDataType(); + toscaDataType.setDerived_from(dataTypeDefinition.getDerivedFromName()); + toscaDataType.setDescription(dataTypeDefinition.getDescription()); + toscaDataType.setVersion(dataTypeDefinition.getVersion()); + if (CollectionUtils.isNotEmpty(dataTypeDefinition.getProperties())) { + toscaDataType.setProperties(dataTypeDefinition.getProperties().stream() + .collect(Collectors.toMap( + PropertyDataDefinition::getName, + s -> propertyConvertor.convertProperty(dataTypes, s, PropertyType.PROPERTY), + (toscaPropertyTobeValidated, toscaProperty) -> validateToscaProperty((List) dataTypeDefinition, + toscaPropertyTobeValidated, + toscaProperty) + ))); + } + toscaDataTypeMap.put(dataTypeDefinition.getName(), toscaDataType); + toscaTemplate.setData_types(toscaDataTypeMap); + } + return Either.left(toscaTemplate); + } + + private List>> getDefaultToscaImports(final String modelId, final boolean isSkipImports) { + if (StringUtils.isEmpty(modelId)) { + return getDefaultToscaImportConfig(); + } + + final List allModelImports = modelOperation.findAllModelImports(modelId, true); + final List>> importList = new ArrayList<>(); + final Set addedPathList = new HashSet<>(); + for (final ToscaImportByModel toscaImportByModel : allModelImports) { + var importPath = Path.of(toscaImportByModel.getFullPath()); + if (!(isSkipImports && importPath.toString().equals(ADDITIONAL_TYPE_DEFINITIONS))) { + if (addedPathList.contains(importPath)) { + importPath = + ToscaDefaultImportHelper.addModelAsFilePrefix(importPath, toscaImportByModel.getModelId()); + } + final String fileName = FilenameUtils.getBaseName(importPath.toString()); + importList.add(Map.of(fileName, Map.of("file", importPath.toString()))); + addedPathList.add(importPath); + } } + return importList; } - private Either convertToscaTemplate(Component component, ToscaTemplate toscaNode) { - Either>, ToscaError> importsRes = fillImports(component, toscaNode); + private Either convertToscaTemplate(Component component, ToscaTemplate toscaNode, boolean isSkipImports) { + Either>, ToscaError> importsRes = fillImports(component, toscaNode, isSkipImports); if (importsRes.isRight()) { return Either.right(importsRes.right().value()); } @@ -323,7 +458,7 @@ public class ToscaExportHandler { if (MapUtils.isNotEmpty(proxyInterfaceTypes)) { toscaNode.setInterface_types(proxyInterfaceTypes); } - Either, JanusGraphOperationStatus> dataTypesEither = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> dataTypesEither = applicationDataTypeCache.getAll(component.getModel()); if (dataTypesEither.isRight()) { log.debug("Failed to retrieve all data types {}", dataTypesEither.right().value()); return Either.right(ToscaError.GENERAL_ERROR); @@ -340,7 +475,7 @@ public class ToscaExportHandler { outputs = outputConverter.convert(component.getOutputs(), dataTypes); } catch (final ToscaConversionException e) { log.error(EcompLoggerErrorCode.SCHEMA_ERROR, ToscaExportHandler.class.getName(), - "Could not parse component '{}' outputs. Component unique id '{}'.", component.getName(), component.getUniqueId(), e); + "Could not parse component '{}' outputs. Component unique id '{}'.", component.getName(), component.getUniqueId(), e); return Either.right(ToscaError.GENERAL_ERROR); } if (!outputs.isEmpty()) { @@ -348,7 +483,7 @@ public class ToscaExportHandler { } if (CollectionUtils.isNotEmpty(component.getComponentInstances())) { final Either, ToscaError> nodeTemplates = - convertNodeTemplates(component, componentCache, dataTypes, topologyTemplate); + convertNodeTemplates(component, componentCache, dataTypes, topologyTemplate); if (nodeTemplates.isRight()) { return Either.right(nodeTemplates.right().value()); } @@ -356,12 +491,10 @@ public class ToscaExportHandler { topologyTemplate.setNode_templates(nodeTemplates.left().value()); } final Map relationshipTemplatesMap = new ToscaExportRelationshipTemplatesHandler() - .createFrom(topologyTemplate.getNode_templates()); + .createFrom(topologyTemplate.getNode_templates()); if (!relationshipTemplatesMap.isEmpty()) { topologyTemplate.setRelationshipTemplates(relationshipTemplatesMap); } - SubstitutionMapping substitutionMapping = new SubstitutionMapping(); - convertSubstitutionMappingFilter(component, substitutionMapping); addGroupsToTopologyTemplate(component, topologyTemplate); try { addPoliciesToTopologyTemplate(component, topologyTemplate); @@ -369,48 +502,100 @@ public class ToscaExportHandler { log.debug("Fail to add policies to topology template:", e); return Either.right(ToscaError.GENERAL_ERROR); } - String toscaResourceName; + try { + createSubstitutionMapping(component, componentCache).ifPresent(topologyTemplate::setSubstitution_mappings); + } catch (final ToscaExportException e) { + log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, ToscaExportHandler.class.getName(), e.getMessage()); + return Either.right(e.getToscaError()); + } + if (!topologyTemplate.isEmpty()) { + toscaNode.setTopology_template(topologyTemplate); + } + return Either.left(toscaNode); + } + + private Either createComponentToscaName(final Component component) { switch (component.getComponentType()) { case RESOURCE: - toscaResourceName = ((ResourceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition()) - .getToscaResourceName(); - break; + final ResourceMetadataDataDefinition resourceMetadata = + (ResourceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition(); + return Either.left(resourceMetadata.getToscaResourceName()); case SERVICE: - toscaResourceName = SERVICE_NODE_TYPE_PREFIX + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName(); - break; + return Either.left(SERVICE_NODE_TYPE_PREFIX + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName()); default: log.debug(NOT_SUPPORTED_COMPONENT_TYPE, component.getComponentType()); return Either.right(ToscaError.NOT_SUPPORTED_TOSCA_TYPE); } - substitutionMapping.setNode_type(toscaResourceName); - Either capabilities = convertCapabilities(component, substitutionMapping, componentCache); - if (capabilities.isRight()) { - return Either.right(capabilities.right().value()); + } + + private Optional createSubstitutionMapping(final Component component, + final Map componentCache) throws ToscaExportException { + if (component instanceof Service && !((Service) component).isSubstituteCandidate()) { + return Optional.empty(); + } + + final Either toscaResourceNameEither = createComponentToscaName(component); + if (toscaResourceNameEither.isRight()) { + throw new ToscaExportException("Could not create component TOSCA name", toscaResourceNameEither.right().value()); } - substitutionMapping = capabilities.left().value(); - Either requirements = capabilityRequirementConverter - .convertSubstitutionMappingRequirements(componentCache, component, substitutionMapping); + final String toscaResourceName = toscaResourceNameEither.left().value(); + + final SubstitutionMapping substitutionMapping = new SubstitutionMapping(); + if (doNotExtendBaseType(component)) { + substitutionMapping.setNode_type(component.getDerivedFromGenericType()); + } else { + substitutionMapping.setNode_type(toscaResourceName); + } + convertSubstitutionMappingFilter(component).ifPresent(substitutionMapping::setSubstitution_filter); + + final Either, ToscaError> capabilitiesEither = convertSubstitutionMappingCapabilities(component, componentCache); + if (capabilitiesEither.isRight()) { + throw new ToscaExportException("Could not convert substitution mapping capabilities", capabilitiesEither.right().value()); + } + final Map capabilityMap = capabilitiesEither.left().value(); + if (!capabilityMap.isEmpty()) { + substitutionMapping.setCapabilities(capabilityMap); + } + final Either, ToscaError> requirements = + capabilityRequirementConverter.convertSubstitutionMappingRequirements(component, componentCache); if (requirements.isRight()) { - return Either.right(requirements.right().value()); + throw new ToscaExportException("Could not convert substitution mapping requirements", requirements.right().value()); + } + final Map requirementMap = requirements.left().value(); + if (MapUtils.isNotEmpty(requirementMap)) { + substitutionMapping.setRequirements(requirementMap); } - substitutionMapping = requirements.left().value(); + final Map propertyMappingMap = buildSubstitutionMappingPropertyMapping(component); - if (!propertyMappingMap.isEmpty()) { + if (MapUtils.isNotEmpty(propertyMappingMap)) { substitutionMapping.setProperties(propertyMappingMap); } + final Map attributesMappingMap = buildSubstitutionMappingAttributesMapping(component); - if (!attributesMappingMap.isEmpty()) { + if (MapUtils.isNotEmpty(attributesMappingMap)) { substitutionMapping.setAttributes(attributesMappingMap); } - topologyTemplate.setSubstitution_mappings(substitutionMapping); - toscaNode.setTopology_template(topologyTemplate); - return Either.left(toscaNode); + + return Optional.of(substitutionMapping); + } + + private boolean doNotExtendBaseType(final Component component) { + final Map serviceNodeTypesConfig = ConfigurationManager.getConfigurationManager().getConfiguration() + .getServiceBaseNodeTypes(); + List categories = component.getCategories(); + if (CollectionUtils.isNotEmpty(categories) && MapUtils.isNotEmpty(serviceNodeTypesConfig) + && serviceNodeTypesConfig.get(categories.get(0).getName()) != null) { + return serviceNodeTypesConfig.get(categories.get(0).getName()).isDoNotExtendBaseType(); + } + return false; } - private void convertSubstitutionMappingFilter(final Component component, final SubstitutionMapping substitutionMapping) { - if (component.getSubstitutionFilter() != null && (component.getSubstitutionFilter().getProperties()).getListToscaDataDefinition() != null) { - substitutionMapping.setSubstitution_filter(convertToSubstitutionFilterComponent(component.getSubstitutionFilter())); + private Optional convertSubstitutionMappingFilter(final Component component) { + if (component.getSubstitutionFilter() == null || (component.getSubstitutionFilter().getProperties()).getListToscaDataDefinition() == null) { + return Optional.empty(); } + + return Optional.ofNullable(convertToSubstitutionFilterComponent(component.getSubstitutionFilter())); } private void addGroupsToTopologyTemplate(Component component, ToscaTopolgyTemplate topologyTemplate) { @@ -427,19 +612,20 @@ public class ToscaExportHandler { } } - private Map convertMetadata(Component component) { + private Map convertMetadata(Component component) { return convertMetadata(component, false, null); } - private Map convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) { - Map toscaMetadata = new LinkedHashMap<>(); + private Map convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) { + Map toscaMetadata = new LinkedHashMap<>(); toscaMetadata.put(convertMetadataKey(JsonPresentationFields.INVARIANT_UUID), component.getInvariantUUID()); toscaMetadata.put(JsonPresentationFields.UUID.getPresentation(), component.getUUID()); toscaMetadata - .put(JsonPresentationFields.NAME.getPresentation(), component.getComponentMetadataDefinition().getMetadataDataDefinition().getName()); + .put(JsonPresentationFields.NAME.getPresentation(), component.getComponentMetadataDefinition().getMetadataDataDefinition().getName()); toscaMetadata.put(JsonPresentationFields.DESCRIPTION.getPresentation(), component.getDescription()); List categories = component.getCategories(); CategoryDefinition categoryDefinition = categories.get(0); + toscaMetadata.put(JsonPresentationFields.MODEL.getPresentation(), component.getModel()); toscaMetadata.put(JsonPresentationFields.CATEGORY.getPresentation(), categoryDefinition.getName()); if (isInstance) { toscaMetadata.put(JsonPresentationFields.VERSION.getPresentation(), component.getVersion()); @@ -451,10 +637,10 @@ public class ToscaExportHandler { toscaMetadata.put(JsonPresentationFields.CI_SOURCE_MODEL_NAME.getPresentation(), componentInstance.getSourceModelName()); if (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy) { toscaMetadata.put(JsonPresentationFields.NAME.getPresentation(), - componentInstance.getSourceModelName() + " " + OriginTypeEnum.ServiceProxy.getDisplayValue()); + componentInstance.getSourceModelName() + " " + OriginTypeEnum.ServiceProxy.getDisplayValue()); } else if (componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) { toscaMetadata.put(JsonPresentationFields.NAME.getPresentation(), - componentInstance.getSourceModelName() + " " + OriginTypeEnum.ServiceSubstitution.getDisplayValue()); + componentInstance.getSourceModelName() + " " + OriginTypeEnum.ServiceSubstitution.getDisplayValue()); } toscaMetadata.put(JsonPresentationFields.DESCRIPTION.getPresentation(), componentInstance.getDescription()); } @@ -463,15 +649,19 @@ public class ToscaExportHandler { case RESOURCE: Resource resource = (Resource) component; if (isInstance && (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy - || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution)) { + || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution)) { toscaMetadata.put(JsonPresentationFields.TYPE.getPresentation(), componentInstance.getOriginType().getDisplayValue()); } else { toscaMetadata.put(JsonPresentationFields.TYPE.getPresentation(), resource.getResourceType().name()); } toscaMetadata.put(JsonPresentationFields.SUB_CATEGORY.getPresentation(), categoryDefinition.getSubcategories().get(0).getName()); toscaMetadata.put(JsonPresentationFields.RESOURCE_VENDOR.getPresentation(), resource.getVendorName()); + if (resource.getTenant() != null) { + toscaMetadata.put(JsonPresentationFields.TENANT.getPresentation(), resource.getTenant()); + } toscaMetadata.put(JsonPresentationFields.RESOURCE_VENDOR_RELEASE.getPresentation(), resource.getVendorRelease()); toscaMetadata.put(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER.getPresentation(), resource.getResourceVendorModelNumber()); + toscaMetadata.put(resource.isTopologyTemplate() ? JsonPresentationFields.TEMPLATE_VERSION.getPresentation() : JsonPresentationFields.VERSION.getPresentation(), resource.getVersion()); break; case SERVICE: Service service = (Service) component; @@ -480,11 +670,10 @@ public class ToscaExportHandler { toscaMetadata.put(JsonPresentationFields.SERVICE_ROLE.getPresentation(), service.getServiceRole()); toscaMetadata.put(JsonPresentationFields.SERVICE_FUNCTION.getPresentation(), service.getServiceFunction()); toscaMetadata.put(JsonPresentationFields.ENVIRONMENT_CONTEXT.getPresentation(), service.getEnvironmentContext()); + toscaMetadata.put(JsonPresentationFields.TEMPLATE_VERSION.getPresentation(), service.getVersion()); toscaMetadata.put(JsonPresentationFields.INSTANTIATION_TYPE.getPresentation(), - service.getEnvironmentContext() == null ? StringUtils.EMPTY : service.getInstantiationType()); + service.getEnvironmentContext() == null ? StringUtils.EMPTY : service.getInstantiationType()); if (!isInstance) { - // DE268546 - toscaMetadata.put(JsonPresentationFields.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming().toString()); toscaMetadata.put(JsonPresentationFields.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming().toString()); toscaMetadata.put(JsonPresentationFields.NAMING_POLICY.getPresentation(), service.getNamingPolicy()); } @@ -507,8 +696,8 @@ public class ToscaExportHandler { return jsonPresentationField.getPresentation(); } - private Either>, ToscaError> fillImports(Component component, ToscaTemplate toscaTemplate) { - final List>> defaultToscaImportConfig = getDefaultToscaImportConfig(); + private Either>, ToscaError> fillImports(Component component, ToscaTemplate toscaTemplate, boolean isSkipImports) { + final List>> defaultToscaImportConfig = getDefaultToscaImports(component.getModel(), isSkipImports); if (CollectionUtils.isEmpty(defaultToscaImportConfig)) { log.debug(FAILED_TO_GET_DEFAULT_IMPORTS_CONFIGURATION); return Either.right(ToscaError.GENERAL_ERROR); @@ -516,25 +705,16 @@ public class ToscaExportHandler { Map componentCache = new HashMap<>(); if (!ModelConverter.isAtomicComponent(component)) { final List>> additionalImports = - toscaTemplate.getImports() == null ? new ArrayList<>(defaultToscaImportConfig) : new ArrayList<>(toscaTemplate.getImports()); + toscaTemplate.getImports() == null ? new ArrayList<>(defaultToscaImportConfig) : new ArrayList<>(toscaTemplate.getImports()); List> dependencies = new ArrayList<>(); Map toscaArtifacts = component.getToscaArtifacts(); - if (isNotEmpty(toscaArtifacts)) { - ArtifactDefinition artifactDefinition = toscaArtifacts.get(ASSET_TOSCA_TEMPLATE); - if (artifactDefinition != null) { - Map> importsListMember = new HashMap<>(); - Map interfaceFiles = new HashMap<>(); - interfaceFiles.put(IMPORTS_FILE_KEY, getInterfaceFilename(artifactDefinition.getArtifactName())); - StringBuilder keyNameBuilder = new StringBuilder(); - keyNameBuilder.append(component.getComponentType().toString().toLowerCase()).append("-").append(component.getName()) - .append("-interface"); - importsListMember.put(keyNameBuilder.toString(), interfaceFiles); - additionalImports.add(importsListMember); - } + final Map> substituteTypeImportEntry = generateComponentSubstituteTypeImport(component, toscaArtifacts); + if (!substituteTypeImportEntry.isEmpty()) { + additionalImports.add(substituteTypeImportEntry); } List componentInstances = component.getComponentInstances(); if (componentInstances != null && !componentInstances.isEmpty()) { - componentInstances.forEach(ci -> createDependency(componentCache, additionalImports, dependencies, ci)); + componentInstances.forEach(ci -> createDependency(componentCache, additionalImports, dependencies, ci, isSkipImports)); } toscaTemplate.setDependencies(dependencies); toscaTemplate.setImports(additionalImports); @@ -544,12 +724,34 @@ public class ToscaExportHandler { return Either.left(new ImmutablePair<>(toscaTemplate, componentCache)); } + private Map> generateComponentSubstituteTypeImport(final Component component, + final Map toscaArtifacts) { + if (doNotExtendBaseType(component)) { + return Collections.emptyMap(); + } + if (component instanceof Service && !((Service) component).isSubstituteCandidate()) { + return Collections.emptyMap(); + } + if (MapUtils.isEmpty(toscaArtifacts)) { + return Collections.emptyMap(); + } + final ArtifactDefinition artifactDefinition = toscaArtifacts.get(ASSET_TOSCA_TEMPLATE); + if (artifactDefinition == null) { + return Collections.emptyMap(); + } + final var importEntryName = component.getComponentType().toString().toLowerCase() + "-" + component.getName() + "-interface"; + return Map.of(importEntryName, + Map.of(IMPORTS_FILE_KEY, getInterfaceFilename(artifactDefinition.getArtifactName())) + ); + } + private List>> getDefaultToscaImportConfig() { return getConfiguration().getDefaultImports(); } private void createDependency(final Map componentCache, final List>> imports, - final List> dependencies, final ComponentInstance componentInstance) { + final List> dependencies, final ComponentInstance componentInstance, + final boolean isSkipImports) { log.debug("createDependency componentCache {}", componentCache); Component componentRI = componentCache.get(componentInstance.getComponentUid()); if (componentRI == null || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) { @@ -557,12 +759,12 @@ public class ToscaExportHandler { final Either resource = toscaOperationFacade.getToscaFullElement(componentInstance.getComponentUid()); if ((resource.isRight()) && (log.isDebugEnabled())) { log.debug("Failed to fetch resource with id {} for instance {}", componentInstance.getComponentUid(), - componentInstance.getUniqueId()); + componentInstance.getUniqueId()); return; } final Component fetchedComponent = resource.left().value(); componentRI = setComponentCache(componentCache, componentInstance, fetchedComponent); - addDependencies(imports, dependencies, componentRI); + addDependencies(imports, dependencies, componentRI, isSkipImports); } } @@ -573,12 +775,12 @@ public class ToscaExportHandler { final Component fetchedComponent) { componentCache.put(fetchedComponent.getUniqueId(), fetchedComponent); if (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy - || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) { + || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) { final Either sourceService = toscaOperationFacade - .getToscaFullElement(componentInstance.getSourceModelUid()); + .getToscaFullElement(componentInstance.getSourceModelUid()); if (sourceService.isRight() && (log.isDebugEnabled())) { log.debug("Failed to fetch source service with id {} for proxy {}", componentInstance.getSourceModelUid(), - componentInstance.getUniqueId()); + componentInstance.getUniqueId()); } final Component fetchedSource = sourceService.left().value(); componentCache.put(fetchedSource.getUniqueId(), fetchedSource); @@ -591,7 +793,7 @@ public class ToscaExportHandler { * Retrieves all derived_from nodes and stores it in a predictable order. */ private void addDependencies(final List>> imports, final List> dependencies, - final Component fetchedComponent) { + final Component fetchedComponent, final boolean isSkipImports) { final Set componentsList = new LinkedHashSet<>(); if (fetchedComponent instanceof Resource) { log.debug("fetchedComponent is a resource {}", fetchedComponent); @@ -606,9 +808,9 @@ public class ToscaExportHandler { } } }); - setImports(imports, dependencies, componentsList); + setImports(imports, dependencies, componentsList, isSkipImports); } else { - setImports(imports, dependencies, fetchedComponent); + setImports(imports, dependencies, fetchedComponent, isSkipImports); } } } @@ -623,7 +825,7 @@ public class ToscaExportHandler { componentsList.add(fetchedComponent); for (final ComponentInstance componentInstance : parentResource.getComponentInstances()) { final Either resourcefetched = toscaOperationFacade - .getToscaElement(componentInstance.getComponentUid()); + .getToscaElement(componentInstance.getComponentUid()); if (resourcefetched != null && resourcefetched.isLeft()) { final Map derivedWithId = resourcefetched.left().value().getDerivedFromMapOfIdToName(); if (MapUtils.isNotEmpty(derivedWithId)) { @@ -642,12 +844,12 @@ public class ToscaExportHandler { * Creates a resource map and adds it to the import list. */ private void setImports(final List>> imports, final List> dependencies, - final Set componentsList) { - componentsList.forEach(component -> setImports(imports, dependencies, component)); + final Set componentsList, boolean isSkipImports) { + componentsList.forEach(component -> setImports(imports, dependencies, component, isSkipImports)); } private void setImports(final List>> imports, final List> dependencies, - final Component component) { + final Component component, boolean isSkipImports) { final Map toscaArtifacts = component.getToscaArtifacts(); final ArtifactDefinition artifactDefinition = toscaArtifacts.get(ASSET_TOSCA_TEMPLATE); if (artifactDefinition != null) { @@ -658,9 +860,11 @@ public class ToscaExportHandler { keyNameBuilder.append(component.getComponentType().toString().toLowerCase()); keyNameBuilder.append("-"); keyNameBuilder.append(component.getName()); - addImports(imports, keyNameBuilder, files); + if (!isSkipImports) { + addImports(imports, keyNameBuilder, files); + } dependencies.add(new ImmutableTriple<>(artifactName, artifactDefinition.getEsId(), component)); - if (!ModelConverter.isAtomicComponent(component)) { + if (!ModelConverter.isAtomicComponent(component) && !isSkipImports) { final Map interfaceFiles = new HashMap<>(); interfaceFiles.put(IMPORTS_FILE_KEY, getInterfaceFilename(artifactName)); keyNameBuilder.append("-interface"); @@ -693,40 +897,37 @@ public class ToscaExportHandler { log.debug("start convert node type for {}", component.getUniqueId()); ToscaNodeType toscaNodeType = createNodeType(component); Either, StorageOperationStatus> lifecycleTypeEither = interfaceLifecycleOperation - .getAllInterfaceLifecycleTypes(); - if (lifecycleTypeEither.isRight()) { + .getAllInterfaceLifecycleTypes(component.getModel()); + if (lifecycleTypeEither.isRight() && !StorageOperationStatus.NOT_FOUND.equals(lifecycleTypeEither.right().value())) { log.debug("Failed to fetch all interface types :", lifecycleTypeEither.right().value()); return Either.right(ToscaError.GENERAL_ERROR); } - List allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream().map(InterfaceDataDefinition::getType) - .collect(Collectors.toList()); - toscaNode.setInterface_types(addInterfaceTypeElement(component, allGlobalInterfaceTypes)); - Either, JanusGraphOperationStatus> dataTypesEither = dataTypeCache.getAll(); + if (lifecycleTypeEither.isLeft()) { + List allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream().map(InterfaceDataDefinition::getType) + .collect(Collectors.toList()); + toscaNode.setInterface_types(interfacesOperationsConverter.addInterfaceTypeElement(component, allGlobalInterfaceTypes)); + } + final var dataTypesEither = applicationDataTypeCache.getAll(component.getModel()); if (dataTypesEither.isRight()) { log.debug("Failed to fetch all data types :", dataTypesEither.right().value()); return Either.right(ToscaError.GENERAL_ERROR); } Map dataTypes = dataTypesEither.left().value(); - List inputDef = component.getInputs(); - Map mergedProperties = new HashMap<>(); interfacesOperationsConverter.addInterfaceDefinitionElement(component, toscaNodeType, dataTypes, isAssociatedComponent); - addInputsToProperties(dataTypes, inputDef, mergedProperties); - final Map toscaAttributeMap; - toscaAttributeMap = convertToToscaAttributes(component.getAttributes(), dataTypes); + final var toscaAttributeMap = convertToToscaAttributes(component.getAttributes(), dataTypes); if (!toscaAttributeMap.isEmpty()) { toscaNodeType.setAttributes(toscaAttributeMap); } + Map convertedProperties = new HashMap(); if (CollectionUtils.isNotEmpty(component.getProperties())) { List properties = component.getProperties(); - Map convertedProperties = properties.stream() - .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition, component.getInputs())).collect(Collectors - .toMap(PropertyDataDefinition::getName, - property -> propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY))); - // merge component properties and inputs properties - mergedProperties.putAll(convertedProperties); + convertedProperties = properties.stream() + .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition, component.getInputs())).collect(Collectors + .toMap(PropertyDataDefinition::getName, + property -> propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY))); } - if (MapUtils.isNotEmpty(mergedProperties)) { - toscaNodeType.setProperties(mergedProperties); + if (MapUtils.isNotEmpty(convertedProperties)) { + toscaNodeType.setProperties(convertedProperties); } /* convert private data_types */ List privateDataTypes = component.getDataTypes(); @@ -734,18 +935,19 @@ public class ToscaExportHandler { Map toscaDataTypeMap = new HashMap<>(); for (DataTypeDefinition dataType : privateDataTypes) { log.debug("Emitting private data type: component.name={} dataType.name={}", - component.getNormalizedName(), dataType.getName()); + component.getNormalizedName(), dataType.getName()); ToscaDataType toscaDataType = new ToscaDataType(); toscaDataType.setDerived_from(dataType.getDerivedFromName()); toscaDataType.setDescription(dataType.getDescription()); toscaDataType.setVersion(dataType.getVersion()); if (CollectionUtils.isNotEmpty(dataType.getProperties())) { toscaDataType.setProperties(dataType.getProperties().stream() - .collect(Collectors.toMap( - PropertyDataDefinition::getName, - s -> propertyConvertor - .convertProperty(dataTypes, s, PropertyType.PROPERTY) - ))); + .collect(Collectors.toMap( + PropertyDataDefinition::getName, + s -> propertyConvertor.convertProperty(dataTypes, s, PropertyType.PROPERTY), + (toscaPropertyTobeValidated, toscaProperty) -> validateToscaProperty(privateDataTypes, toscaPropertyTobeValidated, + toscaProperty) + ))); } toscaDataTypeMap.put(dataType.getName(), toscaDataType); } @@ -756,6 +958,13 @@ public class ToscaExportHandler { return convertReqCapAndTypeName(componentsCache, component, toscaNode, nodeTypes, toscaNodeType, dataTypes); } + private ToscaProperty validateToscaProperty(final List privateDataTypes, final ToscaProperty toscaPropertyTobeValidated, + final ToscaProperty toscaProperty) { + final Optional match = privateDataTypes.stream() + .filter(dataType -> dataType.getName().equals(toscaPropertyTobeValidated.getType())).findFirst(); + return match.isPresent() ? toscaPropertyTobeValidated : toscaProperty; + } + private Map convertToToscaAttributes(final List attributeList, final Map dataTypes) { if (CollectionUtils.isEmpty(attributeList)) { @@ -775,7 +984,7 @@ public class ToscaExportHandler { ToscaNodeType toscaNodeType, Map dataTypes) { Either capabilities = convertCapabilities(componentsCache, component, toscaNodeType, - dataTypes); + dataTypes); if (capabilities.isRight()) { return Either.right(capabilities.right().value()); } @@ -783,7 +992,7 @@ public class ToscaExportHandler { log.debug("Capabilities converted for {}", component.getUniqueId()); Either requirements = capabilityRequirementConverter - .convertRequirements(componentsCache, component, toscaNodeType); + .convertRequirements(componentsCache, component, toscaNodeType); if (requirements.isRight()) { return Either.right(requirements.right().value()); } @@ -794,11 +1003,11 @@ public class ToscaExportHandler { switch (component.getComponentType()) { case RESOURCE: toscaResourceName = ((ResourceMetadataDataDefinition) component.getComponentMetadataDefinition() - .getMetadataDataDefinition()).getToscaResourceName(); + .getMetadataDataDefinition()).getToscaResourceName(); break; case SERVICE: toscaResourceName = SERVICE_NODE_TYPE_PREFIX - + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName(); + + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName(); break; default: log.debug(NOT_SUPPORTED_COMPONENT_TYPE, component.getComponentType()); @@ -832,18 +1041,34 @@ public class ToscaExportHandler { if (MapUtils.isNotEmpty(componentInstance.getToscaArtifacts())) { nodeTemplate.setArtifacts(convertToNodeTemplateArtifacts(componentInstance.getToscaArtifacts())); } + if (componentInstance.getMinOccurrences() != null && componentInstance.getMaxOccurrences() != null) { + List occur = new ArrayList<>(); + occur.add(parseToIntIfPossible(componentInstance.getMinOccurrences())); + occur.add(parseToIntIfPossible(componentInstance.getMaxOccurrences())); + nodeTemplate.setOccurrences(occur); + } + if (componentInstance.getInstanceCount() != null) { + ObjectMapper objectMapper = new ObjectMapper(); + Object obj = convertToToscaObject(componentInstance.getInstanceCount()); + if (obj != null) { + Map map = objectMapper.convertValue(obj, Map.class); + nodeTemplate.setInstance_count(map); + } + } nodeTemplate.setType(componentInstance.getToscaComponentName()); nodeTemplate.setDirectives(componentInstance.getDirectives()); - nodeTemplate.setNode_filter(convertToNodeTemplateNodeFilterComponent(componentInstance.getNodeFilter())); - + NodeFilter nodeFilter = convertToNodeTemplateNodeFilterComponent(componentInstance.getNodeFilter()); + if (nodeFilter != null && nodeFilter.hasData()) { + nodeTemplate.setNode_filter(nodeFilter); + } final Either originComponentRes = capabilityRequirementConverter - .getOriginComponent(componentCache, componentInstance); + .getOriginComponent(componentCache, componentInstance); if (originComponentRes.isRight()) { convertNodeTemplatesRes = Either.right(ToscaError.NODE_TYPE_REQUIREMENT_ERROR); break; } final Either requirements = convertComponentInstanceRequirements(component, componentInstance, - componentInstancesRelations, nodeTemplate, originComponentRes.left().value(), componentCache); + componentInstancesRelations, nodeTemplate, originComponentRes.left().value(), componentCache); if (requirements.isRight()) { convertNodeTemplatesRes = Either.right(requirements.right().value()); break; @@ -863,7 +1088,7 @@ public class ToscaExportHandler { } final Either capabilities = - capabilityRequirementConverter.convertComponentInstanceCapabilities(componentInstance, dataTypes, nodeTemplate); + capabilityRequirementConverter.convertComponentInstanceCapabilities(componentInstance, dataTypes, nodeTemplate); if (capabilities.isRight()) { convertNodeTemplatesRes = Either.right(capabilities.right().value()); break; @@ -888,8 +1113,8 @@ public class ToscaExportHandler { } if (componentInstancesInputs != null - && componentInstancesInputs.containsKey(instanceUniqueId) - && !isComponentOfTypeServiceProxy(componentInstance)) { + && componentInstancesInputs.containsKey(instanceUniqueId) + && !isComponentOfTypeServiceProxy(componentInstance)) { //For service proxy the inputs are already handled under instance properties above addComponentInstanceInputs(dataTypes, componentInstancesInputs, instanceUniqueId, props); } @@ -923,10 +1148,10 @@ public class ToscaExportHandler { topologyTemplate.addGroups(groupsMap); } if (component.getComponentType() == ComponentTypeEnum.SERVICE && isNotEmpty( - ((Service) component).getForwardingPaths())) { + ((Service) component).getForwardingPaths())) { log.debug("Starting converting paths for component {}, name {}", component.getUniqueId(), component.getName()); ForwardingPathToscaUtil - .addForwardingPaths((Service) component, nodeTemplates, capabilityRequirementConverter, componentCache, toscaOperationFacade); + .addForwardingPaths((Service) component, nodeTemplates, capabilityRequirementConverter, componentCache, toscaOperationFacade); log.debug("Finished converting paths for component {}, name {}", component.getUniqueId(), component.getName()); } if (convertNodeTemplatesRes == null) { @@ -936,28 +1161,47 @@ public class ToscaExportHandler { return convertNodeTemplatesRes; } - private void handleInstanceInterfaces( - Map> componentInstanceInterfaces, - ComponentInstance componentInstance, Map dataTypes, ToscaNodeTemplate nodeTemplate, - String instanceUniqueId, - Component parentComponent) { + private Object convertToToscaObject(String value) { + try { + ToscaMapValueConverter mapConverterInst = ToscaMapValueConverter.getInstance(); + StringReader reader = new StringReader(value); + JsonReader jsonReader = new JsonReader(reader); + jsonReader.setLenient(true); + JsonElement jsonElement = JsonParser.parseReader(jsonReader); + if (jsonElement.isJsonObject()) { + JsonObject jsonObj = jsonElement.getAsJsonObject(); + if (jsonObj.entrySet().size() == 1 && jsonObj.has(ToscaFunctions.GET_INPUT.getFunctionName())) { + return mapConverterInst.handleComplexJsonValue(jsonElement); + } + } + return null; + } catch (Exception e) { + log.debug("convertToToscaValue failed to parse json value :", e); + return null; + } + } + + private Object parseToIntIfPossible(final String value) { + final Integer intValue = Ints.tryParse(value); + return intValue == null ? value : intValue; + } + + private void handleInstanceInterfaces(Map> componentInstanceInterfaces, + ComponentInstance componentInstance, Map dataTypes, + ToscaNodeTemplate nodeTemplate, String instanceUniqueId, Component parentComponent) { - if (MapUtils.isEmpty(componentInstanceInterfaces) - || !componentInstanceInterfaces.containsKey(instanceUniqueId)) { + if (MapUtils.isEmpty(componentInstanceInterfaces) || !componentInstanceInterfaces.containsKey(instanceUniqueId)) { nodeTemplate.setInterfaces(null); return; } - final List currServiceInterfaces = - componentInstanceInterfaces.get(instanceUniqueId); + final List currServiceInterfaces = componentInstanceInterfaces.get(instanceUniqueId); final Map tmpInterfaces = new HashMap<>(); - currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface - .getUniqueId(), instInterface)); + currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface.getUniqueId(), instInterface)); final Map interfaceMap = interfacesOperationsConverter - .getInterfacesMap(parentComponent, componentInstance, tmpInterfaces, dataTypes, isComponentOfTypeServiceProxy(componentInstance), - isComponentOfTypeServiceProxy(componentInstance)); + .getInterfacesMap(parentComponent, componentInstance, tmpInterfaces, dataTypes, isComponentOfTypeServiceProxy(componentInstance)); interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap); nodeTemplate.setInterfaces(MapUtils.isEmpty(interfaceMap) ? null : interfaceMap); @@ -965,7 +1209,7 @@ public class ToscaExportHandler { private boolean isComponentOfTypeServiceProxy(ComponentInstance componentInstance) { return Objects.nonNull(componentInstance.getOriginType()) - && componentInstance.getOriginType().getValue().equals("Service Proxy"); + && componentInstance.getOriginType().getValue().equals("Service Proxy"); } private void addComponentInstanceInputs(Map dataTypes, @@ -975,7 +1219,8 @@ public class ToscaExportHandler { List instanceInputsList = componentInstancesInputs.get(instanceUniqueId); if (instanceInputsList != null) { instanceInputsList.forEach(input -> { - Supplier supplier = () -> input.getValue() != null && !Objects.isNull(input.getValue()) ? input.getValue() : input.getDefaultValue(); + Supplier supplier = () -> input.getValue() != null && !Objects.isNull(input.getValue()) ? input.getValue() + : input.getDefaultValue(); propertyConvertor.convertAndAddValue(dataTypes, props, input, supplier); }); } @@ -988,8 +1233,8 @@ public class ToscaExportHandler { if (isNotEmpty(componentInstancesProperties)) { componentInstancesProperties.get(instanceUniqueId) - // Converts and adds each value to property map - .forEach(prop -> propertyConvertor.convertAndAddValue(dataTypes, props, prop, prop::getValue)); + // Converts and adds each value to property map + .forEach(prop -> propertyConvertor.convertAndAddValue(dataTypes, props, prop, prop::getValue)); } } @@ -998,11 +1243,8 @@ public class ToscaExportHandler { final Map attribs) { if (isNotEmpty(componentInstancesAttributes) && componentInstancesAttributes.containsKey(instanceUniqueId)) { - componentInstancesAttributes.get(instanceUniqueId).stream() - // Filters out Attributes with empty default values - .filter(attributeDefinition -> StringUtils.isNotEmpty(attributeDefinition.getDefaultValue())) - // Converts and adds each value to attribute map - .forEach(attributeDefinition -> attributeConverter.convertAndAddValue(attribs, attributeDefinition)); + componentInstancesAttributes.get(instanceUniqueId) + .forEach(attributeDefinition -> attributeConverter.convertAndAddValue(attribs, attributeDefinition)); } } @@ -1012,10 +1254,10 @@ public class ToscaExportHandler { List componentProperties = componentOfInstance.getProperties(); if (isNotEmpty(componentProperties)) { componentProperties.stream() - // Filters out properties with empty default values - .filter(prop -> StringUtils.isNotEmpty(prop.getDefaultValue())) - // Converts and adds each value to property map - .forEach(prop -> propertyConvertor.convertAndAddValue(dataTypes, props, prop, prop::getDefaultValue)); + // Filters out properties with empty default values + .filter(prop -> StringUtils.isNotEmpty(prop.getDefaultValue())) + // Converts and adds each value to property map + .forEach(prop -> propertyConvertor.convertAndAddValue(dataTypes, props, prop, prop::getDefaultValue)); } } @@ -1024,10 +1266,10 @@ public class ToscaExportHandler { final List componentAttributes = componentOfInstance.getAttributes(); if (isNotEmpty(componentAttributes)) { componentAttributes.stream() - // Filters out Attributes with empty default values - .filter(attrib -> StringUtils.isNotEmpty(attrib.getDefaultValue())) - // Converts and adds each value to attribute map - .forEach(attributeDefinition -> attributeConverter.convertAndAddValue(attribs, attributeDefinition)); + // Filters out Attributes with empty default values + .filter(attrib -> StringUtils.isNotEmpty(attrib.getDefaultValue())) + // Converts and adds each value to attribute map + .forEach(attributeDefinition -> attributeConverter.convertAndAddValue(attribs, attributeDefinition)); } } @@ -1040,7 +1282,7 @@ public class ToscaExportHandler { toscaNodeType.setDescription(component.getDescription()); } else { String derivedFrom = null != component.getDerivedFromGenericType() ? component.getDerivedFromGenericType() - : NATIVE_ROOT; + : NATIVE_ROOT; toscaNodeType.setDerived_from(derivedFrom); } return toscaNodeType; @@ -1056,8 +1298,8 @@ public class ToscaExportHandler { } Map serviceProxyInstanceList = new HashMap<>(); componentInstances.stream() - .filter(this::isComponentOfTypeServiceProxy) - .forEach(inst -> serviceProxyInstanceList.put(inst.getToscaComponentName(), inst)); + .filter(this::isComponentOfTypeServiceProxy) + .forEach(inst -> serviceProxyInstanceList.put(inst.getToscaComponentName(), inst)); if (MapUtils.isEmpty(serviceProxyInstanceList)) { return res; } @@ -1067,28 +1309,28 @@ public class ToscaExportHandler { componentParametersView.disableAll(); componentParametersView.setIgnoreInterfaces(false); Either service = toscaOperationFacade - .getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView); + .getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView); if (service.isRight()) { log.debug("Failed to fetch original service component with id {} for instance {}", - entryProxy.getValue().getSourceModelUid(), entryProxy.getValue().getName()); + entryProxy.getValue().getSourceModelUid(), entryProxy.getValue().getName()); return Either.right(ToscaError.GENERAL_ERROR); } else { serviceComponent = service.left().value(); } Either, StorageOperationStatus> lifecycleTypeEither = - interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); + interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(serviceComponent.getModel()); if (lifecycleTypeEither.isRight()) { log.debug("Failed to retrieve global interface types :", lifecycleTypeEither.right().value()); return Either.right(ToscaError.GENERAL_ERROR); } List allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream() - .map(InterfaceDataDefinition::getType) - .collect(Collectors.toList()); + .map(InterfaceDataDefinition::getType) + .collect(Collectors.toList()); //Add interface types for local interfaces in the original service component for proxy - Map localInterfaceTypes = addInterfaceTypeElement(serviceComponent, - allGlobalInterfaceTypes); + Map localInterfaceTypes = interfacesOperationsConverter.addInterfaceTypeElement(serviceComponent, + allGlobalInterfaceTypes); if (MapUtils.isNotEmpty(localInterfaceTypes)) { proxyInterfaceTypes.putAll(localInterfaceTypes); } @@ -1110,8 +1352,8 @@ public class ToscaExportHandler { } Map serviceProxyInstanceList = new HashMap<>(); List proxyInst = componentInstances.stream() - .filter(p -> p.getOriginType().name().equals(OriginTypeEnum.ServiceProxy.name())) - .collect(Collectors.toList()); + .filter(p -> p.getOriginType().name().equals(OriginTypeEnum.ServiceProxy.name())) + .collect(Collectors.toList()); if (proxyInst != null && !proxyInst.isEmpty()) { for (ComponentInstance inst : proxyInst) { serviceProxyInstanceList.put(inst.getToscaComponentName(), inst); @@ -1122,10 +1364,10 @@ public class ToscaExportHandler { return res; } Either serviceProxyOrigin = toscaOperationFacade - .getLatestByName("serviceProxy", null); + .getLatestByName("serviceProxy", null); if (serviceProxyOrigin.isRight()) { log.debug("Failed to fetch normative service proxy resource by tosca name, error {}", - serviceProxyOrigin.right().value()); + serviceProxyOrigin.right().value()); return Either.right(ToscaError.NOT_SUPPORTED_TOSCA_TYPE); } Component origComponent = serviceProxyOrigin.left().value(); @@ -1140,16 +1382,16 @@ public class ToscaExportHandler { componentParametersView.setIgnoreInterfaces(false); componentParametersView.setIgnoreRequirements(false); Either service = toscaOperationFacade - .getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView); + .getToscaElement(entryProxy.getValue().getSourceModelUid(), componentParametersView); if (service.isRight()) { log.debug("Failed to fetch resource with id {} for instance {}", - entryProxy.getValue().getSourceModelUid(), entryProxy.getValue().getName()); + entryProxy.getValue().getSourceModelUid(), entryProxy.getValue().getName()); } else { serviceComponent = service.left().value(); } ToscaNodeType toscaNodeType = createProxyNodeType(componentCache, origComponent, serviceComponent, - entryProxy.getValue()); + entryProxy.getValue()); nodeTypesMap.put(entryProxy.getKey(), toscaNodeType); } @@ -1164,14 +1406,14 @@ public class ToscaExportHandler { return; } final List serviceSubstitutionInstanceList = componentInstances.stream() - .filter(p -> p.getOriginType().name().equals(OriginTypeEnum.ServiceSubstitution.name())) - .collect(Collectors.toList()); + .filter(p -> p.getOriginType().name().equals(OriginTypeEnum.ServiceSubstitution.name())) + .collect(Collectors.toList()); if (CollectionUtils.isNotEmpty(serviceSubstitutionInstanceList)) { for (ComponentInstance inst : serviceSubstitutionInstanceList) { final Map nodeTypes = - toscaNode.getNode_types() == null ? new HashMap<>() : toscaNode.getNode_types(); + toscaNode.getNode_types() == null ? new HashMap<>() : toscaNode.getNode_types(); convertInterfaceNodeType(new HashMap<>(), componentCache.get(inst.getSourceModelUid()), toscaNode, - nodeTypes, true); + nodeTypes, true); } } } @@ -1182,19 +1424,20 @@ public class ToscaExportHandler { String derivedFrom = ((Resource) origComponent).getToscaResourceName(); toscaNodeType.setDerived_from(derivedFrom); - Either, JanusGraphOperationStatus> dataTypesEither = dataTypeCache.getAll(); + Either, JanusGraphOperationStatus> dataTypesEither = applicationDataTypeCache.getAll( + origComponent.getModel()); if (dataTypesEither.isRight()) { log.debug("Failed to retrieve all data types {}", dataTypesEither.right().value()); } Map dataTypes = dataTypesEither.left().value(); Map capabilities = this.capabilityRequirementConverter - .convertProxyCapabilities(componentCache, componentInstance, dataTypes); + .convertProxyCapabilities(componentCache, componentInstance, dataTypes); if (MapUtils.isNotEmpty(capabilities)) { toscaNodeType.setCapabilities(capabilities); } List> proxyNodeTypeRequirements = this.capabilityRequirementConverter - .convertProxyRequirements(componentCache, componentInstance); + .convertProxyRequirements(componentCache, componentInstance); if (CollectionUtils.isNotEmpty(proxyNodeTypeRequirements)) { toscaNodeType.setRequirements(proxyNodeTypeRequirements); } @@ -1208,8 +1451,7 @@ public class ToscaExportHandler { interfaceMap = proxyInterfaces.get(); } } else { - interfaceMap = interfacesOperationsConverter - .getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false, false); + interfaceMap = interfacesOperationsConverter.getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false); } interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap); @@ -1226,16 +1468,17 @@ public class ToscaExportHandler { Map componentCache) { final List requirementDefinitionList = filterRequirements(componentInstance, - relations); + relations); if (isNotEmpty(requirementDefinitionList)) { try { - final List> toscaRequirements = buildRequirements(component, componentInstance, requirementDefinitionList, originComponent, componentCache); - if (!toscaRequirements.isEmpty()) { + final List> toscaRequirements = buildRequirements(component, componentInstance, + requirementDefinitionList, originComponent, componentCache); + if (CollectionUtils.isNotEmpty(toscaRequirements)) { nodeTypeTemplate.setRequirements(toscaRequirements); } } catch (final Exception e) { log.debug("Failed to convert component instance requirements for the component instance {}. ", - componentInstance.getName(), e); + componentInstance.getName(), e); return Either.right(ToscaError.NODE_TYPE_REQUIREMENT_ERROR); } } @@ -1248,13 +1491,15 @@ public class ToscaExportHandler { final List filteredRelations, final Component originComponent, final Map componentCache) - throws ToscaExportException { + throws ToscaExportException { final List> toscaRequirements = new ArrayList<>(); for (RequirementCapabilityRelDef relationshipDefinition : filteredRelations) { final Map toscaTemplateRequirementMap = - buildRequirement(componentInstance, originComponent, component.getComponentInstances(), relationshipDefinition, componentCache); - toscaRequirements.add(toscaTemplateRequirementMap); + buildRequirement(componentInstance, originComponent, component.getComponentInstances(), relationshipDefinition, componentCache); + if (MapUtils.isNotEmpty(toscaTemplateRequirementMap)) { + toscaRequirements.add(toscaTemplateRequirementMap); + } } return toscaRequirements; @@ -1263,7 +1508,7 @@ public class ToscaExportHandler { private List filterRequirements(ComponentInstance componentInstance, List relations) { return relations.stream() - .filter(p -> componentInstance.getUniqueId().equals(p.getFromNode())).collect(Collectors.toList()); + .filter(p -> componentInstance.getUniqueId().equals(p.getFromNode())).collect(Collectors.toList()); } private Map buildRequirement(final ComponentInstance fromInstance, @@ -1271,28 +1516,27 @@ public class ToscaExportHandler { final List instancesList, final RequirementCapabilityRelDef relationshipDefinition, final Map componentCache) - throws ToscaExportException { + throws ToscaExportException { final Map> reqMap = fromOriginComponent.getRequirements(); - final CapabilityRequirementRelationship capabilityRequirementRelationship = relationshipDefinition - .getRelationships().get(0); + if (MapUtils.isEmpty(reqMap)) { + return new HashMap<>(); + } + final CapabilityRequirementRelationship capabilityRequirementRelationship = relationshipDefinition.getRelationships().get(0); final RelationshipInfo relationshipInfo = capabilityRequirementRelationship.getRelation(); - final ComponentInstance toInstance = instancesList.stream() - .filter(i -> relationshipDefinition.getToNode().equals(i.getUniqueId())) - .findFirst().orElse(null); + final ComponentInstance toInstance = instancesList.stream().filter(i -> relationshipDefinition.getToNode().equals(i.getUniqueId())) + .findFirst().orElse(null); if (toInstance == null) { final String errorMsg = String - .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(), - relationshipDefinition.getToNode()); + .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(), + relationshipDefinition.getToNode()); log.debug(errorMsg); throw new ToscaExportException(errorMsg); } - final Optional reqOpt = - findRequirement(fromOriginComponent, reqMap, relationshipInfo, fromInstance.getUniqueId()); + final Optional reqOpt = findRequirement(fromOriginComponent, reqMap, relationshipInfo, fromInstance.getUniqueId()); if (reqOpt.isEmpty()) { - final String errorMsg = String - .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s", + final String errorMsg = String.format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s", relationshipInfo.getRequirementUid(), fromOriginComponent.getUniqueId()); log.debug(errorMsg); throw new ToscaExportException(errorMsg); @@ -1302,46 +1546,44 @@ public class ToscaExportHandler { filter.setIgnoreCapabilities(false); filter.setIgnoreGroups(false); final Either getOriginRes = - toscaOperationFacade.getToscaElement(toInstance.getActualComponentUid(), filter); + toscaOperationFacade.getToscaElement(toInstance.getActualComponentUid(), filter); if (getOriginRes.isRight()) { final String errorMsg = String.format( - "Failed to build substituted name for the requirement %s. " - + "Failed to get an origin component with uniqueId %s", - reqOpt.get().getName(), toInstance.getActualComponentUid()); + "Failed to build substituted name for the requirement %s. Failed to get an origin component with uniqueId %s", + reqOpt.get().getName(), toInstance.getActualComponentUid()); log.debug(errorMsg); throw new ToscaExportException(errorMsg); } final Component toOriginComponent = getOriginRes.left().value(); Optional capOpt = toOriginComponent.getCapabilities().get(reqOpt.get().getCapability()).stream() - .filter(c -> isCapabilityBelongToRelation(relationshipInfo, c)).findFirst(); + .filter(c -> isCapabilityBelongToRelation(relationshipInfo, c)).findFirst(); if (capOpt.isEmpty()) { capOpt = findCapability(relationshipInfo, toOriginComponent, fromOriginComponent, reqOpt.get()); if (capOpt.isEmpty()) { - final String errorMsg = String - .format("Failed to find a capability with name %s on a component with uniqueId %s", + final String errorMsg = String.format("Failed to find a capability with name %s on a component with uniqueId %s", relationshipInfo.getCapability(), fromOriginComponent.getUniqueId()); log.debug(errorMsg); throw new ToscaExportException(errorMsg); } } return buildRequirement(fromOriginComponent, toOriginComponent, capOpt.get(), reqOpt.get(), - capabilityRequirementRelationship, toInstance, componentCache); + capabilityRequirementRelationship, toInstance, componentCache); } private boolean isCapabilityBelongToRelation(RelationshipInfo reqAndRelationshipPair, CapabilityDefinition capability) { return capability.getName().equals(reqAndRelationshipPair.getCapability()) && (capability.getOwnerId() != null - && capability.getOwnerId().equals(reqAndRelationshipPair.getCapabilityOwnerId())); + && capability.getOwnerId().equals(reqAndRelationshipPair.getCapabilityOwnerId())); } private Optional findCapability(RelationshipInfo reqAndRelationshipPair, Component toOriginComponent, Component fromOriginComponent, RequirementDefinition requirement) { Optional cap = toOriginComponent.getCapabilities().get(requirement.getCapability()) - .stream().filter(c -> c.getType().equals(requirement.getCapability())).findFirst(); - if (!cap.isPresent()) { + .stream().filter(c -> c.getType().equals(requirement.getCapability())).findFirst(); + if (cap.isEmpty()) { log.debug("Failed to find a capability with name {} on a component with uniqueId {}", - reqAndRelationshipPair.getCapability(), fromOriginComponent.getUniqueId()); + reqAndRelationshipPair.getCapability(), fromOriginComponent.getUniqueId()); } return cap; } @@ -1353,31 +1595,31 @@ public class ToscaExportHandler { final CapabilityRequirementRelationship capabilityRequirementRelationship, final ComponentInstance toInstance, final Map componentCache) - throws ToscaExportException { + throws ToscaExportException { List reducedPath = capability.getPath(); if (capability.getOwnerId() != null) { reducedPath = capabilityRequirementConverter - .getReducedPathByOwner(capability.getPath(), capability.getOwnerId()); + .getReducedPathByOwner(capability.getPath(), capability.getOwnerId()); } final RelationshipInfo relationshipInfo = capabilityRequirementRelationship.getRelation(); final Either capabilityNameEither = capabilityRequirementConverter.buildSubstitutedName(componentCache, - toOriginComponent, reducedPath, relationshipInfo.getCapability(), capability.getPreviousName()); + toOriginComponent, reducedPath, relationshipInfo.getCapability(), capability.getPreviousName(), capability.getExternalName()); if (capabilityNameEither.isRight()) { final String errorMsg = String.format( - "Failed to build a substituted capability name for the capability with name %s on a component with uniqueId %s", - capabilityRequirementRelationship.getCapability(), toOriginComponent.getUniqueId()); + "Failed to build a substituted capability name for the capability with name %s on a component with uniqueId %s", + capabilityRequirementRelationship.getCapability(), toOriginComponent.getUniqueId()); log.debug( - errorMsg); + errorMsg); throw new ToscaExportException(errorMsg); } final Either requirementNameEither = capabilityRequirementConverter - .buildSubstitutedName(componentCache, fromOriginComponent, - requirement.getPath(), relationshipInfo.getRequirement(), requirement.getPreviousName()); + .buildSubstitutedName(componentCache, fromOriginComponent, + requirement.getPath(), relationshipInfo.getRequirement(), requirement.getPreviousName(), requirement.getExternalName()); if (requirementNameEither.isRight()) { final String errorMsg = String.format("Failed to build a substituted requirement name for the requirement " - + "with name %s on a component with uniqueId %s", - capabilityRequirementRelationship.getRequirement(), fromOriginComponent.getUniqueId()); + + "with name %s on a component with uniqueId %s", + capabilityRequirementRelationship.getRequirement(), fromOriginComponent.getUniqueId()); log.debug(errorMsg); throw new ToscaExportException(errorMsg); } @@ -1396,10 +1638,9 @@ public class ToscaExportHandler { Map> reqMap, RelationshipInfo reqAndRelationshipPair, String fromInstanceId) { - for (List reqList : reqMap.values()) { - Optional reqOpt = reqList.stream().filter( - r -> isRequirementBelongToRelation(fromOriginComponent, reqAndRelationshipPair, r, fromInstanceId)) - .findFirst(); + for (final List reqList : reqMap.values()) { + final Optional reqOpt = reqList.stream() + .filter(r -> isRequirementBelongToRelation(fromOriginComponent, reqAndRelationshipPair, r, fromInstanceId)).findFirst(); if (reqOpt.isPresent()) { return reqOpt; } @@ -1414,40 +1655,44 @@ public class ToscaExportHandler { */ private boolean isRequirementBelongToRelation(Component originComponent, RelationshipInfo reqAndRelationshipPair, RequirementDefinition requirement, String fromInstanceId) { + if (originComponent.isService() && requirement.getUniqueId().equals(reqAndRelationshipPair.getRequirementUid())) { + return true; + } if (!StringUtils.equals(requirement.getName(), reqAndRelationshipPair.getRequirement())) { log.debug("Failed to find a requirement with name {} and reqAndRelationshipPair {}", requirement.getName(), - reqAndRelationshipPair.getRequirement()); + reqAndRelationshipPair.getRequirement()); return false; } return ModelConverter.isAtomicComponent(originComponent) || isRequirementBelongToOwner(reqAndRelationshipPair, requirement, fromInstanceId, - originComponent); + originComponent); } private boolean isRequirementBelongToOwner(RelationshipInfo reqAndRelationshipPair, RequirementDefinition requirement, String fromInstanceId, Component originComponent) { return StringUtils.equals(requirement.getOwnerId(), reqAndRelationshipPair.getRequirementOwnerId()) || ( - isCvfc(originComponent) && StringUtils.equals(fromInstanceId, reqAndRelationshipPair.getRequirementOwnerId()) || StringUtils - .equals(requirement.getOwnerId(), originComponent.getUniqueId())); + isCvfc(originComponent) && StringUtils.equals(fromInstanceId, reqAndRelationshipPair.getRequirementOwnerId()) || StringUtils + .equals(requirement.getOwnerId(), originComponent.getUniqueId())); } private boolean isCvfc(Component component) { return component.getComponentType() == ComponentTypeEnum.RESOURCE && ((Resource) component).getResourceType() == ResourceTypeEnum.CVFC; } - private Either convertCapabilities(Component component, SubstitutionMapping substitutionMappings, - Map componentCache) { - Either result = Either.left(substitutionMappings); - Either, ToscaError> toscaCapabilitiesRes = capabilityRequirementConverter - .convertSubstitutionMappingCapabilities(componentCache, component); + private Either, ToscaError> convertSubstitutionMappingCapabilities(final Component component, + final Map componentCache) { + Either, ToscaError> toscaCapabilitiesRes = + capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component); if (toscaCapabilitiesRes.isRight()) { - result = Either.right(toscaCapabilitiesRes.right().value()); log.debug("Failed convert capabilities for the component {}. ", component.getName()); - } else if (isNotEmpty(toscaCapabilitiesRes.left().value())) { - substitutionMappings.setCapabilities(toscaCapabilitiesRes.left().value()); + return Either.right(toscaCapabilitiesRes.right().value()); + } + if (isNotEmpty(toscaCapabilitiesRes.left().value())) { log.debug("Finish convert capabilities for the component {}. ", component.getName()); + return Either.left(toscaCapabilitiesRes.left().value()); } log.debug("Finished to convert capabilities for the component {}. ", component.getName()); - return result; + + return Either.left(Collections.emptyMap()); } private Either convertCapabilities(Map componentsCache, Component component, ToscaNodeType nodeType, @@ -1469,6 +1714,7 @@ public class ToscaExportHandler { ToscaTemplateArtifact artifact = new ToscaTemplateArtifact(); artifact.setFile(entry.getValue().getFile()); artifact.setType(entry.getValue().getType()); + artifact.setProperties(entry.getValue().getProperties()); arts.put(entry.getKey(), artifact); } return arts; @@ -1480,20 +1726,18 @@ public class ToscaExportHandler { } NodeFilter nodeFilter = new NodeFilter(); ListDataDefinition origCapabilities = inNodeFilter.getCapabilities(); - ListDataDefinition origProperties = inNodeFilter.getProperties(); + ListDataDefinition origProperties = inNodeFilter.getProperties(); List> capabilitiesCopy = new ArrayList<>(); - List>> propertiesCopy = new ArrayList<>(); copyNodeFilterCapabilitiesTemplate(origCapabilities, capabilitiesCopy); - copyNodeFilterProperties(origProperties, propertiesCopy); if (CollectionUtils.isNotEmpty(capabilitiesCopy)) { nodeFilter.setCapabilities(capabilitiesCopy); } + final List>> propertiesCopy = copyNodeFilterProperties(origProperties); if (CollectionUtils.isNotEmpty(propertiesCopy)) { nodeFilter.setProperties(propertiesCopy); } nodeFilter.setTosca_id(cloneToscaId(inNodeFilter.getTosca_id())); - nodeFilter = (NodeFilter) cloneObjectFromYml(nodeFilter, NodeFilter.class); - return nodeFilter; + return cloneObjectFromYml(nodeFilter, NodeFilter.class); } private NodeFilter convertToSubstitutionFilterComponent(final SubstitutionFilterDataDefinition substitutionFilterDataDefinition) { @@ -1501,21 +1745,19 @@ public class ToscaExportHandler { return null; } NodeFilter nodeFilter = new NodeFilter(); - ListDataDefinition origProperties = substitutionFilterDataDefinition.getProperties(); - List>> propertiesCopy = new ArrayList<>(); - copySubstitutionFilterProperties(origProperties, propertiesCopy); - if (CollectionUtils.isNotEmpty(propertiesCopy)) { + final List>> propertiesCopy = copySubstitutionPropertiesFilter(substitutionFilterDataDefinition.getProperties()); + if (!propertiesCopy.isEmpty()) { nodeFilter.setProperties(propertiesCopy); } nodeFilter.setTosca_id(cloneToscaId(substitutionFilterDataDefinition.getTosca_id())); - return (NodeFilter) cloneObjectFromYml(nodeFilter, NodeFilter.class); + return cloneObjectFromYml(nodeFilter, NodeFilter.class); } private Object cloneToscaId(Object toscaId) { return Objects.isNull(toscaId) ? null : cloneObjectFromYml(toscaId, toscaId.getClass()); } - private Object cloneObjectFromYml(Object objToClone, Class classOfObj) { + private T cloneObjectFromYml(Object objToClone, Class classOfObj) { String objectAsYml = yamlUtil.objectToYaml(objToClone); return yamlUtil.yamlToObject(objectAsYml, classOfObj); } @@ -1523,92 +1765,130 @@ public class ToscaExportHandler { private void copyNodeFilterCapabilitiesTemplate(ListDataDefinition origCapabilities, List> capabilitiesCopy) { if (origCapabilities == null || origCapabilities.getListToscaDataDefinition() == null || origCapabilities.getListToscaDataDefinition() - .isEmpty()) { + .isEmpty()) { return; } for (RequirementNodeFilterCapabilityDataDefinition capability : origCapabilities.getListToscaDataDefinition()) { Map capabilityFilterCopyMap = new HashMap<>(); - CapabilityFilter capabilityFilter = new CapabilityFilter(); - List>> propertiesCopy = new ArrayList<>(); - copyNodeFilterProperties(capability.getProperties(), propertiesCopy); - capabilityFilter.setProperties(propertiesCopy); + final var capabilityFilter = new CapabilityFilter(); + capabilityFilter.setProperties(copyNodeFilterProperties(capability.getProperties())); capabilityFilterCopyMap.put(capability.getName(), capabilityFilter); capabilitiesCopy.add(capabilityFilterCopyMap); } } - private void copyNodeFilterProperties(ListDataDefinition origProperties, - List>> propertiesCopy) { + private List>> copyNodeFilterProperties(final ListDataDefinition origProperties) { if (origProperties == null || origProperties.getListToscaDataDefinition() == null || origProperties.isEmpty()) { - return; + return Collections.emptyList(); } - Map> propertyMapCopy = new HashMap<>(); - for (RequirementNodeFilterPropertyDataDefinition propertyDataDefinition : origProperties.getListToscaDataDefinition()) { - for (String propertyInfoEntry : propertyDataDefinition.getConstraints()) { - Map> propertyValObj = new YamlUtil().yamlToObject(propertyInfoEntry, Map.class); - String propertyName = propertyDataDefinition.getName(); - if (propertyMapCopy.containsKey(propertyName)) { - addPropertyConstraintValueToList(propertyName, propertyValObj, propertyMapCopy.get(propertyName)); - } else { - if (propertyName != null) { - List propsList = new ArrayList<>(); - addPropertyConstraintValueToList(propertyName, propertyValObj, propsList); - propertyMapCopy.put(propertyName, propsList); - } else { - propertyMapCopy.putAll(propertyValObj); + List>> propertiesCopy = new ArrayList<>(); + Map> propertyFilterDefinitionMap = new HashMap<>(); + for (final PropertyFilterDataDefinition propertyFilter : origProperties.getListToscaDataDefinition()) { + final String propertyName = propertyFilter.getName(); + for (final PropertyFilterConstraintDataDefinition filterConstraint : propertyFilter.getConstraints()) { + propertyFilterDefinitionMap.compute(propertyName, (propertyName1, constraints) -> { + if (constraints == null) { + constraints = new ArrayList<>(); } - } + constraints.add(buildNodeFilterValue(filterConstraint)); + return constraints; + }); } } - propertyMapCopy.entrySet().stream().forEach(entry -> addCalculatedConstraintsIntoPropertiesList(propertiesCopy, entry)); + propertyFilterDefinitionMap.entrySet().stream() + .map(entry -> Map.of(entry.getKey(), entry.getValue())) + .forEach(propertiesCopy::add); + return propertiesCopy; } - private void copySubstitutionFilterProperties(final ListDataDefinition origProperties, - final List>> propertiesCopy) { + private List>> copySubstitutionPropertiesFilter( + final ListDataDefinition origProperties) { + if (origProperties == null || origProperties.getListToscaDataDefinition() == null || origProperties.isEmpty()) { - return; + return Collections.emptyList(); } - final Map> propertyMapCopy = new HashMap<>(); - for (final RequirementSubstitutionFilterPropertyDataDefinition propertyDataDefinition : origProperties.getListToscaDataDefinition()) { - for (final String propertyInfoEntry : propertyDataDefinition.getConstraints()) { - final Map> propertyValObj = new YamlUtil().yamlToObject(propertyInfoEntry, Map.class); - final String propertyName = propertyDataDefinition.getName(); - if (propertyMapCopy.containsKey(propertyName)) { - addPropertyConstraintValueToList(propertyName, propertyValObj, propertyMapCopy.get(propertyName)); - } else { - if (propertyName != null) { - final List propsList = new ArrayList<>(); - addPropertyConstraintValueToList(propertyName, propertyValObj, propsList); - propertyMapCopy.put(propertyName, propsList); - } else { - propertyMapCopy.putAll(propertyValObj); + List>> propertiesCopy = new ArrayList<>(); + Map> propertyFilterDefinitionMap = new HashMap<>(); + for (final SubstitutionFilterPropertyDataDefinition propertyFilter : origProperties.getListToscaDataDefinition()) { + final String propertyName = propertyFilter.getName(); + for (final PropertyFilterConstraintDataDefinition filterConstraint : propertyFilter.getConstraints()) { + propertyFilterDefinitionMap.compute(propertyName, (propertyName1, constraints) -> { + if (constraints == null) { + constraints = new ArrayList<>(); } - } + constraints.add(buildNodeFilterValue(filterConstraint)); + return constraints; + }); } } - propertyMapCopy.entrySet().forEach(entry -> addCalculatedConstraintsIntoPropertiesList(propertiesCopy, entry)); + propertyFilterDefinitionMap.entrySet().stream() + .map(entry -> Map.of(entry.getKey(), entry.getValue())) + .forEach(propertiesCopy::add); + return propertiesCopy; } - private void addPropertyConstraintValueToList(String propertyName, Map> propertyValObj, List propsList) { - if (propertyValObj.containsKey(propertyName)) { - propsList.add(propertyValObj.get(propertyName)); - } else { - propsList.add(propertyValObj); + private static Object buildNodeFilterValue(final PropertyFilterConstraintDataDefinition filterConstraint) { + if (filterConstraint.getValue() instanceof ToscaFunction) { + return Map.of(filterConstraint.getOperator().getType(), ((ToscaFunction) filterConstraint.getValue()).getJsonObjectValue()); + } + if (filterConstraint.getValue() instanceof List) { + if (((List) filterConstraint.getValue()).get(0) instanceof ToscaFunction) { + List toscaFunctionList = new ArrayList<>(); + ((List) filterConstraint.getValue()).forEach(toscaFunctionValue -> toscaFunctionList.add( + ((ToscaFunction) toscaFunctionValue).getJsonObjectValue())); + return Map.of(filterConstraint.getOperator().getType(), toscaFunctionList); + } + } + if (doesTypeNeedConvertingToIntOrFloat(filterConstraint.getOriginalType(), filterConstraint.getValue())) { + ToscaType toscaType = ToscaType.getToscaType( + filterConstraint.getValue() instanceof List ? ToscaType.LIST.getType() : filterConstraint.getOriginalType()); + filterConstraint.setValue(toscaType.convert(String.valueOf(filterConstraint.getValue()))); + } else if (ConstraintType.LENGTH.getType().equals(filterConstraint.getOperator().getType()) || + ConstraintType.MIN_LENGTH.getType().equals(filterConstraint.getOperator().getType()) || + ConstraintType.MAX_LENGTH.getType().equals(filterConstraint.getOperator().getType())) { + filterConstraint.setValue(Integer.valueOf(String.valueOf(filterConstraint.getValue()))); } + if (doesTypeNeedConvertingToBoolean(filterConstraint.getOriginalType())) { + filterConstraint.setValue(ToscaType.getToscaType(filterConstraint.getOriginalType()).convert( + String.valueOf(filterConstraint.getValue()))); + } + return Map.of(filterConstraint.getOperator().getType(), filterConstraint.getValue()); + } + + private static boolean doesTypeNeedConvertingToIntOrFloat(String propertyType, Object value) { + if (value instanceof List && ((List) value).get(0) instanceof LinkedHashMap + && ((LinkedHashMap) ((List) value).get(0)).get("type") != null) { + return false; + } + return ToscaType.INTEGER.getType().equals(propertyType) || ToscaType.FLOAT.getType().equals(propertyType); } - private void addCalculatedConstraintsIntoPropertiesList(List>> propertiesCopy, Entry> entry) { - Map> tempMap = new HashMap<>(); - tempMap.put(entry.getKey(), entry.getValue()); - propertiesCopy.add(tempMap); + private static boolean doesTypeNeedConvertingToBoolean(String propertyType) { + return ToscaType.BOOLEAN.getType().equals(propertyType); } private Map buildSubstitutionMappingPropertyMapping(final Component component) { if (component == null || CollectionUtils.isEmpty(component.getInputs())) { return Collections.emptyMap(); } - return component.getInputs().stream().filter(InputDefinition::isMappedToComponentProperty).map(PropertyDataDefinition::getName) - .collect(Collectors.toMap(inputName -> inputName, inputName -> new String[]{inputName}, (inputName1, inputName2) -> inputName1)); + Map propertyMapping = new HashMap<>(); + List propertyMappedInputList = component.getInputs().stream().filter(InputDefinition::isMappedToComponentProperty).collect( + Collectors.toList()); + + if (CollectionUtils.isNotEmpty(propertyMappedInputList)) { + propertyMappedInputList.forEach(inputDefinition -> { + if (StringUtils.isNotEmpty(inputDefinition.getPropertyId())) { + Optional property = component.getProperties().stream() + .filter(propertyDefinition -> propertyDefinition.getUniqueId().equals(inputDefinition.getPropertyId())).findFirst(); + if (property.isPresent()) { + propertyMapping.put(property.get().getName(), new String[]{inputDefinition.getName()}); + } + } else { + propertyMapping.put(inputDefinition.getName(), new String[]{inputDefinition.getName()}); + } + }); + } + return propertyMapping; } private Map buildSubstitutionMappingAttributesMapping(final Component component) { @@ -1616,36 +1896,33 @@ public class ToscaExportHandler { return Collections.emptyMap(); } return component.getOutputs().stream().map(AttributeDataDefinition::getName) - .collect(Collectors.toMap(outputName -> outputName, outputName -> new String[]{outputName}, (outputName1, outputName2) -> outputName1)); + .collect(Collectors.toMap(outputName -> outputName, outputName -> new String[]{outputName}, (outputName1, outputName2) -> outputName1)); } - Optional> getProxyNodeTypeProperties(Component proxyComponent, Map dataTypes) { + private Optional> getProxyNodeTypeProperties(Component proxyComponent, Map dataTypes) { if (Objects.isNull(proxyComponent)) { return Optional.empty(); } - Map proxyProperties = new HashMap<>(); - addInputsToProperties(dataTypes, proxyComponent.getInputs(), proxyProperties); + final var proxyProperties = convertInputsToProperties(dataTypes, proxyComponent.getInputs(), proxyComponent.getUniqueId()); if (CollectionUtils.isNotEmpty(proxyComponent.getProperties())) { proxyProperties.putAll(proxyComponent.getProperties().stream() - .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition, proxyComponent.getInputs())).collect(Collectors - .toMap(PropertyDataDefinition::getName, - property -> propertyConvertor.convertProperty(dataTypes, property, PropertyConvertor.PropertyType.PROPERTY)))); + .map(propertyDefinition -> resolvePropertyValueFromInput(propertyDefinition, proxyComponent.getInputs())).collect(Collectors + .toMap(PropertyDataDefinition::getName, + property -> propertyConvertor.convertProperty(dataTypes, property, PropertyType.PROPERTY)))); } return MapUtils.isNotEmpty(proxyProperties) ? Optional.of(proxyProperties) : Optional.empty(); } - void addInputsToProperties(Map dataTypes, List componentInputs, - Map mergedProperties) { + private Map convertInputsToProperties(Map dataTypes, List componentInputs, + String componentUniqueId) { if (CollectionUtils.isEmpty(componentInputs)) { - return; - } - for (InputDefinition input : componentInputs) { - ToscaProperty property = propertyConvertor.convertProperty(dataTypes, input, PropertyConvertor.PropertyType.INPUT); - mergedProperties.put(input.getName(), property); + return new HashMap<>(); } + return componentInputs.stream().filter(input -> componentUniqueId.equals(input.getInstanceUniqueId())) + .collect(Collectors.toMap(InputDefinition::getName, i -> propertyConvertor.convertProperty(dataTypes, i, PropertyType.INPUT))); } - Optional> getProxyNodeTypeInterfaces(Component proxyComponent, Map dataTypes) { + private Optional> getProxyNodeTypeInterfaces(Component proxyComponent, Map dataTypes) { if (Objects.isNull(proxyComponent) || MapUtils.isEmpty(proxyComponent.getInterfaces())) { return Optional.empty(); } @@ -1654,14 +1931,16 @@ public class ToscaExportHandler { // always available in the proxy node template removeOperationImplementationForProxyNodeType(proxyComponentInterfaces); - return Optional - .ofNullable(interfacesOperationsConverter.getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes, false, false)); + return Optional.ofNullable(interfacesOperationsConverter.getInterfacesMap(proxyComponent, null, proxyComponentInterfaces, dataTypes, false)); + } + + private Configuration getConfiguration() { + return ConfigurationManager.getConfigurationManager().getConfiguration(); } private static class CustomRepresenter extends Representer { CustomRepresenter() { - super(); this.representers.put(ToscaPropertyAssignment.class, new RepresentToscaPropertyAssignment()); this.representers.put(ToscaAttribute.class, new RepresentToscaAttribute()); // null representer is exceptional and it is stored as an instance @@ -1699,6 +1978,9 @@ public class ToscaExportHandler { if (javaBean instanceof ToscaRelationshipTemplate && "name".equals(property.getName())) { return null; } + if (javaBean instanceof ToscaPropertyConstraint) { + return handleToscaPropertyConstraint((ToscaPropertyConstraint) javaBean, property, propertyValue, customTag); + } removeDefaultP(propertyValue); NodeTuple defaultNode = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag); if (javaBean instanceof ToscaTopolgyTemplate && "relationshipTemplates".equals(property.getName())) { @@ -1707,6 +1989,13 @@ public class ToscaExportHandler { return "_defaultp_".equals(property.getName()) ? new NodeTuple(representData("default"), defaultNode.getValueNode()) : defaultNode; } + private NodeTuple handleToscaPropertyConstraint(final ToscaPropertyConstraint javaBean, final Property property, final Object propertyValue, + final Tag customTag) { + final NodeTuple nodeTuple = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag); + final String entryToscaName = javaBean.getEntryToscaName(property.getName()); + return new NodeTuple(representData(entryToscaName), nodeTuple.getValueNode()); + } + private void removeDefaultP(final Object propertyValue) { if (propertyValue instanceof Map) { final Map mapPropertyValue = ((Map) propertyValue); @@ -1775,9 +2064,9 @@ public class ToscaExportHandler { return false; } final List functionList = Arrays - .asList(GET_ATTRIBUTE.getFunctionName(), GET_INPUT.getFunctionName(), GET_PROPERTY.getFunctionName()); + .asList(GET_ATTRIBUTE.getFunctionName(), GET_INPUT.getFunctionName(), GET_PROPERTY.getFunctionName()); final Optional function = getAttributeMap.keySet().stream() - .filter(key -> functionList.stream().anyMatch(function1 -> function1.equals(key))).findFirst(); + .filter(key -> functionList.stream().anyMatch(function1 -> function1.equals(key))).findFirst(); if (function.isEmpty()) { return false; } @@ -1813,8 +2102,4 @@ public class ToscaExportHandler { } } - private Configuration getConfiguration() { - return ConfigurationManager.getConfigurationManager().getConfiguration(); - } - }