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.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.gson.JsonParser;
+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.Set;
import java.util.function.Supplier;
import java.util.stream.Collectors;
-import com.google.common.primitives.Ints;
+
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.FilenameUtils;
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.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;
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.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;
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<String> 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 final ApplicationDataTypeCache applicationDataTypeCache;
private final ToscaOperationFacade toscaOperationFacade;
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<ToscaRepresentation, ToscaError> exportComponent(Component component) {
return convertToToscaTemplate(component).left().map(this::createToscaRepresentation);
}
+ public Either<ToscaRepresentation, ToscaError> exportDataType(DataTypeDefinition dataTypeDefinition) {
+ return convertDataTypeToToscaTemplate(dataTypeDefinition).left().map(this::createToscaRepresentation);
+ }
+
public Either<ToscaRepresentation, ToscaError> exportComponentInterface(final Component component, final boolean isAssociatedComponent) {
final List<Map<String, Map<String, String>>> imports = new ArrayList<>(getDefaultToscaImports(component.getModel()));
if (CollectionUtils.isEmpty(imports)) {
}
List<Triple<String, String, Component>> dependencies = new ArrayList<>();
if (component.getDerivedFromGenericType() != null && !component.getDerivedFromGenericType()
- .startsWith("org.openecomp.resource.abstract.nodes.")) {
+ .startsWith("org.openecomp.resource.abstract.nodes.")) {
final Either<Component, StorageOperationStatus> baseType = toscaOperationFacade
- .getByToscaResourceNameAndVersion(component.getDerivedFromGenericType(), component.getDerivedFromGenericVersion(), component.getModel());
+ .getByToscaResourceNameAndVersion(component.getDerivedFromGenericType(), component.getDerivedFromGenericVersion(),
+ component.getModel());
if (baseType.isLeft() && baseType.left().value() != null) {
addDependencies(imports, dependencies, baseType.left().value());
} else {
toscaTemplate.setImports(imports);
final Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
final Either<ToscaTemplate, ToscaError> toscaTemplateRes = convertInterfaceNodeType(new HashMap<>(), component, toscaTemplate, nodeTypes,
- isAssociatedComponent);
+ isAssociatedComponent);
if (toscaTemplateRes.isRight()) {
return Either.right(toscaTemplateRes.right().value());
}
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);
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<ToscaTemplate, ToscaError> getDependencies(Component component) {
}
}
- public List<Map<String, Map<String, String>>> getDefaultToscaImports(final String modelId) {
+ private Either<ToscaTemplate, ToscaError> convertDataTypeToToscaTemplate(final DataTypeDefinition dataTypeDefinition) {
+ final ToscaTemplate toscaTemplate = new ToscaTemplate(TOSCA_VERSION);
+ return convertDataTypeTosca(dataTypeDefinition, toscaTemplate);
+ }
+
+ private Either<ToscaTemplate, ToscaError> 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<String, DataTypeDefinition> dataTypes = dataTypesEither.left().value();
+ if (!dataTypeDefinition.isEmpty()) {
+ Map<String, ToscaDataType> 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>) dataTypeDefinition,
+ toscaPropertyTobeValidated,
+ toscaProperty)
+ )));
+ }
+ toscaDataTypeMap.put(dataTypeDefinition.getName(), toscaDataType);
+ toscaTemplate.setData_types(toscaDataTypeMap);
+ }
+ return Either.left(toscaTemplate);
+ }
+
+ private List<Map<String, Map<String, String>>> getDefaultToscaImports(final String modelId) {
if (modelId == null) {
return getDefaultToscaImportConfig();
}
-
+
final List<ToscaImportByModel> allModelImports = modelOperation.findAllModelImports(modelId, true);
final List<Map<String, Map<String, String>>> importList = new ArrayList<>();
final Set<Path> addedPathList = new HashSet<>();
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()) {
}
if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
final Either<Map<String, ToscaNodeTemplate>, ToscaError> nodeTemplates =
- convertNodeTemplates(component, componentCache, dataTypes, topologyTemplate);
+ convertNodeTemplates(component, componentCache, dataTypes, topologyTemplate);
if (nodeTemplates.isRight()) {
return Either.right(nodeTemplates.right().value());
}
topologyTemplate.setNode_templates(nodeTemplates.left().value());
}
final Map<String, ToscaRelationshipTemplate> relationshipTemplatesMap = new ToscaExportRelationshipTemplatesHandler()
- .createFrom(topologyTemplate.getNode_templates());
+ .createFrom(topologyTemplate.getNode_templates());
if (!relationshipTemplatesMap.isEmpty()) {
topologyTemplate.setRelationshipTemplates(relationshipTemplatesMap);
}
switch (component.getComponentType()) {
case RESOURCE:
final ResourceMetadataDataDefinition resourceMetadata =
- (ResourceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition();
+ (ResourceMetadataDataDefinition) component.getComponentMetadataDefinition().getMetadataDataDefinition();
return Either.left(resourceMetadata.getToscaResourceName());
case SERVICE:
return Either.left(SERVICE_NODE_TYPE_PREFIX + component.getComponentMetadataDefinition().getMetadataDataDefinition().getSystemName());
final String toscaResourceName = toscaResourceNameEither.left().value();
final SubstitutionMapping substitutionMapping = new SubstitutionMapping();
- substitutionMapping.setNode_type(toscaResourceName);
+ if (doNotExtendBaseType(component)) {
+ substitutionMapping.setNode_type(component.getDerivedFromGenericType());
+ } else {
+ substitutionMapping.setNode_type(toscaResourceName);
+ }
convertSubstitutionMappingFilter(component).ifPresent(substitutionMapping::setSubstitution_filter);
final Either<Map<String, String[]>, ToscaError> capabilitiesEither = convertSubstitutionMappingCapabilities(component, componentCache);
if (!capabilityMap.isEmpty()) {
substitutionMapping.setCapabilities(capabilityMap);
}
-
final Either<Map<String, String[]>, ToscaError> requirements =
- capabilityRequirementConverter.convertSubstitutionMappingRequirements(component, componentCache);
+ capabilityRequirementConverter.convertSubstitutionMappingRequirements(component, componentCache);
if (requirements.isRight()) {
throw new ToscaExportException("Could not convert substitution mapping requirements", requirements.right().value());
}
final Map<String, String[]> requirementMap = requirements.left().value();
- if (!requirementMap.isEmpty()) {
+ if (MapUtils.isNotEmpty(requirementMap)) {
substitutionMapping.setRequirements(requirementMap);
}
final Map<String, String[]> propertyMappingMap = buildSubstitutionMappingPropertyMapping(component);
- if (!propertyMappingMap.isEmpty()) {
+ if (MapUtils.isNotEmpty(propertyMappingMap)) {
substitutionMapping.setProperties(propertyMappingMap);
}
final Map<String, String[]> attributesMappingMap = buildSubstitutionMappingAttributesMapping(component);
- if (!attributesMappingMap.isEmpty()) {
+ if (MapUtils.isNotEmpty(attributesMappingMap)) {
substitutionMapping.setAttributes(attributesMappingMap);
}
return Optional.of(substitutionMapping);
}
+ private boolean doNotExtendBaseType(final Component component) {
+ final Map<String, CategoryBaseTypeConfig> serviceNodeTypesConfig = ConfigurationManager.getConfigurationManager().getConfiguration()
+ .getServiceBaseNodeTypes();
+ List<CategoryDefinition> 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 Optional<NodeFilter> convertSubstitutionMappingFilter(final Component component) {
if (component.getSubstitutionFilter() == null || (component.getSubstitutionFilter().getProperties()).getListToscaDataDefinition() == null) {
return Optional.empty();
}
}
- private Map<String, String> convertMetadata(Component component) {
+ private Map<String, Object> convertMetadata(Component component) {
return convertMetadata(component, false, null);
}
- private Map<String, String> convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) {
- Map<String, String> toscaMetadata = new LinkedHashMap<>();
+ private Map<String, Object> convertMetadata(Component component, boolean isInstance, ComponentInstance componentInstance) {
+ Map<String, Object> 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<CategoryDefinition> 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());
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());
}
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;
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.ECOMP_GENERATED_NAMING.getPresentation(), service.isEcompGeneratedNaming());
toscaMetadata.put(JsonPresentationFields.NAMING_POLICY.getPresentation(), service.getNamingPolicy());
}
break;
Map<String, Component> componentCache = new HashMap<>();
if (!ModelConverter.isAtomicComponent(component)) {
final List<Map<String, Map<String, String>>> additionalImports =
- toscaTemplate.getImports() == null ? new ArrayList<>(defaultToscaImportConfig) : new ArrayList<>(toscaTemplate.getImports());
+ toscaTemplate.getImports() == null ? new ArrayList<>(defaultToscaImportConfig) : new ArrayList<>(toscaTemplate.getImports());
List<Triple<String, String, Component>> dependencies = new ArrayList<>();
Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
final Map<String, Map<String, String>> substituteTypeImportEntry = generateComponentSubstituteTypeImport(component, toscaArtifacts);
private Map<String, Map<String, String>> generateComponentSubstituteTypeImport(final Component component,
final Map<String, ArtifactDefinition> toscaArtifacts) {
-
+ if (doNotExtendBaseType(component)) {
+ return Collections.emptyMap();
+ }
if (component instanceof Service && !((Service) component).isSubstituteCandidate()) {
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()))
+ Map.of(IMPORTS_FILE_KEY, getInterfaceFilename(artifactDefinition.getArtifactName()))
);
}
final Either<Component, StorageOperationStatus> 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();
final Component fetchedComponent) {
componentCache.put(fetchedComponent.getUniqueId(), fetchedComponent);
if (componentInstance.getOriginType() == OriginTypeEnum.ServiceProxy
- || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) {
+ || componentInstance.getOriginType() == OriginTypeEnum.ServiceSubstitution) {
final Either<Component, StorageOperationStatus> 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);
componentsList.add(fetchedComponent);
for (final ComponentInstance componentInstance : parentResource.getComponentInstances()) {
final Either<Resource, StorageOperationStatus> resourcefetched = toscaOperationFacade
- .getToscaElement(componentInstance.getComponentUid());
+ .getToscaElement(componentInstance.getComponentUid());
if (resourcefetched != null && resourcefetched.isLeft()) {
final Map<String, String> derivedWithId = resourcefetched.left().value().getDerivedFromMapOfIdToName();
if (MapUtils.isNotEmpty(derivedWithId)) {
log.debug("start convert node type for {}", component.getUniqueId());
ToscaNodeType toscaNodeType = createNodeType(component);
Either<Map<String, InterfaceDefinition>, StorageOperationStatus> lifecycleTypeEither = interfaceLifecycleOperation
- .getAllInterfaceLifecycleTypes(component.getModel());
+ .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);
}
if (lifecycleTypeEither.isLeft()) {
List<String> allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream().map(InterfaceDataDefinition::getType)
- .collect(Collectors.toList());
- toscaNode.setInterface_types(addInterfaceTypeElement(component, allGlobalInterfaceTypes));
+ .collect(Collectors.toList());
+ toscaNode.setInterface_types(interfacesOperationsConverter.addInterfaceTypeElement(component, allGlobalInterfaceTypes));
}
- Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypesEither = applicationDataTypeCache.getAll(component.getModel());
+ 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<String, DataTypeDefinition> dataTypes = dataTypesEither.left().value();
- List<InputDefinition> inputDef = component.getInputs();
- Map<String, ToscaProperty> mergedProperties = new HashMap<>();
interfacesOperationsConverter.addInterfaceDefinitionElement(component, toscaNodeType, dataTypes, isAssociatedComponent);
- addInputsToProperties(dataTypes, inputDef, mergedProperties);
- final Map<String, ToscaAttribute> toscaAttributeMap;
- toscaAttributeMap = convertToToscaAttributes(component.getAttributes(), dataTypes);
+ final var toscaAttributeMap = convertToToscaAttributes(component.getAttributes(), dataTypes);
if (!toscaAttributeMap.isEmpty()) {
toscaNodeType.setAttributes(toscaAttributeMap);
}
+ Map<String, ToscaProperty> convertedProperties = new HashMap();
if (CollectionUtils.isNotEmpty(component.getProperties())) {
List<PropertyDefinition> properties = component.getProperties();
- Map<String, ToscaProperty> 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<DataTypeDefinition> privateDataTypes = component.getDataTypes();
Map<String, ToscaDataType> 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),
- (toscaPropertyTobeValidated, toscaProperty) -> validateToscaProperty(privateDataTypes, toscaPropertyTobeValidated, toscaProperty)
- )));
+ .collect(Collectors.toMap(
+ PropertyDataDefinition::getName,
+ s -> propertyConvertor.convertProperty(dataTypes, s, PropertyType.PROPERTY),
+ (toscaPropertyTobeValidated, toscaProperty) -> validateToscaProperty(privateDataTypes, toscaPropertyTobeValidated,
+ toscaProperty)
+ )));
}
toscaDataTypeMap.put(dataType.getName(), toscaDataType);
}
private ToscaProperty validateToscaProperty(final List<DataTypeDefinition> privateDataTypes, final ToscaProperty toscaPropertyTobeValidated,
final ToscaProperty toscaProperty) {
final Optional<DataTypeDefinition> match = privateDataTypes.stream()
- .filter(dataType -> dataType.getName().equals(toscaPropertyTobeValidated.getType())).findFirst();
+ .filter(dataType -> dataType.getName().equals(toscaPropertyTobeValidated.getType())).findFirst();
return match.isPresent() ? toscaPropertyTobeValidated : toscaProperty;
}
ToscaNodeType toscaNodeType,
Map<String, DataTypeDefinition> dataTypes) {
Either<ToscaNodeType, ToscaError> capabilities = convertCapabilities(componentsCache, component, toscaNodeType,
- dataTypes);
+ dataTypes);
if (capabilities.isRight()) {
return Either.right(capabilities.right().value());
}
log.debug("Capabilities converted for {}", component.getUniqueId());
Either<ToscaNodeType, ToscaError> requirements = capabilityRequirementConverter
- .convertRequirements(componentsCache, component, toscaNodeType);
+ .convertRequirements(componentsCache, component, toscaNodeType);
if (requirements.isRight()) {
return Either.right(requirements.right().value());
}
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());
if (MapUtils.isNotEmpty(componentInstance.getToscaArtifacts())) {
nodeTemplate.setArtifacts(convertToNodeTemplateArtifacts(componentInstance.getToscaArtifacts()));
}
- if (componentInstance.getMinOccurrences() != null && componentInstance.getMaxOccurrences()!= null){
+ if (componentInstance.getMinOccurrences() != null && componentInstance.getMaxOccurrences() != null) {
List<Object> occur = new ArrayList<>();
occur.add(parseToIntIfPossible(componentInstance.getMinOccurrences()));
occur.add(parseToIntIfPossible(componentInstance.getMaxOccurrences()));
nodeTemplate.setOccurrences(occur);
}
- if (componentInstance.getInstanceCount() != null){
+ if (componentInstance.getInstanceCount() != null) {
ObjectMapper objectMapper = new ObjectMapper();
Object obj = convertToToscaObject(componentInstance.getInstanceCount());
- if(obj != null) {
+ if (obj != null) {
Map<String, String> 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<Component, Boolean> originComponentRes = capabilityRequirementConverter
- .getOriginComponent(componentCache, componentInstance);
+ .getOriginComponent(componentCache, componentInstance);
if (originComponentRes.isRight()) {
convertNodeTemplatesRes = Either.right(ToscaError.NODE_TYPE_REQUIREMENT_ERROR);
break;
}
final Either<ToscaNodeTemplate, ToscaError> 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;
}
final Either<ToscaNodeTemplate, ToscaError> capabilities =
- capabilityRequirementConverter.convertComponentInstanceCapabilities(componentInstance, dataTypes, nodeTemplate);
+ capabilityRequirementConverter.convertComponentInstanceCapabilities(componentInstance, dataTypes, nodeTemplate);
if (capabilities.isRight()) {
convertNodeTemplatesRes = Either.right(capabilities.right().value());
break;
}
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);
}
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) {
return convertNodeTemplatesRes;
}
- public Object convertToToscaObject(String value) {
+ private Object convertToToscaObject(String value) {
try {
ToscaMapValueConverter mapConverterInst = ToscaMapValueConverter.getInstance();
- JsonParser jsonParser = new JsonParser();
StringReader reader = new StringReader(value);
JsonReader jsonReader = new JsonReader(reader);
jsonReader.setLenient(true);
- JsonElement jsonElement = jsonParser.parse(jsonReader);
+ JsonElement jsonElement = JsonParser.parseReader(jsonReader);
if (jsonElement.isJsonObject()) {
JsonObject jsonObj = jsonElement.getAsJsonObject();
if (jsonObj.entrySet().size() == 1 && jsonObj.has(ToscaFunctions.GET_INPUT.getFunctionName())) {
return intValue == null ? value : intValue;
}
- private void handleInstanceInterfaces(
- Map<String, List<ComponentInstanceInterface>> componentInstanceInterfaces,
- ComponentInstance componentInstance, Map<String, DataTypeDefinition> dataTypes, ToscaNodeTemplate nodeTemplate,
- String instanceUniqueId,
- Component parentComponent) {
+ private void handleInstanceInterfaces(Map<String, List<ComponentInstanceInterface>> componentInstanceInterfaces,
+ ComponentInstance componentInstance, Map<String, DataTypeDefinition> 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<ComponentInstanceInterface> currServiceInterfaces =
- componentInstanceInterfaces.get(instanceUniqueId);
+ final List<ComponentInstanceInterface> currServiceInterfaces = componentInstanceInterfaces.get(instanceUniqueId);
final Map<String, InterfaceDefinition> tmpInterfaces = new HashMap<>();
- currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface
- .getUniqueId(), instInterface));
+ currServiceInterfaces.forEach(instInterface -> tmpInterfaces.put(instInterface.getUniqueId(), instInterface));
final Map<String, Object> 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);
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<String, DataTypeDefinition> dataTypes,
List<ComponentInstanceInput> instanceInputsList = componentInstancesInputs.get(instanceUniqueId);
if (instanceInputsList != null) {
instanceInputsList.forEach(input -> {
- Supplier<String> supplier = () -> input.getValue() != null && !Objects.isNull(input.getValue()) ? input.getValue() : input.getDefaultValue();
+ Supplier<String> supplier = () -> input.getValue() != null && !Objects.isNull(input.getValue()) ? input.getValue()
+ : input.getDefaultValue();
propertyConvertor.convertAndAddValue(dataTypes, props, input, supplier);
});
}
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));
}
}
final Map<String, Object> 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));
}
}
List<PropertyDefinition> 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));
}
}
final List<AttributeDefinition> 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));
}
}
toscaNodeType.setDescription(component.getDescription());
} else {
String derivedFrom = null != component.getDerivedFromGenericType() ? component.getDerivedFromGenericType()
- : NATIVE_ROOT;
+ : NATIVE_ROOT;
toscaNodeType.setDerived_from(derivedFrom);
}
return toscaNodeType;
}
Map<String, ComponentInstance> 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;
}
componentParametersView.disableAll();
componentParametersView.setIgnoreInterfaces(false);
Either<Component, StorageOperationStatus> 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<Map<String, InterfaceDefinition>, StorageOperationStatus> lifecycleTypeEither =
- interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(serviceComponent.getModel());
+ 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<String> 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<String, Object> localInterfaceTypes = addInterfaceTypeElement(serviceComponent,
- allGlobalInterfaceTypes);
+ Map<String, Object> localInterfaceTypes = interfacesOperationsConverter.addInterfaceTypeElement(serviceComponent,
+ allGlobalInterfaceTypes);
if (MapUtils.isNotEmpty(localInterfaceTypes)) {
proxyInterfaceTypes.putAll(localInterfaceTypes);
}
}
Map<String, ComponentInstance> serviceProxyInstanceList = new HashMap<>();
List<ComponentInstance> 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);
return res;
}
Either<Resource, StorageOperationStatus> 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();
componentParametersView.setIgnoreInterfaces(false);
componentParametersView.setIgnoreRequirements(false);
Either<Component, StorageOperationStatus> 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);
}
return;
}
final List<ComponentInstance> 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<String, ToscaNodeType> 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);
}
}
}
String derivedFrom = ((Resource) origComponent).getToscaResourceName();
toscaNodeType.setDerived_from(derivedFrom);
- Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypesEither = applicationDataTypeCache.getAll(origComponent.getModel());
+ Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> dataTypesEither = applicationDataTypeCache.getAll(
+ origComponent.getModel());
if (dataTypesEither.isRight()) {
log.debug("Failed to retrieve all data types {}", dataTypesEither.right().value());
}
Map<String, DataTypeDefinition> dataTypes = dataTypesEither.left().value();
Map<String, ToscaCapability> capabilities = this.capabilityRequirementConverter
- .convertProxyCapabilities(componentCache, componentInstance, dataTypes);
+ .convertProxyCapabilities(componentCache, componentInstance, dataTypes);
if (MapUtils.isNotEmpty(capabilities)) {
toscaNodeType.setCapabilities(capabilities);
}
List<Map<String, ToscaRequirement>> proxyNodeTypeRequirements = this.capabilityRequirementConverter
- .convertProxyRequirements(componentCache, componentInstance);
+ .convertProxyRequirements(componentCache, componentInstance);
if (CollectionUtils.isNotEmpty(proxyNodeTypeRequirements)) {
toscaNodeType.setRequirements(proxyNodeTypeRequirements);
}
interfaceMap = proxyInterfaces.get();
}
} else {
- interfaceMap = interfacesOperationsConverter
- .getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false, false);
+ interfaceMap = interfacesOperationsConverter.getInterfacesMapFromComponentInstance(proxyComponent, componentInstance, dataTypes, false);
}
interfacesOperationsConverter.removeInterfacesWithoutOperations(interfaceMap);
Map<String, Component> componentCache) {
final List<RequirementCapabilityRelDef> requirementDefinitionList = filterRequirements(componentInstance,
- relations);
+ relations);
if (isNotEmpty(requirementDefinitionList)) {
try {
- final List<Map<String, ToscaTemplateRequirement>> toscaRequirements = buildRequirements(component, componentInstance, requirementDefinitionList, originComponent, componentCache);
- if (!toscaRequirements.isEmpty()) {
+ final List<Map<String, ToscaTemplateRequirement>> 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);
}
}
final List<RequirementCapabilityRelDef> filteredRelations,
final Component originComponent,
final Map<String, Component> componentCache)
- throws ToscaExportException {
+ throws ToscaExportException {
final List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
for (RequirementCapabilityRelDef relationshipDefinition : filteredRelations) {
final Map<String, ToscaTemplateRequirement> 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;
private List<RequirementCapabilityRelDef> filterRequirements(ComponentInstance componentInstance,
List<RequirementCapabilityRelDef> 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<String, ToscaTemplateRequirement> buildRequirement(final ComponentInstance fromInstance,
final List<ComponentInstance> instancesList,
final RequirementCapabilityRelDef relationshipDefinition,
final Map<String, Component> componentCache)
- throws ToscaExportException {
+ throws ToscaExportException {
final Map<String, List<RequirementDefinition>> 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<RequirementDefinition> reqOpt =
- findRequirement(fromOriginComponent, reqMap, relationshipInfo, fromInstance.getUniqueId());
+ final Optional<RequirementDefinition> 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);
filter.setIgnoreCapabilities(false);
filter.setIgnoreGroups(false);
final Either<Component, StorageOperationStatus> 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<CapabilityDefinition> 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<CapabilityDefinition> findCapability(RelationshipInfo reqAndRelationshipPair,
Component toOriginComponent, Component fromOriginComponent,
RequirementDefinition requirement) {
Optional<CapabilityDefinition> 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;
}
final CapabilityRequirementRelationship capabilityRequirementRelationship,
final ComponentInstance toInstance,
final Map<String, Component> componentCache)
- throws ToscaExportException {
+ throws ToscaExportException {
List<String> 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<String, Boolean> capabilityNameEither = capabilityRequirementConverter.buildSubstitutedName(componentCache,
- toOriginComponent, reducedPath, relationshipInfo.getCapability(), capability.getPreviousName(), capability.getExternalName());
+ 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<String, Boolean> requirementNameEither = capabilityRequirementConverter
- .buildSubstitutedName(componentCache, fromOriginComponent,
- requirement.getPath(), relationshipInfo.getRequirement(), requirement.getPreviousName(), requirement.getExternalName());
+ .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);
}
Map<String, List<RequirementDefinition>> reqMap,
RelationshipInfo reqAndRelationshipPair,
String fromInstanceId) {
- for (List<RequirementDefinition> reqList : reqMap.values()) {
- Optional<RequirementDefinition> reqOpt = reqList.stream().filter(
- r -> isRequirementBelongToRelation(fromOriginComponent, reqAndRelationshipPair, r, fromInstanceId))
- .findFirst();
+ for (final List<RequirementDefinition> reqList : reqMap.values()) {
+ final Optional<RequirementDefinition> reqOpt = reqList.stream()
+ .filter(r -> isRequirementBelongToRelation(fromOriginComponent, reqAndRelationshipPair, r, fromInstanceId)).findFirst();
if (reqOpt.isPresent()) {
return reqOpt;
}
*/
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) {
private Either<Map<String, String[]>, ToscaError> convertSubstitutionMappingCapabilities(final Component component,
final Map<String, Component> componentCache) {
Either<Map<String, String[]>, ToscaError> toscaCapabilitiesRes =
- capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component);
+ capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component);
if (toscaCapabilitiesRes.isRight()) {
log.debug("Failed convert capabilities for the component {}. ", component.getName());
return Either.right(toscaCapabilitiesRes.right().value());
}
NodeFilter nodeFilter = new NodeFilter();
ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> origCapabilities = inNodeFilter.getCapabilities();
- ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> origProperties = inNodeFilter.getProperties();
+ ListDataDefinition<PropertyFilterDataDefinition> origProperties = inNodeFilter.getProperties();
List<Map<String, CapabilityFilter>> capabilitiesCopy = new ArrayList<>();
- List<Map<String, List<Object>>> propertiesCopy = new ArrayList<>();
copyNodeFilterCapabilitiesTemplate(origCapabilities, capabilitiesCopy);
- copyNodeFilterProperties(origProperties, propertiesCopy);
if (CollectionUtils.isNotEmpty(capabilitiesCopy)) {
nodeFilter.setCapabilities(capabilitiesCopy);
}
+ final List<Map<String, List<Object>>> propertiesCopy = copyNodeFilterProperties(origProperties);
if (CollectionUtils.isNotEmpty(propertiesCopy)) {
nodeFilter.setProperties(propertiesCopy);
}
return null;
}
NodeFilter nodeFilter = new NodeFilter();
- ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> origProperties = substitutionFilterDataDefinition.getProperties();
- List<Map<String, List<Object>>> propertiesCopy = new ArrayList<>();
- copySubstitutionFilterProperties(origProperties, propertiesCopy);
- if (CollectionUtils.isNotEmpty(propertiesCopy)) {
+ final List<Map<String, List<Object>>> propertiesCopy = copySubstitutionPropertiesFilter(substitutionFilterDataDefinition.getProperties());
+ if (!propertiesCopy.isEmpty()) {
nodeFilter.setProperties(propertiesCopy);
}
nodeFilter.setTosca_id(cloneToscaId(substitutionFilterDataDefinition.getTosca_id()));
private void copyNodeFilterCapabilitiesTemplate(ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> origCapabilities,
List<Map<String, CapabilityFilter>> capabilitiesCopy) {
if (origCapabilities == null || origCapabilities.getListToscaDataDefinition() == null || origCapabilities.getListToscaDataDefinition()
- .isEmpty()) {
+ .isEmpty()) {
return;
}
for (RequirementNodeFilterCapabilityDataDefinition capability : origCapabilities.getListToscaDataDefinition()) {
Map<String, CapabilityFilter> capabilityFilterCopyMap = new HashMap<>();
- CapabilityFilter capabilityFilter = new CapabilityFilter();
- List<Map<String, List<Object>>> 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<RequirementNodeFilterPropertyDataDefinition> origProperties,
- List<Map<String, List<Object>>> propertiesCopy) {
+ private List<Map<String, List<Object>>> copyNodeFilterProperties(final ListDataDefinition<PropertyFilterDataDefinition> origProperties) {
if (origProperties == null || origProperties.getListToscaDataDefinition() == null || origProperties.isEmpty()) {
- return;
+ return Collections.emptyList();
}
- Map<String, List<Object>> propertyMapCopy = new HashMap<>();
- for (RequirementNodeFilterPropertyDataDefinition propertyDataDefinition : origProperties.getListToscaDataDefinition()) {
- for (String propertyInfoEntry : propertyDataDefinition.getConstraints()) {
- Map<String, List<Object>> 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<Object> propsList = new ArrayList<>();
- addPropertyConstraintValueToList(propertyName, propertyValObj, propsList);
- propertyMapCopy.put(propertyName, propsList);
- } else {
- propertyMapCopy.putAll(propertyValObj);
+ List<Map<String, List<Object>>> propertiesCopy = new ArrayList<>();
+ Map<String, List<Object>> 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<RequirementSubstitutionFilterPropertyDataDefinition> origProperties,
- final List<Map<String, List<Object>>> propertiesCopy) {
+ private List<Map<String, List<Object>>> copySubstitutionPropertiesFilter(
+ final ListDataDefinition<SubstitutionFilterPropertyDataDefinition> origProperties) {
+
if (origProperties == null || origProperties.getListToscaDataDefinition() == null || origProperties.isEmpty()) {
- return;
+ return Collections.emptyList();
}
- final Map<String, List<Object>> propertyMapCopy = new HashMap<>();
- for (final RequirementSubstitutionFilterPropertyDataDefinition propertyDataDefinition : origProperties.getListToscaDataDefinition()) {
- for (final String propertyInfoEntry : propertyDataDefinition.getConstraints()) {
- final Map<String, List<Object>> 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<Object> propsList = new ArrayList<>();
- addPropertyConstraintValueToList(propertyName, propertyValObj, propsList);
- propertyMapCopy.put(propertyName, propsList);
- } else {
- propertyMapCopy.putAll(propertyValObj);
+ List<Map<String, List<Object>>> propertiesCopy = new ArrayList<>();
+ Map<String, List<Object>> 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<String, List<Object>> propertyValObj, List<Object> 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<Object> 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<Map<String, List<Object>>> propertiesCopy, Entry<String, List<Object>> entry) {
- Map<String, List<Object>> 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<String, String[]> 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<String, String[]> propertyMapping = new HashMap<>();
+ List<InputDefinition> propertyMappedInputList = component.getInputs().stream().filter(InputDefinition::isMappedToComponentProperty).collect(
+ Collectors.toList());
+
+ if (CollectionUtils.isNotEmpty(propertyMappedInputList)) {
+ propertyMappedInputList.forEach(inputDefinition -> {
+ if (StringUtils.isNotEmpty(inputDefinition.getPropertyId())) {
+ Optional<PropertyDefinition> 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<String, String[]> buildSubstitutionMappingAttributesMapping(final Component component) {
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<Map<String, ToscaProperty>> getProxyNodeTypeProperties(Component proxyComponent, Map<String, DataTypeDefinition> dataTypes) {
+ private Optional<Map<String, ToscaProperty>> getProxyNodeTypeProperties(Component proxyComponent, Map<String, DataTypeDefinition> dataTypes) {
if (Objects.isNull(proxyComponent)) {
return Optional.empty();
}
- Map<String, ToscaProperty> 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<String, DataTypeDefinition> dataTypes, List<InputDefinition> componentInputs,
- Map<String, ToscaProperty> mergedProperties) {
+ private Map<String, ToscaProperty> convertInputsToProperties(Map<String, DataTypeDefinition> dataTypes, List<InputDefinition> 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<Map<String, Object>> getProxyNodeTypeInterfaces(Component proxyComponent, Map<String, DataTypeDefinition> dataTypes) {
+ private Optional<Map<String, Object>> getProxyNodeTypeInterfaces(Component proxyComponent, Map<String, DataTypeDefinition> dataTypes) {
if (Objects.isNull(proxyComponent) || MapUtils.isEmpty(proxyComponent.getInterfaces())) {
return Optional.empty();
}
// 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 {
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())) {
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);
return false;
}
final List<String> functionList = Arrays
- .asList(GET_ATTRIBUTE.getFunctionName(), GET_INPUT.getFunctionName(), GET_PROPERTY.getFunctionName());
+ .asList(GET_ATTRIBUTE.getFunctionName(), GET_INPUT.getFunctionName(), GET_PROPERTY.getFunctionName());
final Optional<String> 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;
}
}
}
- private Configuration getConfiguration() {
- return ConfigurationManager.getConfigurationManager().getConfiguration();
- }
-
}