import java.util.Optional;
import java.util.stream.Collectors;
import org.apache.commons.collections.MapUtils;
+import org.apache.commons.lang3.StringUtils;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
}
public Either<TopologyTemplate, StorageOperationStatus> createTopologyTemplate(TopologyTemplate topologyTemplate) {
- topologyTemplate.generateUUID();
+ if (topologyTemplate.getUUID() == null) {
+ topologyTemplate.generateUUID();
+ }
topologyTemplate = getResourceMetaDataFromResource(topologyTemplate);
String resourceUniqueId = topologyTemplate.getUniqueId();
if (resourceUniqueId == null) {
return Either.right(associateInstProperties);
}
StorageOperationStatus associateInstInputs = associateInstInputsToComponent(topologyTemplateVertex, topologyTemplate);
- if (associateInstProperties != StorageOperationStatus.OK) {
+ if (associateInstInputs != StorageOperationStatus.OK) {
return Either.right(associateInstInputs);
}
StorageOperationStatus associateInstGroups = associateInstGroupsToComponent(topologyTemplateVertex, topologyTemplate);
return Either.right(associateInterfaces);
}
StorageOperationStatus associatePathProperties = associateForwardingPathToResource(topologyTemplateVertex, topologyTemplate);
- if (associateCapProperties != StorageOperationStatus.OK) {
+ if (associatePathProperties != StorageOperationStatus.OK) {
return Either.right(associatePathProperties);
}
+ StorageOperationStatus associateNodeFilterToComponent = associateNodeFilterToComponent(topologyTemplateVertex, topologyTemplate);
+ if (associateNodeFilterToComponent != StorageOperationStatus.OK) {
+ return Either.right(associateNodeFilterToComponent);
+ }
final StorageOperationStatus associateServiceToModel = associateComponentToModel(topologyTemplateVertex, topologyTemplate,
EdgeLabelEnum.MODEL);
if (associateServiceToModel != StorageOperationStatus.OK) {
}
private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) {
- return associatePoliciesToComponent(nodeTypeVertex, topologyTemplate.getPolicies());
- }
-
- private StorageOperationStatus associatePoliciesToComponent(GraphVertex nodeTypeVertex, Map<String, PolicyDataDefinition> policies) {
+ Map<String, PolicyDataDefinition> policies = topologyTemplate.getPolicies();
if (policies != null && !policies.isEmpty()) {
policies.values().stream().filter(p -> p.getUniqueId() == null).forEach(p -> {
String uid = UniqueIdBuilder.buildGroupingUid(nodeTypeVertex.getUniqueId(), p.getName());
return StorageOperationStatus.OK;
}
+ public StorageOperationStatus associateInstInterfacesToComponent(
+ GraphVertex nodeTypeVertex,
+ Map<String, MapInterfaceDataDefinition> instInterfaces
+ ) {
+ if (instInterfaces != null && !instInterfaces.isEmpty()) {
+ Either<GraphVertex, StorageOperationStatus> associateElementToData = associateElementToData(
+ nodeTypeVertex,
+ VertexTypeEnum.INST_INTERFACES,
+ EdgeLabelEnum.INST_INTERFACES,
+ instInterfaces);
+ if (associateElementToData.isRight()) {
+ return associateElementToData.right().value();
+ }
+ }
+ return StorageOperationStatus.OK;
+ }
+
public StorageOperationStatus associateInstGroupsToComponent(GraphVertex nodeTypeVertex, Map<String, MapGroupsDataDefinition> instGroups) {
if (instGroups != null && !instGroups.isEmpty()) {
Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex, VertexTypeEnum.INST_GROUPS,
return StorageOperationStatus.OK;
}
- public StorageOperationStatus deleteInstInputsToComponent(GraphVertex nodeTypeVertex, Map<String, MapPropertiesDataDefinition> instInputs) {
- if (instInputs != null && !instInputs.isEmpty()) {
- instInputs.entrySet().forEach(i -> {
- List<String> uniqueKeys = new ArrayList<>(i.getValue().getMapToscaDataDefinition().keySet());
- List<String> pathKeys = new ArrayList<>();
- pathKeys.add(i.getKey());
- StorageOperationStatus status = deleteToscaDataDeepElements(nodeTypeVertex, EdgeLabelEnum.INST_INPUTS, VertexTypeEnum.INST_INPUTS,
- uniqueKeys, pathKeys, JsonPresentationFields.NAME);
- if (status != StorageOperationStatus.OK) {
- return;
- }
- });
- }
- return StorageOperationStatus.OK;
- }
-
- public StorageOperationStatus addInstPropertiesToComponent(GraphVertex nodeTypeVertex, Map<String, MapPropertiesDataDefinition> instInputs) {
- if (instInputs != null && !instInputs.isEmpty()) {
- instInputs.entrySet().forEach(i -> {
- StorageOperationStatus status = addToscaDataDeepElementsBlockToToscaElement(nodeTypeVertex, EdgeLabelEnum.INST_PROPERTIES,
- VertexTypeEnum.INST_PROPERTIES, i.getValue(), i.getKey());
- if (status != StorageOperationStatus.OK) {
- return;
- }
- });
- }
- return StorageOperationStatus.OK;
- }
-
- public StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapArtifactDataDefinition> instArtifacts) {
+ protected StorageOperationStatus associateInstDeploymentArtifactsToComponent(GraphVertex nodeTypeVertex,
+ Map<String, MapArtifactDataDefinition> instArtifacts) {
return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INST_DEPLOYMENT_ARTIFACTS,
EdgeLabelEnum.INST_DEPLOYMENT_ARTIFACTS);
}
public StorageOperationStatus associateInstArtifactsToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapArtifactDataDefinition> instArtifacts) {
+ Map<String, MapArtifactDataDefinition> instArtifacts) {
return associateInstanceArtifactsToComponent(nodeTypeVertex, instArtifacts, VertexTypeEnum.INSTANCE_ARTIFACTS,
EdgeLabelEnum.INSTANCE_ARTIFACTS);
}
}
public StorageOperationStatus associateOrAddCalcCapReqToComponent(GraphVertex nodeTypeVertex,
- Map<String, MapListRequirementDataDefinition> calcRequirements,
- Map<String, MapListCapabilityDataDefinition> calcCapabilty,
- Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
+ Map<String, MapListRequirementDataDefinition> calcRequirements,
+ Map<String, MapListCapabilityDataDefinition> calcCapabilty,
+ Map<String, MapCapabilityProperty> calculatedCapabilitiesProperties) {
if (!MapUtils.isEmpty(calcRequirements)) {
Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateOrAddElementToData(nodeTypeVertex,
VertexTypeEnum.CALCULATED_REQUIREMENTS, EdgeLabelEnum.CALCULATED_REQUIREMENTS, calcRequirements);
}
public StorageOperationStatus associateForwardingPathToComponent(GraphVertex nodeTypeVertex,
- Map<String, ForwardingPathDataDefinition> forwardingPathMap) {
+ Map<String, ForwardingPathDataDefinition> forwardingPathMap) {
if (forwardingPathMap != null && !forwardingPathMap.isEmpty()) {
Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(nodeTypeVertex,
VertexTypeEnum.FORWARDING_PATH, EdgeLabelEnum.FORWARDING_PATH, forwardingPathMap);
return StorageOperationStatus.OK;
}
+ public StorageOperationStatus associateOutputsToComponent(final GraphVertex nodeTypeVertex,
+ final Map<String, ? extends AttributeDataDefinition> outputs,
+ final String id) {
+ if (MapUtils.isNotEmpty(outputs)) {
+ outputs.values().stream().filter(e -> e.getUniqueId() == null)
+ .forEach(e -> e.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(id, e.getName())));
+ final Either<GraphVertex, StorageOperationStatus> associateElementToData
+ = associateElementToData(nodeTypeVertex, VertexTypeEnum.OUTPUTS, EdgeLabelEnum.OUTPUTS, outputs);
+ if (associateElementToData.isRight()) {
+ return associateElementToData.right().value();
+ }
+ }
+ return StorageOperationStatus.OK;
+ }
+
private GraphVertex fillMetadata(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate, JsonParseFlagEnum flag) {
nodeTypeVertex.setLabel(VertexTypeEnum.TOPOLOGY_TEMPLATE);
fillCommonMetadata(nodeTypeVertex, topologyTemplate);
private StorageOperationStatus associateServiceMetadataToCategory(GraphVertex nodeTypeVertex, TopologyTemplate topologyTemplate) {
String categoryName = topologyTemplate.getCategories().get(0).getName();
- Either<GraphVertex, StorageOperationStatus> category = categoryOperation.getCategory(categoryName, VertexTypeEnum.SERVICE_CATEGORY);
+ Either<GraphVertex, StorageOperationStatus> category = categoryOperation.getCategory(categoryName,
+ VertexTypeEnum.SERVICE_CATEGORY);
if (category.isRight()) {
log.trace("NO category {} for service {}", categoryName, topologyTemplate.getUniqueId());
return StorageOperationStatus.CATEGORY_NOT_FOUND;
return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus));
}
}
- if (!componentParametersView.isIgnoreInterfaces()) {
- JanusGraphOperationStatus storageStatus = setInterfcesFromGraph(componentV, toscaElement);
- if (storageStatus != JanusGraphOperationStatus.OK) {
- return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(storageStatus));
- }
- }
if (!componentParametersView.isIgnoreComponentInstancesInterfaces()) {
JanusGraphOperationStatus storageStatus = setComponentInstancesInterfacesFromGraph(componentV, toscaElement);
if (storageStatus != JanusGraphOperationStatus.OK) {
return JanusGraphOperationStatus.OK;
}
- private JanusGraphOperationStatus setInterfcesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) {
- Either<Map<String, InterfaceDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.INTERFACE);
- if (result.isLeft()) {
- topologyTemplate.setInterfaces(result.left().value());
- } else {
- if (result.right().value() != JanusGraphOperationStatus.NOT_FOUND) {
- return result.right().value();
- }
- }
- return JanusGraphOperationStatus.OK;
- }
-
private JanusGraphOperationStatus setPoliciesFromGraph(GraphVertex componentV, TopologyTemplate toscaElement) {
Either<Map<String, PolicyDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV, EdgeLabelEnum.POLICIES);
if (result.isLeft()) {
return StorageOperationStatus.OK;
}
+ private StorageOperationStatus associateNodeFilterToComponent(GraphVertex topologyTemplateVertex, TopologyTemplate topologyTemplate) {
+ Map<String, CINodeFilterDataDefinition> nodeFilterComponents = topologyTemplate.getNodeFilterComponents();
+ if (MapUtils.isNotEmpty(nodeFilterComponents)) {
+ Either<GraphVertex, StorageOperationStatus> assosiateElementToData = associateElementToData(topologyTemplateVertex,
+ VertexTypeEnum.INTERFACE, EdgeLabelEnum.NODE_FILTER_TEMPLATE, nodeFilterComponents);
+ if (assosiateElementToData.isRight()) {
+ return assosiateElementToData.right().value();
+ }
+ }
+ return StorageOperationStatus.OK;
+ }
+
private JanusGraphOperationStatus setForwardingGraphPropertiesFromGraph(GraphVertex componentV, TopologyTemplate topologyTemplate) {
Either<Map<String, ForwardingPathDataDefinition>, JanusGraphOperationStatus> result = getDataFromGraph(componentV,
EdgeLabelEnum.FORWARDING_PATH);
if (MapUtils.isEmpty(filters)) {
return JanusGraphOperationStatus.OK;
}
- if(filters.values().size() > 1) {
+ if (filters.values().size() > 1) {
log.error(EcompLoggerErrorCode.DATA_ERROR, TopologyTemplateOperation.class.getName(),
(ErrorLogOptionalData) null, "Only a single substitution filter is expected, but got '{}'", filters.values().size());
return JanusGraphOperationStatus.GENERAL_ERROR;
category.setUniqueId(categoryV.getUniqueId());
category.setNormalizedName((String) metadataProperties.get(GraphPropertyEnum.NORMALIZED_NAME));
category.setName((String) metadataProperties.get(GraphPropertyEnum.NAME));
- final Boolean useServiceSubstitutionForNestedServices = (Boolean) metadataProperties
- .get(GraphPropertyEnum.USE_SUBSTITUTION_FOR_NESTED_SERVICES);
+ final Object useServiceSubstitutionForNestedServices = metadataProperties.get(GraphPropertyEnum.USE_SUBSTITUTION_FOR_NESTED_SERVICES);
category.setUseServiceSubstitutionForNestedServices(
- useServiceSubstitutionForNestedServices == null ? false : useServiceSubstitutionForNestedServices);
+ useServiceSubstitutionForNestedServices != null && (boolean) useServiceSubstitutionForNestedServices);
Type listTypeCat = new TypeToken<List<String>>() {
}.getType();
- List<String> iconsfromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS.getProperty()), listTypeCat);
- category.setIcons(iconsfromJsonCat);
+ category.setNotApplicableMetadataKeys(
+ (getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.NOT_APPLICABLE_METADATA_KEYS.getProperty()), listTypeCat)));
+ List<String> iconsFromJsonCat = getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.ICONS.getProperty()), listTypeCat);
+ category.setIcons(iconsFromJsonCat);
+ category.setModels((getGson().fromJson((String) metadataProperties.get(GraphPropertyEnum.MODEL.getProperty()), listTypeCat)));
final Type metadataKeysTypeCat = new TypeToken<List<MetadataKeyDataDefinition>>() {
}.getType();
final List<MetadataKeyDataDefinition> metadataKeysfromJsonCat = getGson()
log.debug("Failed to disassociate instances interfaces for {} error {}", toscaElementVertex.getUniqueId(), status);
return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
}
+ status = janusGraphDao.disassociateAndDeleteLast(toscaElementVertex, Direction.OUT, EdgeLabelEnum.NODE_FILTER_TEMPLATE);
+ if (status != JanusGraphOperationStatus.OK) {
+ log.debug("Failed to disassociate capabilities for {} error {}", toscaElementVertex.getUniqueId(), status);
+ return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
+ }
+
toscaElementVertex.getVertex().remove();
log.trace("Tosca element vertex for {} was removed", toscaElementVertex.getUniqueId());
return nodeType;
}
public Either<GraphVertex, StorageOperationStatus> updateDistributionStatus(String uniqueId, User user,
- DistributionStatusEnum distributionStatus) {
+ DistributionStatusEnum distributionStatus) {
Either<GraphVertex, StorageOperationStatus> result = null;
String userId = user.getUserId();
Either<GraphVertex, JanusGraphOperationStatus> getRes = findUserVertex(userId);
* @return
*/
public Either<List<ComponentInstanceProperty>, StorageOperationStatus> getComponentInstanceCapabilityProperties(String componentId,
- String instanceId,
- String capabilityName,
- String capabilityType,
- String ownerId) {
+ String instanceId,
+ String capabilityName,
+ String capabilityType,
+ String ownerId) {
Either<List<ComponentInstanceProperty>, StorageOperationStatus> result = null;
Map<String, MapCapabilityProperty> mapPropertiesDataDefinition = null;
Either<GraphVertex, StorageOperationStatus> componentByLabelAndId = getComponentByLabelAndId(componentId,
}
public StorageOperationStatus updateComponentInstanceCapabilityProperties(Component containerComponent, String componentInstanceId,
- MapCapabilityProperty instanceProperties) {
+ MapCapabilityProperty instanceProperties) {
return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.CALCULATED_CAP_PROPERTIES,
instanceProperties, componentInstanceId);
}
public StorageOperationStatus updateComponentInstanceInterfaces(Component containerComponent, String componentInstanceId,
- MapInterfaceDataDefinition instanceInterfaces) {
+ MapInterfaceDataDefinition instanceInterfaces) {
if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) {
return updateToscaDataDeepElementsBlockToToscaElement(containerComponent.getUniqueId(), EdgeLabelEnum.INST_INTERFACES, instanceInterfaces,
componentInstanceId);
return StorageOperationStatus.OK;
}
+
+ public StorageOperationStatus updateComponentInterfaces(final String componentId, final MapInterfaceDataDefinition instanceInterfaces,
+ final String componentInterfaceUpdatedKey) {
+ if (MapUtils.isNotEmpty(instanceInterfaces.getMapToscaDataDefinition())) {
+ return updateToscaDataDeepElementsBlockToToscaElement(componentId, EdgeLabelEnum.INTERFACE_ARTIFACTS, instanceInterfaces,
+ componentInterfaceUpdatedKey);
+ }
+ return StorageOperationStatus.OK;
+ }
+
private boolean isNotEmptyMapOfProperties(String instanceId, Map<String, MapCapabilityProperty> mapPropertiesDataDefinition) {
return MapUtils.isNotEmpty(mapPropertiesDataDefinition) && instanceId != null && mapPropertiesDataDefinition.get(instanceId) != null
&& MapUtils.isNotEmpty(mapPropertiesDataDefinition.get(instanceId).getMapToscaDataDefinition());
}
public StorageOperationStatus removePolicyFromToscaElement(GraphVertex componentV, String policyId) {
- return deleteToscaDataElement(componentV, EdgeLabelEnum.POLICIES, VertexTypeEnum.POLICIES, policyId, JsonPresentationFields.UNIQUE_ID);
+ return deleteToscaDataElement(componentV, EdgeLabelEnum.POLICIES, policyId);
}
public StorageOperationStatus updateGroupOfToscaElement(GraphVertex componentV, GroupDefinition groupDefinition) {
}
private void fillPolicyDefinition(GraphVertex componentV, PolicyDefinition policyDefinition, int counter) {
- String policyName = buildSubComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME),
- policyDefinition.getPolicyTypeName(), counter);
- policyDefinition.setName(policyName);
+ String policyName = policyDefinition.getName();
+ if (StringUtils.isBlank(policyName)) {
+ policyName = buildSubComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME),
+ policyDefinition.getPolicyTypeName(), counter);
+ policyDefinition.setName(policyName);
+ }
policyDefinition.setInvariantName(policyName);
policyDefinition.setComponentName((String) componentV.getJsonMetadataField(JsonPresentationFields.NAME));
policyDefinition.setUniqueId(UniqueIdBuilder.buildPolicyUniqueId(componentV.getUniqueId(), policyName));
policyDefinition.setPolicyUUID(UniqueIdBuilder.generateUUID());
}
- void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) {
+ protected void revertNamesOfCalculatedCapabilitiesRequirements(String componentId, TopologyTemplate toscaElement) {
if (MapUtils.isNotEmpty(toscaElement.getComponentInstances()) || MapUtils.isNotEmpty(toscaElement.getGroups())) {
GraphVertex toscaElementV = janusGraphDao.getVertexById(componentId, JsonParseFlagEnum.NoParse).left().on(this::throwStorageException);
if (MapUtils.isNotEmpty(toscaElement.getComponentInstances())) {
Code Review / sdc.git / blobdiff