import java.util.List;
import java.util.Map;
import java.util.Set;
+
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
import org.openecomp.sdc.be.components.impl.ImportUtils;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.category.CategoryDefinition;
import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.utils.TypeUtils;
import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
+import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.yaml.snakeyaml.Yaml;
private static final Logger log = Logger.getLogger(ServiceCsarInfo.class);
private final Map<String, Map<String, Object>> mainTemplateImports;
private List<NodeTypeDefinition> nodeTypeDefinitions;
+ private final String model;
+ private final ModelOperation modelOperation;
- public ServiceCsarInfo(final User modifier, final String csarUUID, final Map<String, byte[]> csar, final String vfResourceName,
- final String mainTemplateName, final String mainTemplateContent, final boolean isUpdate) {
+ public ServiceCsarInfo(final User modifier, final String csarUUID, final Map<String, byte[]> csar,
+ final String vfResourceName, final String model,
+ final String mainTemplateName, final String mainTemplateContent, final boolean isUpdate, final ModelOperation modelOperation) {
super(modifier, csarUUID, csar, vfResourceName, mainTemplateName, mainTemplateContent, isUpdate);
-
+ this.model = model;
+ this.modelOperation = modelOperation;
final Path mainTemplateDir = Paths.get(getMainTemplateName().substring(0, getMainTemplateName().lastIndexOf('/') + 1));
final Collection<Path> filesHandled = new HashSet<>();
filesHandled.add(Paths.get(mainTemplateName));
final List<Path> importFilePaths = getTemplateImportFilePaths(mappedToscaMainTemplate, fileParentDir);
importFilePaths.stream().filter(path -> !filesHandled.contains(path)).forEach(
- importFilePath -> {
- byte[] importFile = csar.get(importFilePath.toString());
- if (importFile != null) {
- filesHandled.add(importFilePath);
- Map<String, Object> mappedImportFile = new Yaml().load(new String(csar.get(importFilePath.toString())));
- templateImports.put(importFilePath.toString(), mappedImportFile);
- templateImports.putAll(getTemplateImports(csar, mappedImportFile, importFilePath.getParent(), filesHandled));
- } else {
- log.info("Import {} cannot be found in CSAR", importFilePath.toString());
- }
- });
+ importFilePath -> {
+ final String importFilePathString = importFilePath.toString();
+ final byte[] importFile = csar.get(importFilePathString);
+ if (importFile != null) {
+ filesHandled.add(importFilePath);
+ final Map<String, Object> mappedImportFile = new Yaml().load(new String(importFile));
+ templateImports.put(importFilePathString, mappedImportFile);
+ templateImports.putAll(getTemplateImports(csar, mappedImportFile, importFilePath.getParent(), filesHandled));
+ } else {
+ log.warn("Import {} cannot be found in CSAR", importFilePathString);
+ }
+ });
return templateImports;
}
if (CollectionUtils.isNotEmpty(importsList)) {
if (importsList.get(0) instanceof String) {
List<Path> importPaths = new ArrayList<>();
- importsList.stream()
- .forEach(importPath -> importPaths.add(fileParentDir == null ? Paths.get((String) importPath) : fileParentDir.resolve(Paths.get((String) importPath)).normalize()));
+ importsList.forEach(
+ importPath -> {
+ final Path path = fileParentDir == null ?
+ Paths.get((String) importPath) : fileParentDir.resolve(Paths.get((String) importPath)).normalize();
+ importPaths.add(path);
+ });
return importPaths;
} else if (importsList.get(0) instanceof Map) {
return getTemplateImportFilePathsMultiLineGrammar(importsList, fileParentDir);
@Override
public Map<String, Object> getDataTypes() {
- final Map<String, Object> definitions = new HashMap<>();
- mainTemplateImports.entrySet().stream()
- .forEach(entry -> definitions.putAll(getTypesFromTemplate(entry.getValue(), TypeUtils.ToscaTagNamesEnum.DATA_TYPES)));
- definitions.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), TypeUtils.ToscaTagNamesEnum.DATA_TYPES));
- return definitions;
+ return getTypes(ToscaTagNamesEnum.DATA_TYPES);
+ }
+
+ @Override
+ public Map<String, Object> getGroupTypes() {
+ return getTypes(ToscaTagNamesEnum.GROUP_TYPES);
+ }
+
+ @Override
+ public Map<String, Object> getCapabilityTypes() {
+ return getTypes(ToscaTagNamesEnum.CAPABILITY_TYPES);
}
+ @Override
public Map<String, Object> getArtifactTypes() {
- final Map<String, Object> artifactsTypes = new HashMap<>();
- mainTemplateImports.entrySet().stream()
- .forEach(entry -> artifactsTypes.putAll(getTypesFromTemplate(entry.getValue(), TypeUtils.ToscaTagNamesEnum.ARTIFACT_TYPES)));
- artifactsTypes.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), TypeUtils.ToscaTagNamesEnum.ARTIFACT_TYPES));
- return artifactsTypes;
+ return getTypes(ToscaTagNamesEnum.ARTIFACT_TYPES);
+ }
+
+ @Override
+ public Map<String, Object> getInterfaceTypes() {
+ return getTypes(ToscaTagNamesEnum.INTERFACE_TYPES);
+ }
+
+ private Map<String, Object> getTypes(ToscaTagNamesEnum toscaTag) {
+ final Map<String, Object> types = new HashMap<>();
+ mainTemplateImports.entrySet().forEach(entry -> types.putAll(getTypesFromTemplate(entry.getValue(), toscaTag)));
+ types.putAll(getTypesFromTemplate(getMappedToscaMainTemplate(), toscaTag));
+ return types;
}
public List<NodeTypeDefinition> getNodeTypesUsed() {
if (nodeTypeDefinitions == null) {
nodeTypeDefinitions = new ArrayList<>();
final Set<String> nodeTypesUsed = getNodeTypesUsedInToscaTemplate(getMappedToscaMainTemplate());
- nodeTypeDefinitions.addAll(getNodeTypeDefinitions(nodeTypesUsed));
+ nodeTypeDefinitions.addAll(getNodeTypeDefinitions(nodeTypesUsed).values());
}
nodeTypeDefinitions = sortNodeTypesByDependencyOrder(nodeTypeDefinitions);
return nodeTypeDefinitions;
for (final String dependencyName : getDependencyTypes(nodeType, nodeTypes)) {
final NodeTypeDefinition dependency = nodeTypeDefinitionsMap.get(dependencyName);
final int indexOfDependency = sortedNodeTypeDefinitions.lastIndexOf(dependency);
- highestDependencyIndex = indexOfDependency > highestDependencyIndex ? indexOfDependency : highestDependencyIndex;
+ highestDependencyIndex = Math.max(indexOfDependency, highestDependencyIndex);
}
sortedNodeTypeDefinitions.add(highestDependencyIndex + 1, nodeType);
nodeTypeDefinitionsMap.put(nodeType.getMappedNodeType().getKey(), nodeType);
return dependencies;
}
- private Set<NodeTypeDefinition> getNodeTypeDefinitions(final Set<String> nodeTypesToGet) {
- final Set<NodeTypeDefinition> nodeTypesToReturn = new HashSet<>();
- final Set<NodeTypeDefinition> foundNodeTypes = getTypes(nodeTypesToGet);
- nodeTypesToReturn.addAll(foundNodeTypes);
+ private Map<String, NodeTypeDefinition> getNodeTypeDefinitions(final Set<String> nodeTypesToGet) {
+ final Map<String, NodeTypeDefinition> foundNodeTypes = getTypes(nodeTypesToGet);
+ final Map<String, NodeTypeDefinition> nodeTypesToReturn = new HashMap<>(foundNodeTypes);
final Set<String> recursiveNodeTypesToGet = new HashSet<>();
- foundNodeTypes.stream().forEach(nodeTypeDef -> {
+ foundNodeTypes.values().forEach(nodeTypeDef -> {
Either<Object, ResultStatusEnum> derivedFromTypeEither =
findToscaElement((Map<String, Object>) nodeTypeDef.getMappedNodeType().getValue(), TypeUtils.ToscaTagNamesEnum.DERIVED_FROM,
ToscaElementTypeEnum.STRING);
if (derivedFromTypeEither.isLeft()) {
- recursiveNodeTypesToGet.add((String)derivedFromTypeEither.left().value());
+ recursiveNodeTypesToGet.add((String) derivedFromTypeEither.left().value());
}
});
recursiveNodeTypesToGet.removeAll(nodeTypesToGet);
if (CollectionUtils.isNotEmpty(recursiveNodeTypesToGet)) {
- nodeTypesToReturn.addAll(getNodeTypeDefinitions(recursiveNodeTypesToGet));
+ nodeTypesToReturn.putAll(getNodeTypeDefinitions(recursiveNodeTypesToGet));
}
return nodeTypesToReturn;
}
+ private Map<String, NodeTypeDefinition> getTypes(final Set<String> nodeTypes) {
+ final Map<String, NodeTypeDefinition> nodeTypeDefinitionsMap = new HashMap<>();
+ final Set<String> lowerPrecedenceImports = new HashSet<>();
- private Set<NodeTypeDefinition> getTypes(final Set<String> nodeTypes) {
- Set<NodeTypeDefinition> nodeTypeDefinitionsLocal = new HashSet<>();
- mainTemplateImports.entrySet().forEach(entry -> {
- final Map<String, Object> types = getTypesFromTemplate(entry.getValue(), TypeUtils.ToscaTagNamesEnum.NODE_TYPES, nodeTypes);
- if (MapUtils.isNotEmpty(types)) {
- types.entrySet().stream().forEach(typesEntry -> {
- final NodeTypeMetadata metadata =
- getMetaDataFromTemplate(entry.getValue(), typesEntry.getKey());
- nodeTypeDefinitionsLocal.add(new NodeTypeDefinition(typesEntry, metadata));
- });
- }
- });
- return nodeTypeDefinitionsLocal;
+ if (model != null && !model.equals(Constants.DEFAULT_MODEL_NAME)) {
+ final Set<String> modelImports = new HashSet<>();
+ modelOperation.findAllModelImports(model, true).forEach(modelImport -> modelImports.add("Definitions/" + modelImport.getFullPath()));
+
+ lowerPrecedenceImports.add("Definitions/" + ModelOperation.ADDITIONAL_TYPE_DEFINITIONS_PATH);
+ lowerPrecedenceImports.addAll(modelImports);
+
+ mainTemplateImports.entrySet().stream().filter(entry -> modelImports.contains(entry.getKey()))
+ .forEach(template -> addTypesFromTemplate(nodeTypeDefinitionsMap, template.getValue(), nodeTypes));
+
+ mainTemplateImports.entrySet().stream().filter(entry -> entry.getKey().equals(ModelOperation.ADDITIONAL_TYPE_DEFINITIONS_PATH.toString()))
+ .forEach(template -> addTypesFromTemplate(nodeTypeDefinitionsMap, template.getValue(), nodeTypes));
+ }
+
+ mainTemplateImports.entrySet().stream().filter(entry -> !lowerPrecedenceImports.contains(entry.getKey()))
+ .forEach(template -> addTypesFromTemplate(nodeTypeDefinitionsMap, template.getValue(), nodeTypes));
+
+ return nodeTypeDefinitionsMap;
+ }
+
+ private void addTypesFromTemplate(final Map<String, NodeTypeDefinition> nodeTypeDefinitionsMap, final Map<String, Object> mappedTemplate,
+ final Set<String> nodeTypes) {
+ final Map<String, Object> types = getTypesFromTemplate(mappedTemplate, ToscaTagNamesEnum.NODE_TYPES, nodeTypes);
+ if (MapUtils.isNotEmpty(types)) {
+ types.entrySet().forEach(typesEntry -> {
+ final NodeTypeMetadata metadata = getMetaDataFromTemplate(mappedTemplate, typesEntry.getKey());
+ nodeTypeDefinitionsMap.put(typesEntry.getKey(), new NodeTypeDefinition(typesEntry, metadata));
+ });
+ }
}
@SuppressWarnings("unchecked")
private NodeTypeMetadata getMetaDataFromTemplate(Map<String, Object> mappedResourceTemplate, String nodeTemplateType) {
NodeTypeMetadata nodeTypeMetadata = new NodeTypeMetadata();
- Either<Map<String, Object>, ImportUtils.ResultStatusEnum> metadataEither = ImportUtils.findFirstToscaMapElement(mappedResourceTemplate, TypeUtils.ToscaTagNamesEnum.METADATA);
+ Either<Map<String, Object>, ImportUtils.ResultStatusEnum> metadataEither = ImportUtils.findFirstToscaMapElement(mappedResourceTemplate,
+ TypeUtils.ToscaTagNamesEnum.METADATA);
if (metadataEither.isLeft() && metadataEither.left().value().get("type").equals(ResourceTypeEnum.VFC.getValue())) {
Map<String, Object> metadata = metadataEither.left().value();
createMetadataFromTemplate(nodeTypeMetadata, metadata, nodeTemplateType);
return nodeTypeMetadata;
}
- private void createMetadataFromTemplate(NodeTypeMetadata nodeTypeMetadata, Map<String, Object> metadata, String nodeTemplateType) {
+ private void createMetadataFromTemplate(NodeTypeMetadata nodeTypeMetadata, Map<String, Object> metadata, String nodeTemplateType) {
nodeTypeMetadata.setToscaName(nodeTemplateType);
nodeTypeMetadata.setContactId(getModifier().getUserId());
nodeTypeMetadata.setDescription((String) metadata.get("description"));
nodeTypeMetadata.setResourceType((String) metadata.get("type"));
nodeTypeMetadata.setVendorName((String) metadata.get("resourceVendor"));
nodeTypeMetadata.setVendorRelease(String.valueOf(metadata.get("resourceVendorRelease")));
- nodeTypeMetadata.setModel((String) metadata.get("model"));
+ nodeTypeMetadata.setModel(model);
nodeTypeMetadata.setNormative(false);
}
private NullNodeTypeMetadata createDefaultMetadata(String nodeTemplateType) {
NullNodeTypeMetadata nodeTypeMetadata = new NullNodeTypeMetadata();
nodeTypeMetadata.setToscaName(nodeTemplateType);
+ nodeTypeMetadata.setModel(model);
return nodeTypeMetadata;
}
}
Code Review / sdc.git / blobdiff