import com.fasterxml.jackson.annotation.JsonIgnore;
import org.openecomp.sdc.be.config.ConfigurationManager;
-import org.openecomp.sdc.be.dao.utils.MapUtil;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.model.category.CategoryDefinition;
import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
-import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
-import org.openecomp.sdc.common.api.ArtifactTypeEnum;
-import java.util.stream.Collectors;
import static java.util.Collections.emptyList;
import org.openecomp.sdc.be.dao.utils.MapUtil;
import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import java.io.Serializable;
-import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import org.openecomp.sdc.be.datatypes.elements.*;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
-import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
import java.util.HashMap;
import java.util.Map;
artifactData.setArtifactVersion(String.valueOf(newVersion));
}
- private boolean validateParentType(NodeTypeEnum type) {
- boolean isValid = false;
- switch (type) {
- case Resource:
- case InterfaceOperation:
- case Service:
- case ResourceInstance:
- isValid = true;
- break;
- default:
- log.debug("Not supported node type for artifact relation : {} ", type);
- }
- return isValid;
- }
-
public Either<ArtifactDataDefinition, StorageOperationStatus> removeArtifactOnGraph(ArtifactDefinition artifactFromGraph, String componentId, String instanceId, NodeTypeEnum type, boolean deleteMandatoryArtifact) {
Triple<EdgeLabelEnum, Boolean, VertexTypeEnum> triple = getEdgeLabelEnumFromArtifactGroupType(artifactFromGraph.getArtifactGroupType(), type);
import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
}
- private List<InputDefinition> getNewInputsByResourceType(Resource component) {
- return component.getResourceType().equals(ResourceTypeEnum.CVFC) ?
- component.getInputs() : null;
- }
-
// region - Component Update
/**
*
return Either.left(instProperties);
}
- public StorageOperationStatus deleteComponentInstanceInputsToComponent(Map<String, List<ComponentInstanceInput>> instProperties, String componentId) {
-
- Either<GraphVertex, TitanOperationStatus> getVertexEither = titanDao.getVertexById(componentId, JsonParseFlagEnum.NoParse);
- if (getVertexEither.isRight()) {
- log.debug("Couldn't fetch component with and unique id {}, error: {}", componentId, getVertexEither.right().value());
- return DaoStatusConverter.convertTitanStatusToStorageStatus(getVertexEither.right().value());
-
- }
-
- GraphVertex vertex = getVertexEither.left().value();
- Map<String, MapPropertiesDataDefinition> instPropsMap = new HashMap<>();
- if (instProperties != null) {
-
- MapPropertiesDataDefinition propertiesMap;
- for (Entry<String, List<ComponentInstanceInput>> entry : instProperties.entrySet()) {
- propertiesMap = new MapPropertiesDataDefinition();
-
- propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
-
- instPropsMap.put(entry.getKey(), propertiesMap);
- }
- }
-
- return topologyTemplateOperation.deleteInstInputsToComponent(vertex, instPropsMap);
-
- }
-
public Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> addComponentInstancePropertiesToComponent(Component containerComponent, Map<String, List<ComponentInstanceProperty>> instProperties, String componentId) {
if (instProperties != null) {
import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
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.AdditionalInformationDefinition;
import org.openecomp.sdc.be.model.ArtifactDefinition;
package org.openecomp.sdc.be.model.operations.api;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
-import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.ComponentInstanceInput;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
-import org.openecomp.sdc.be.model.RelationshipInfo;
-import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
-import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.resources.data.AttributeValueData;
-import org.openecomp.sdc.be.resources.data.CapabilityData;
import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
-import org.openecomp.sdc.be.resources.data.RequirementData;
-import org.openecomp.sdc.exception.ResponseFormat;
import fj.data.Either;
import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
import org.openecomp.sdc.be.resources.data.UniqueIdData;
-import org.openecomp.sdc.common.config.EcompErrorName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
}
}
- private void commitOrRollbackTx(TitanTransaction tx, boolean inTransaction, Either<? extends Object, StorageOperationStatus> result) {
-
- if (false == inTransaction) {
- if (result == null || result.isRight()) {
- log.error("Going to execute rollback on graph.");
- tx.rollback();
- } else {
- log.debug("Going to execute commit on graph.");
- tx.commit();
- }
- }
- }
-
@Override
public Either<AdditionalInfoParameterInfo, StorageOperationStatus> getAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId, String id, boolean inTransaction) {
import org.openecomp.sdc.be.resources.data.HeatParameterValueData;
import org.openecomp.sdc.be.resources.data.UniqueIdData;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
-import org.openecomp.sdc.common.config.EcompErrorName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import com.thinkaurelius.titan.core.TitanGraph;
-//import com.tinkerpop.blueprints.Direction;
-//import com.tinkerpop.blueprints.Edge;
-//import com.tinkerpop.blueprints.Vertex;
-//import com.tinkerpop.blueprints.util.ElementHelper;
import com.thinkaurelius.titan.core.TitanVertex;
import fj.data.Either;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Map;
-import java.util.Map.Entry;
import javax.annotation.PostConstruct;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import fj.data.Either;
import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
-import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.model.Resource;
-import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
-import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation;
import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
-import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
-import fj.data.Either;
-
@Component("graph-lock-operation")
public class GraphLockOperation implements IGraphLockOperation {
private static Logger log = LoggerFactory.getLogger(GraphLockOperation.class.getName());
@javax.annotation.Resource
private TitanGenericDao titanGenericDao;
-
- @Autowired
- ToscaOperationFacade toscaOperationFacade;
-
- @javax.annotation.Resource
- private ICacheMangerOperation cacheManagerOperation;
public GraphLockOperation() {
super();
TitanOperationStatus lockElementStatus = null;
try {
- // SET LAST UPDATE DATE OF THE COMPONENT.
- // In this way we mark the component as updated one (and component
- // won't be fetched from cache since the component in cache has
- // different timestamp)
-// Either<ComponentMetadataData, TitanOperationStatus> updateTime = updateModificationTimeOfComponent(componentId, nodeType);
-// if (updateTime.isRight()) {
-// TitanOperationStatus operationStatus = updateTime.right().value();
-// if (operationStatus != TitanOperationStatus.OK) {
-// return DaoStatusConverter.convertTitanStatusToStorageStatus(operationStatus);
-// }
-// }
-
lockElementStatus = titanGenericDao.lockElement(componentId, nodeType);
} catch (Exception e) {
}
- /**
- * update the last update date of the component
- *
- * @param componentId
- * @param nodeType
- * @return
- */
- private Either<ComponentMetadataData, TitanOperationStatus> updateModificationTimeOfComponent(String componentId, NodeTypeEnum nodeType) {
-
- if (nodeType == NodeTypeEnum.Resource || nodeType == NodeTypeEnum.Service || nodeType == NodeTypeEnum.Product) {
- // We fetch all node since update only timestamp make problems since
- // there is default resource type (VFC) which changes component
- // resource type when we update only timestamp(ResourceMetadataData
- // contains default value VFC on resourceType field).
- Either<ComponentMetadataData, TitanOperationStatus> findComp = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, ComponentMetadataData.class);
-
- if (findComp.isRight()) {
- return Either.right(findComp.right().value());
- }
- ComponentMetadataData componentMetadataData = findComp.left().value();
- componentMetadataData.getMetadataDataDefinition().setLastUpdateDate(System.currentTimeMillis());
- Either<ComponentMetadataData, TitanOperationStatus> updateNode = titanGenericDao.updateNode(componentMetadataData, ComponentMetadataData.class);
- return updateNode;
- }
- return Either.right(TitanOperationStatus.OK);
- }
-
/*
* (non-Javadoc)
*
@Override
public StorageOperationStatus unlockComponent(String componentId, NodeTypeEnum nodeType) {
-// Either<Long, StorageOperationStatus> addComponentToCachePart1 = addComponentToCachePart1WithoutCommit(componentId, nodeType);
-
TitanOperationStatus lockElementStatus = titanGenericDao.releaseElement(componentId, nodeType);
-// if (addComponentToCachePart1.isLeft()) {
-// Long lastUpdateDate = addComponentToCachePart1.left().value();
-// addComponentToCachePart2(componentId, lastUpdateDate, nodeType);
-// }
-//
return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus);
}
- private ResourceMetadataData getResourceMetaDataFromResource(Resource resource) {
- ResourceMetadataData resourceData = new ResourceMetadataData((ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition().getMetadataDataDefinition());
- return resourceData;
- }
-
@Override
public StorageOperationStatus unlockComponentByName(String name, String componentId, NodeTypeEnum nodeType) {
-
-// Either<Long, StorageOperationStatus> addComponentToCachePart1 = addComponentToCachePart1WithoutCommit(componentId, nodeType);
-
TitanOperationStatus lockElementStatus = titanGenericDao.releaseElement(name, nodeType);
-//
-// if (addComponentToCachePart1.isLeft()) {
-// Long lastUpdateDate = addComponentToCachePart1.left().value();
-// addComponentToCachePart2(componentId, lastUpdateDate, nodeType);
-// }
-
return DaoStatusConverter.convertTitanStatusToStorageStatus(lockElementStatus);
}
- /**
- * We fetch the last update date of the component
- *
- * @param componentId
- * @param nodeType
- * @return
- */
- private Either<Long, StorageOperationStatus> addComponentToCachePart1WithoutCommit(String componentId, NodeTypeEnum nodeType) {
- if (componentId != null) { // In case of error, the componentId might be
- // empty.
- if (nodeType == NodeTypeEnum.Resource || nodeType == NodeTypeEnum.Service || nodeType == NodeTypeEnum.Product) {
- Long lastUpdateDate = null;
- Either<ComponentMetadataData, StorageOperationStatus> resResult = toscaOperationFacade.getComponentMetadata(componentId);
- if (resResult.isLeft()) {
- ComponentMetadataData resourceMetadataData = resResult.left().value();
- lastUpdateDate = resourceMetadataData.getMetadataDataDefinition().getLastUpdateDate();
-
- return Either.left(lastUpdateDate);
- } else {
- return Either.right(resResult.right().value());
- }
- }
- }
- return Either.right(StorageOperationStatus.OPERATION_NOT_SUPPORTED);
- }
-
- /**
- * add the component to the cache
- *
- * @param componentId
- * @param lastUpdateDate
- * @param nodeType
- * @return
- */
- private Either<Long, StorageOperationStatus> addComponentToCachePart2(String componentId, Long lastUpdateDate, NodeTypeEnum nodeType) {
- if (componentId != null) { // In case of error, the componentId might be
- // empty.
- if (nodeType == NodeTypeEnum.Resource || nodeType == NodeTypeEnum.Service || nodeType == NodeTypeEnum.Product) {
- // add task to Q
- log.debug("Going to add component {} of type {} to cache", componentId, nodeType.name().toLowerCase());
- cacheManagerOperation.updateComponentInCache(componentId, lastUpdateDate, nodeType);
- }
- }
- return Either.right(StorageOperationStatus.OPERATION_NOT_SUPPORTED);
- }
-
@Override
public StorageOperationStatus lockComponentByName(String name, NodeTypeEnum nodeType) {
log.info("lock resource with name {}", name);
}
-
- private GroupInstanceData buildGroupInstanceData(GroupInstance groupInstance, String componentInstanceId, String logicalName) {
- String ciOriginComponentUid = groupInstance.getGroupUid();
-
- GroupInstanceDataDefinition dataDefinition = new GroupInstanceDataDefinition(groupInstance);
-
- Long creationDate = groupInstance.getCreationTime();
- if (creationDate == null) {
- creationDate = System.currentTimeMillis();
- }
- dataDefinition.setCreationTime(creationDate);
- dataDefinition.setModificationTime(creationDate);
- // dataDefinition.setResourceUid(resourceUid);
- // String replacmentlogicalName = logicalName.replaceAll(" ",
- // "_").toLowerCase();
- dataDefinition.setName(logicalName);
- if (dataDefinition.getNormalizedName() == null)
- dataDefinition.setNormalizedName(ValidationUtils.normalizeComponentInstanceName(logicalName));
- dataDefinition.setUniqueId(UniqueIdBuilder.buildResourceInstanceUniuqeId(componentInstanceId, ciOriginComponentUid, dataDefinition.getNormalizedName()));
-
- GroupInstanceData resourceInstanceData = new GroupInstanceData(dataDefinition);
-
- return resourceInstanceData;
- }
-
/**
* update value of attribute on resource instance
*
@javax.annotation.Resource
private TitanGenericDao titanGenericDao;
- private Gson gson = new Gson();
-
public TitanGenericDao getTitanGenericDao() {
return titanGenericDao;
}
return Either.left(createNodeResult.left().value());
}
- private Either<TitanVertex, TitanOperationStatus> createInterfaceNodeAndRelation(String interfaceName, String resourceId, InterfaceData interfaceData, TitanVertex metadataVertex) {
- log.debug("Before adding interface to graph {}", interfaceData);
- Either<TitanVertex, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(interfaceData);
-
- if (createNodeResult.isRight()) {
- TitanOperationStatus operationStatus = createNodeResult.right().value();
- log.error("Failed to add interface {} to graph. status is {}", interfaceName, operationStatus);
- return Either.right(operationStatus);
- }
-
- Map<String, Object> props = new HashMap<String, Object>();
- props.put(GraphPropertiesDictionary.NAME.getProperty(), interfaceName);
- TitanVertex interfaceVertex = createNodeResult.left().value();
- TitanOperationStatus createRelResult = titanGenericDao.createEdge(metadataVertex, interfaceVertex, GraphEdgeLabels.INTERFACE, props);
- if (!createRelResult.equals(TitanOperationStatus.OK)) {
- log.error("Failed to associate resource {} to property {} in graph. status is {}", resourceId, interfaceName, createRelResult);
- }
- return Either.left(interfaceVertex);
- }
-
private Either<OperationData, TitanOperationStatus> createOperationNodeAndRelation(String operationName, OperationData operationData, InterfaceData interfaceData) {
log.debug("Before adding operation to graph {}", operationData);
Either<OperationData, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(operationData, OperationData.class);
import org.openecomp.sdc.be.model.tosca.constraints.MinLengthConstraint;
import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
-import org.openecomp.sdc.be.model.tosca.validators.PropertyTypeValidator;
import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
import org.openecomp.sdc.be.resources.data.DataTypeData;
import org.openecomp.sdc.be.resources.data.PropertyData;
return functionPatterns;
}
- /*
- * (non-Javadoc)
- *
- * @see org.openecomp.sdc.be.model.operations.api.IPropertyOperation# addPropertyToResource(java.lang.String, org.openecomp.sdc.be.model.PropertyDefinition, org.openecomp.sdc.be.dao.neo4j.datatype.NodeTypeEnum, java.lang.String)
- */
- /*
- * @Override public Either<PropertyDefinition, StorageOperationStatus> addPropertyToResource( String propertyName, PropertyDefinition propertyDefinition, NodeTypeEnum nodeType, String resourceId) {
- *
- * StorageOperationStatus isValidProperty = isTypeExistsAndValid(propertyDefinition); if (isValidProperty != StorageOperationStatus.OK) { return Either.right(isValidProperty); }
- *
- * Either<PropertyData, TitanOperationStatus> status = addPropertyToGraph(propertyName, propertyDefinition, resourceId);
- *
- * if (status.isRight()) { titanGenericDao.rollback();
- * log.error("Failed to add property {} to resource {}, propertyName, resourceId);
- * return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(status. right().value())); } else
- * { titanGenericDao.commit(); PropertyData propertyData = status.left().value();
- *
- * PropertyDefinition propertyDefResult = convertPropertyDataToPropertyDefinition(propertyData, propertyName, resourceId); log.debug("The returned PropertyDefintion is " + propertyDefinition); return Either.left(propertyDefResult); }
- *
- *
- * }
- */
- private StorageOperationStatus isTypeExistsAndValid(PropertyDefinition propertyDefinition) {
-
- ToscaPropertyType type = ToscaPropertyType.isValidType(propertyDefinition.getType());
-
- if (type == null) {
- return StorageOperationStatus.INVALID_TYPE;
- }
-
- String propertyType = propertyDefinition.getType();
- String innerType = null;
- String value = propertyDefinition.getDefaultValue();
-
- if (propertyType.equals(ToscaPropertyType.LIST) || propertyType.equals(ToscaPropertyType.MAP)) {
- SchemaDefinition schema;
- if ((schema = propertyDefinition.getSchema()) != null) {
- PropertyDataDefinition property;
- if ((property = schema.getProperty()) != null) {
- innerType = property.getType();
-
- }
- }
- }
-
- PropertyTypeValidator validator = type.getValidator();
-
- if (value == null || (EMPTY_VALUE != null && EMPTY_VALUE.equals(propertyDefinition.getDefaultValue()))) {
- return StorageOperationStatus.OK;
- } else {
- boolean isValid = validator.isValid(value, innerType, null);
- if (true == isValid) {
- return StorageOperationStatus.OK;
- } else {
- return StorageOperationStatus.INVALID_VALUE;
- }
- }
-
- }
-
public PropertyDefinition convertPropertyDataToPropertyDefinition(PropertyData propertyDataResult, String propertyName, String resourceId) {
log.debug("The object returned after create property is {}", propertyDataResult);
return StorageOperationStatus.OK;
}
- /*
- * public Either<Object, Boolean> validateAndUpdatePropertyValue(String propertyType, String value, String innerType) {
- *
- * log. trace("Going to validate property value and its type. type = {}, value = {}" ,propertyType, value);
- *
- * ToscaPropertyType type = getType(propertyType);
- *
- * if (type == null) {
- *
- * Either<DataTypeDefinition, TitanOperationStatus> externalDataType = getExternalDataType(propertyType); if (externalDataType.isRight()) { TitanOperationStatus status = externalDataType.right().value(); log.debug("The type " + propertyType +
- * " of property cannot be found. Status is " + status); if (status != TitanOperationStatus.NOT_FOUND) { BeEcompErrorManager.getInstance(). logBeInvalidTypeError("validate property type", propertyType, "property"); } return Either.right(false); }
- *
- * DataTypeDefinition dataTypeDefinition = externalDataType.left().value();
- *
- * Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypesRes = getAllDataTypes(); if (allDataTypesRes.isRight()) { TitanOperationStatus status = allDataTypesRes.right().value(); return Either.right(false); }
- *
- * Map<String, DataTypeDefinition> allDataTypes = allDataTypesRes.left().value();
- *
- * ImmutablePair<JsonElement, Boolean> validateResult = dataTypeValidatorConverter.validateAndUpdate(value, dataTypeDefinition, allDataTypes);
- *
- * if (validateResult.right.booleanValue() == false) {
- * log.debug("The value {} of property from type {} is invalid", value, propertyType);
- * return Either.right(false); }
- *
- * JsonElement jsonElement = validateResult.left;
- *
- * String valueFromJsonElement = getValueFromJsonElement(jsonElement);
- *
- * return Either.left(valueFromJsonElement);
- *
- * }
- *
- * log.trace("After validating property type {}", propertyType);
- *
- * boolean isValidProperty = isValidValue(type, value, innerType); if (false == isValidProperty) { log.debug("The value " + value + " of property from type " + type + " is invalid"); return Either.right(false); }
- *
- *
- * Object convertedValue = value; if (false == isEmptyValue(value)) { PropertyValueConverter converter = type.getConverter(); convertedValue = converter.convert(value, null); }
- *
- * return Either.left(convertedValue); }
- */
-
public Either<PropertyData, TitanOperationStatus> addPropertyToGraph(String propertyName, PropertyDefinition propertyDefinition, String resourceId) {
ResourceMetadataData resourceData = new ResourceMetadataData();
}
- public TitanOperationStatus addPropertyToNodeType(TitanVertex elementVertex, String propertyName, PropertyDefinition propertyDefinition, NodeTypeEnum nodeType, String uniqueId) {
-
- List<PropertyConstraint> constraints = propertyDefinition.getConstraints();
-
- propertyDefinition.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(uniqueId, propertyName));
- PropertyData propertyData = new PropertyData(propertyDefinition, convertConstraintsToString(constraints));
-
- if (log.isDebugEnabled())
- log.debug("Before adding property to graph {}", propertyData);
- Either<TitanVertex, TitanOperationStatus> createNodeResult = titanGenericDao.createNode(propertyData);
- if (log.isDebugEnabled())
- log.debug("After adding property to graph {}", propertyData);
- if (createNodeResult.isRight()) {
- TitanOperationStatus operationStatus = createNodeResult.right().value();
- log.error("Failed to add property {} to graph. status is {} ", propertyName, operationStatus);
- return operationStatus;
- }
-
- Map<String, Object> props = new HashMap<String, Object>();
- props.put(GraphPropertiesDictionary.NAME.getProperty(), propertyName);
-
- TitanOperationStatus createRelResult = titanGenericDao.createEdge(elementVertex, propertyData, GraphEdgeLabels.PROPERTY, props);
- if (!createRelResult.equals(TitanOperationStatus.OK)) {
- log.error("Failed to associate resource {} to property {} in graph. status is {}", uniqueId, propertyName, createRelResult);
- return createRelResult;
- }
-
- return createRelResult;
-
- }
-
public Either<Map<String, PropertyDefinition>, TitanOperationStatus> findPropertiesOfNode(NodeTypeEnum nodeType, String uniqueId) {
Map<String, PropertyDefinition> resourceProps = new HashMap<String, PropertyDefinition>();
}
- public void updatePropertiesByPropertyValues(Map<String, List<ComponentInstanceProperty>> resourceInstancesProperties, Map<String, Map<String, ComponentInstanceProperty>> values) {
-
- if (resourceInstancesProperties == null) {
- return;
- }
-
- List<ComponentInstanceProperty> allProperties = new ArrayList<>();
- Collection<List<ComponentInstanceProperty>> properties = resourceInstancesProperties.values();
- if (properties != null) {
- Iterator<List<ComponentInstanceProperty>> iterator = properties.iterator();
- while (iterator.hasNext()) {
- List<ComponentInstanceProperty> compInstancePropertyList = iterator.next();
- allProperties.addAll(compInstancePropertyList);
- }
- }
-
- // Go over each property and check whether there is a rule which updates
- // it
- for (ComponentInstanceProperty instanceProperty : allProperties) {
-
- String propertyUniqueId = instanceProperty.getUniqueId();
-
- // get the changes per componentInstanceId.
- Map<String, ComponentInstanceProperty> instanceIdToValue = values.get(propertyUniqueId);
-
- if (instanceIdToValue == null) {
- continue;
- }
-
- this.updatePropertyByBestMatch(propertyUniqueId, instanceProperty, instanceIdToValue);
-
- }
-
- }
-
/**
*
* Add data type to graph.
}
- private Either<DataTypeDefinition, TitanOperationStatus> getExternalDataType(String propertyType) {
-
- String dataTypeUid = UniqueIdBuilder.buildDataTypeUid(propertyType);
- Either<DataTypeDefinition, TitanOperationStatus> dataTypeByUid = getDataTypeByUid(dataTypeUid);
- if (dataTypeByUid.isRight()) {
- TitanOperationStatus status = dataTypeByUid.right().value();
- return Either.right(status);
- }
-
- return Either.left(dataTypeByUid.left().value());
-
- }
-
public Either<Map<String, DataTypeDefinition>, TitanOperationStatus> getAllDataTypes() {
Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
}
- protected TitanOperationStatus addPropertiesToElementType(String uniqueId, NodeTypeEnum nodeType, Map<String, PropertyDefinition> propertiesMap, TitanVertex elementVertex) {
-
- if (propertiesMap != null) {
-
- for (Entry<String, PropertyDefinition> propertyDefinitionEntry : propertiesMap.entrySet()) {
- String propertyName = propertyDefinitionEntry.getKey();
-
- TitanOperationStatus operationStatus = this.addPropertyToNodeType(elementVertex, propertyName, propertyDefinitionEntry.getValue(), nodeType, uniqueId);
-
- if (!operationStatus.equals(TitanOperationStatus.OK)) {
- log.error("Failed to associate {} {} to property {} in graph. status is {}", nodeType.getName(), uniqueId, propertyName, operationStatus);
- return operationStatus;
- }
- }
- }
-
- return TitanOperationStatus.OK;
-
- }
-
public Either<Map<String, PropertyData>, TitanOperationStatus> addPropertiesToElementType(String uniqueId, NodeTypeEnum elementType, List<PropertyDefinition> properties) {
Map<String, PropertyDefinition> propMap;
JsonParser jsonParser = new JsonParser();
- Gson gson = new Gson();
-
ImmutablePair<JsonElement, Boolean> falseResult = new ImmutablePair<JsonElement, Boolean>(null, false);
ImmutablePair<JsonElement, Boolean> trueEmptyResult = new ImmutablePair<JsonElement, Boolean>(null, true);
return allParentsProps;
}
- private String getValueFromJsonElement(JsonElement jsonElement) {
- String value = null;
-
- if (jsonElement == null || jsonElement.isJsonNull()) {
- value = PropertyOperation.EMPTY_VALUE;
- } else {
- if (jsonElement.toString().isEmpty()) {
- value = "";
- } else {
- value = jsonElement.toString();
- }
- }
-
- return value;
- }
-
public boolean isValid(String value, DataTypeDefinition dataTypeDefinition, Map<String, DataTypeDefinition> allDataTypes) {
boolean result = false;
package org.openecomp.sdc.be.model.tosca.validators;
-import java.util.Map;
-
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+import com.google.gson.JsonSyntaxException;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.gson.Gson;
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
-import com.google.gson.JsonSyntaxException;
+import java.util.Map;
public class ListValidator implements PropertyTypeValidator {
private static ListValidator listValidator = new ListValidator();
private static Logger log = LoggerFactory.getLogger(ListValidator.class.getName());
- Gson gson = new Gson();
private static JsonParser jsonParser = new JsonParser();
package org.openecomp.sdc.be.model;
-import javax.annotation.Generated;
-
import org.junit.Test;
import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import java.util.List;
import java.util.Map;
-import javax.annotation.Generated;
-
import org.junit.Assert;
import org.junit.Test;
import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
import javax.annotation.Generated;
import org.junit.Test;
-import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
@Generated(value = "org.junit-tools-1.0.6")
package org.openecomp.sdc.be.model.cache;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Function;
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.ImmutableTriple;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.config.Configuration;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.cassandra.ComponentCassandraDao;
-import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.resources.data.ComponentCacheData;
import org.slf4j.Logger;
import fj.data.Either;
-import org.apache.tinkerpop.gremlin.structure.Direction;
-import org.apache.tinkerpop.gremlin.structure.Edge;
-import org.apache.tinkerpop.gremlin.structure.Property;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
-import org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
-import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
-import com.thinkaurelius.titan.core.PropertyKey;
-import com.thinkaurelius.titan.core.TitanEdge;
-import com.thinkaurelius.titan.core.TitanTransaction;
import com.thinkaurelius.titan.core.TitanVertex;
-import com.thinkaurelius.titan.core.TitanVertexProperty;
-import com.thinkaurelius.titan.core.TitanVertexQuery;
-import com.thinkaurelius.titan.core.VertexLabel;
-import com.thinkaurelius.titan.diskstorage.EntryMetaData.Map;
import java.util.Collections;
import java.util.HashMap;
-import java.util.Iterator;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
import org.openecomp.sdc.be.model.ModelTestBase;
-import org.openecomp.sdc.be.model.catalog.CatalogComponent;
import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
import org.openecomp.sdc.be.model.jsontitan.utils.GraphTestUtils;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Matchers.anyMap;
-import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
-import org.openecomp.sdc.be.dao.jsongraph.utils.IdBuilderUtils;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapDataDefinition;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.PropertyDefinition;
-import javax.json.Json;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
Code Review / sdc.git / commitdiff