public Vertex getVertex(String id, String type) throws CrudException;
/**
- * Retrieve all of the edges which are incident to the vertex with the specified identifier.
+ * Retrieve all of the edges which are incident to the vertex with the
+ * specified identifier.
*
- * @param id - The unique identifier of the vertex to retrieve the edges for.
+ * @param id
+ * - The unique identifier of the vertex to retrieve the edges for.
* @return - A collection of edges.
* @throws CrudException
*/
public List<Edge> getVertexEdges(String id) throws CrudException;
/**
- * Retrieve a collection of {@link Vertex} objects which match the supplied type label
- * and filter properties.
+ * Retrieve a collection of {@link Vertex} objects which match the supplied
+ * type label and filter properties.
*
- * @param type - The vertex type that we want to retrieve.
- * @param filter - The parameters to filter our results by.
+ * @param type
+ * - The vertex type that we want to retrieve.
+ * @param filter
+ * - The parameters to filter our results by.
* @return - A collection of vertices.
* @throws CrudException
*/
public List<Vertex> getVertices(String type, Map<String, Object> filter) throws CrudException;
/**
- * Retrieve an {@link Edge} from the graph database by specifying its unique identifier.
+ * Retrieve an {@link Edge} from the graph database by specifying its unique
+ * identifier.
*
- * @param id - The unique identifier for the Edge to be retrieved.
+ * @param id
+ * - The unique identifier for the Edge to be retrieved.
* @return - The Edge corresponding to the specified identifier.
* @throws CrudException
*/
public Edge getEdge(String id, String type) throws CrudException;
/**
- * Retrieve a collection of {@link Edge} objects with a given type and which match a set of
- * supplied filter parameters.
+ * Retrieve a collection of {@link Edge} objects with a given type and which
+ * match a set of supplied filter parameters.
*
- * @param type - The type of edges that we are interested in.
- * @param filter - The parameters that we want to filter our edges by.
+ * @param type
+ * - The type of edges that we are interested in.
+ * @param filter
+ * - The parameters that we want to filter our edges by.
* @return - A collection of edges which match the supplied filter parameters.
* @throws CrudException
*/
/**
* Insert a new {@link Vertex} into the graph data store.
*
- * @param type - The type label to assign to the vertex.
- * @param properties - The properties to associated with this vertex.
+ * @param type
+ * - The type label to assign to the vertex.
+ * @param properties
+ * - The properties to associated with this vertex.
* @return - The {@link Vertex} object that was created.
* @throws CrudException
*/
/**
* Updates an existing {@link Vertex}.
*
- * @param id - The unique identifier of the vertex to be updated.
- * @param properties - The properties to associate with the vertex.
+ * @param id
+ * - The unique identifier of the vertex to be updated.
+ * @param properties
+ * - The properties to associate with the vertex.
* @return - The udpated vertex.
* @throws CrudException
*/
- public Vertex updateVertex(String id, String type, Map<String, Object> properties)
- throws CrudException;
+ public Vertex updateVertex(String id, String type, Map<String, Object> properties) throws CrudException;
/**
* Removes the specified vertex from the graph data base.
*
- * <p>NOTE: The vertex MUST contain NO incident edges before it can be deleted.
+ * <p>
+ * NOTE: The vertex MUST contain NO incident edges before it can be deleted.
*
- * @param id - The unique identifier of the vertex to be deleted.
+ * @param id
+ * - The unique identifier of the vertex to be deleted.
* @throws CrudException
*/
public void deleteVertex(String id, String type) throws CrudException;
/**
* Adds an edge to the graph database.
*
- * @param type - The 'type' label to apply to the edge.
- * @param source - The source vertex for this edge.
- * @param target - The target vertex for this edge.
- * @param properties - The properties map to associate with this edge.
+ * @param type
+ * - The 'type' label to apply to the edge.
+ * @param source
+ * - The source vertex for this edge.
+ * @param target
+ * - The target vertex for this edge.
+ * @param properties
+ * - The properties map to associate with this edge.
* @return - The {@link Edge} object that was created.
* @throws CrudException
*/
- public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties)
- throws CrudException;
+ public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties) throws CrudException;
/**
* Updates an existing {@link Edge}.
*
- * @param id - The unique identifier of the edge to be updated.
- * @param properties - The properties to associate with the edge.
+ * @param id
+ * - The unique identifier of the edge to be updated.
+ * @param properties
+ * - The properties to associate with the edge.
* @return - The update edge.
* @throws CrudException
*/
/**
* Remove the specified edge from the graph data base.
*
- * @param id - The unique identifier of the edge to be deleted.
+ * @param id
+ * - The unique identifier of the edge to be deleted.
* @throws CrudException
*/
public void deleteEdge(String id, String type) throws CrudException;
-
-
+
public String openTransaction();
+
public void commitTransaction(String id) throws CrudException;
+
public void rollbackTransaction(String id) throws CrudException;
+
public boolean transactionExists(String id) throws CrudException;
-
+
public Vertex addVertex(String type, Map<String, Object> properties, String txId) throws CrudException;
+
public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties, String txId)
- throws CrudException;
- public Vertex updateVertex(String id, String type, Map<String, Object> properties, String txId)
- throws CrudException;
-
+ throws CrudException;
+
+ public Vertex updateVertex(String id, String type, Map<String, Object> properties, String txId) throws CrudException;
+
public Edge updateEdge(Edge edge, String txId) throws CrudException;
+
public void deleteVertex(String id, String type, String txId) throws CrudException;
+
public void deleteEdge(String id, String type, String txId) throws CrudException;
+
public Edge getEdge(String id, String type, String txId) throws CrudException;
}
import org.openecomp.crud.logging.CrudServiceMsgs;
/**
- * This is the integration layer between the CRUD API service and the low level Champ library for graph database
- * interaction.
+ * This is the integration layer between the CRUD API service and the low level
+ * Champ library for graph database interaction.
*/
public class ChampDao implements GraphDao {
- public static final String CONFIG_STORAGE_BACKEND = "storage.backend";
- public static final String CONFIG_STORAGE_BACKEND_DB = "storage.backend.db";
- public static final String STORAGE_HBASE_DB = "hbase";
- public static final String STORAGE_CASSANDRA_DB = "cassandra";
- public static final String CONFIG_STORAGE_HOSTNAMES = "storage.hostnames";
- public static final String CONFIG_STORAGE_PORT = "storage.port";
- public static final String CONFIG_HBASE_ZNODE_PARENT = "storage.hbase.ext.zookeeper.znode.parent";
- public static final String CONFIG_GRAPH_NAME = "graph.name";
- public static final String GRAPH_UNQ_INSTANCE_ID_SUFFIX = "graph.unique-instance-id-suffix";
+ public static final String CONFIG_STORAGE_BACKEND = "storage.backend";
+ public static final String CONFIG_STORAGE_BACKEND_DB = "storage.backend.db";
+ public static final String STORAGE_HBASE_DB = "hbase";
+ public static final String STORAGE_CASSANDRA_DB = "cassandra";
+ public static final String CONFIG_STORAGE_HOSTNAMES = "storage.hostnames";
+ public static final String CONFIG_STORAGE_PORT = "storage.port";
+ public static final String CONFIG_HBASE_ZNODE_PARENT = "storage.hbase.ext.zookeeper.znode.parent";
+ public static final String CONFIG_GRAPH_NAME = "graph.name";
+ public static final String GRAPH_UNQ_INSTANCE_ID_SUFFIX = "graph.unique-instance-id-suffix";
- public static final String CONFIG_EVENT_STREAM_PUBLISHER = "event.stream.publisher";
- public static final String CONFIG_EVENT_STREAM_NUM_PUBLISHERS = "event.stream.num-publishers";
+ public static final String CONFIG_EVENT_STREAM_PUBLISHER = "event.stream.publisher";
+ public static final String CONFIG_EVENT_STREAM_NUM_PUBLISHERS = "event.stream.num-publishers";
- private static Map<String, ChampTransaction> transactions = new ConcurrentHashMap<String, ChampTransaction>();
- public static final String DEFAULT_GRAPH_NAME = "default_graph";
+ private static Map<String, ChampTransaction> transactions = new ConcurrentHashMap<String, ChampTransaction>();
+ public static final String DEFAULT_GRAPH_NAME = "default_graph";
- private enum GraphType {
- IN_MEMORY, TITAN, DSE
- }
+ private enum GraphType {
+ IN_MEMORY, TITAN, DSE
+ }
- /**
- * Instance of the API used for interacting with the Champ library.
- */
- private ChampGraph champApi = null;
+ /**
+ * Instance of the API used for interacting with the Champ library.
+ */
+ private ChampGraph champApi = null;
- private Logger logger = LoggerFactory.getInstance().getLogger(ChampDao.class.getName());
+ private Logger logger = LoggerFactory.getInstance().getLogger(ChampDao.class.getName());
- /**
- * Creates a new instance of the ChampDao.
- *
- * @param champGraph
- * - Concrete implementation of the graph dao layer
- */
- public ChampDao(ChampGraph champGraph) {
- this.champApi = champGraph;
- }
+ /**
+ * Creates a new instance of the ChampDao.
+ *
+ * @param champGraph
+ * - Concrete implementation of the graph dao layer
+ */
+ public ChampDao(ChampGraph champGraph) {
+ this.champApi = champGraph;
+ }
- @Override
- public Vertex getVertex(String id) throws CrudException {
+ @Override
+ public Vertex getVertex(String id) throws CrudException {
- try {
+ try {
- if (logger.isDebugEnabled()) {
- logger.debug("getVertex with id: " + id);
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("getVertex with id: " + id);
+ }
- long idAsLong = Long.parseLong(id);
+ long idAsLong = Long.parseLong(id);
- Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
+ Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
- String nodeType = org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName();
- if (retrievedVertex.isPresent() && retrievedVertex.get().getProperties().get(nodeType) != null) {
- return vertexFromChampObject(retrievedVertex.get(), retrievedVertex.get().getProperties().get(nodeType).toString());
- } else {
+ String nodeType = org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName();
+ if (retrievedVertex.isPresent() && retrievedVertex.get().getProperties().get(nodeType) != null) {
+ return vertexFromChampObject(retrievedVertex.get(),
+ retrievedVertex.get().getProperties().get(nodeType).toString());
+ } else {
- // We didn't find a vertex with the supplied id, so just throw an
- // exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
- } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
- // Something went wrong - throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
+ // Something went wrong - throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
- @Override
- public Vertex getVertex(String id, String type) throws CrudException {
+ @Override
+ public Vertex getVertex(String id, String type) throws CrudException {
- try {
+ try {
- if (logger.isDebugEnabled()) {
- logger.debug("getVertex with id: " + id);
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("getVertex with id: " + id);
+ }
- long idAsLong = Long.parseLong(id);
+ long idAsLong = Long.parseLong(id);
- // Request the vertex from the graph db.
- Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
+ // Request the vertex from the graph db.
+ Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
- // Did we find it?
- if (retrievedVertex.isPresent()
- && retrievedVertex.get().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) != null
- && retrievedVertex.get().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()
- .equalsIgnoreCase(type)) {
+ // Did we find it?
+ if (retrievedVertex.isPresent()
+ && retrievedVertex.get().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) != null
+ && retrievedVertex.get().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()
+ .equalsIgnoreCase(type)) {
- // Yup, convert it to a Vector object and return it.
- return vertexFromChampObject(retrievedVertex.get(), type);
+ // Yup, convert it to a Vector object and return it.
+ return vertexFromChampObject(retrievedVertex.get(), type);
- } else {
+ } else {
- // We didn't find a vertex with the supplied id, so just throw an
- // exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
- } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
- // Something went wrong - throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
+ // Something went wrong - throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
- @Override
- public List<Edge> getVertexEdges(String id) throws CrudException {
+ @Override
+ public List<Edge> getVertexEdges(String id) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("get Edges incident to vertex with id: " + id + " from graph");
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("get Edges incident to vertex with id: " + id + " from graph");
+ }
- try {
- long idAsLong = Long.parseLong(id); // GDF - what to do about id???
+ try {
+ long idAsLong = Long.parseLong(id); // GDF - what to do about id???
- // Request the vertex from the graph db.
- Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
+ // Request the vertex from the graph db.
+ Optional<ChampObject> retrievedVertex = champApi.retrieveObject(idAsLong);
- // Did we find it?
- if (retrievedVertex.isPresent()) {
+ // Did we find it?
+ if (retrievedVertex.isPresent()) {
- // Query the Champ library for the edges which are incident to the specified
- // vertex.
- Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get());
+ // Query the Champ library for the edges which are incident to the
+ // specified
+ // vertex.
+ Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get());
- // Build an edge list from the result stream.
- List<Edge> edges = new ArrayList<Edge>();
- relationships.forEach(r -> edges.add(edgeFromChampRelationship(r)));
+ // Build an edge list from the result stream.
+ List<Edge> edges = new ArrayList<Edge>();
+ relationships.forEach(r -> edges.add(edgeFromChampRelationship(r)));
- return edges;
+ return edges;
- } else {
+ } else {
- // We couldn't find the specified vertex, so throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
+ // We couldn't find the specified vertex, so throw an exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
- } catch (ChampUnmarshallingException e) {
+ } catch (ChampUnmarshallingException e) {
- // Something went wrong, so throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ // Something went wrong, so throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- } catch (ChampObjectNotExistsException e) {
+ } catch (ChampObjectNotExistsException e) {
- // We couldn't find the specified vertex, so throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- } catch (ChampTransactionException e) {
- throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
+ // We couldn't find the specified vertex, so throw an exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
- @Override
- public Vertex addVertex(String type, Map<String, Object> properties) throws CrudException {
+ @Override
+ public Vertex addVertex(String type, Map<String, Object> properties) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Add/update vertex: {label: " + type + " properties:" + propertiesMapToString(properties));
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Add/update vertex: {label: " + type + " properties:" + propertiesMapToString(properties));
+ }
- // Add the aai_node_type so that AAI can read the data created by gizmo
- properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
+ // Add the aai_node_type so that AAI can read the data created by gizmo
+ properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
- // Create an object to represent our vertex in the format expected by the Champ library.
- ChampObject objectToCreate = buildChampObject(type, properties);
+ // Create an object to represent our vertex in the format expected by the
+ // Champ library.
+ ChampObject objectToCreate = buildChampObject(type, properties);
- try {
+ try {
- // Ask the Champ library to store our vertex, placing the returned object into a
- // list so that we can easily put that into our result object.
- return vertexFromChampObject(champApi.storeObject(objectToCreate), type);
+ // Ask the Champ library to store our vertex, placing the returned object
+ // into a
+ // list so that we can easily put that into our result object.
+ return vertexFromChampObject(champApi.storeObject(objectToCreate), type);
- } catch (ChampMarshallingException | ChampSchemaViolationException | ChampObjectNotExistsException | ChampTransactionException e) {
+ } catch (ChampMarshallingException | ChampSchemaViolationException | ChampObjectNotExistsException
+ | ChampTransactionException e) {
- // Something went wrong - throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
+ // Something went wrong - throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
- @Override
- public Vertex updateVertex(String id, String type, Map<String, Object> properties) throws CrudException {
+ @Override
+ public Vertex updateVertex(String id, String type, Map<String, Object> properties) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Update vertex with id: " + id + " with properties: " + propertiesMapToString(properties));
- }
- // Add the aai_node_type so that AAI can read the data created by gizmo
- properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
+ if (logger.isDebugEnabled()) {
+ logger.debug("Update vertex with id: " + id + " with properties: " + propertiesMapToString(properties));
+ }
+ // Add the aai_node_type so that AAI can read the data created by gizmo
+ properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
- try {
- // Now, build the updated version of the Champ Object...
- ChampObject updateObject = buildChampObject(id, type, properties);
- // ...and send it to the Champ library.
- return vertexFromChampObject(champApi.replaceObject(updateObject), type);
+ try {
+ // Now, build the updated version of the Champ Object...
+ ChampObject updateObject = buildChampObject(id, type, properties);
+ // ...and send it to the Champ library.
+ return vertexFromChampObject(champApi.replaceObject(updateObject), type);
- } catch (ChampObjectNotExistsException e) {
- throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
- } catch (NumberFormatException | ChampMarshallingException | ChampSchemaViolationException e) {
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- } catch (ChampTransactionException e) {
- throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
+ } catch (ChampObjectNotExistsException e) {
+ throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ } catch (NumberFormatException | ChampMarshallingException | ChampSchemaViolationException e) {
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
- }
+ }
- @Override
- public List<Vertex> getVertices(String type, Map<String, Object> filter) throws CrudException {
+ @Override
+ public List<Vertex> getVertices(String type, Map<String, Object> filter) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Retrieve vertices with type label: " + type + " which map query parameters: " + propertiesMapToString(filter));
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Retrieve vertices with type label: " + type + " which map query parameters: "
+ + propertiesMapToString(filter));
+ }
- filter.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
+ filter.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
- Stream<ChampObject> retrievedVertices;
- try {
- retrievedVertices = champApi.queryObjects(filter);
+ Stream<ChampObject> retrievedVertices;
+ try {
+ retrievedVertices = champApi.queryObjects(filter);
- } catch (ChampTransactionException e) {
- throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
- List<Vertex> vertices = retrievedVertices.map(v -> vertexFromChampObject(v, type)).collect(Collectors.toList());
+ List<Vertex> vertices = retrievedVertices.map(v -> vertexFromChampObject(v, type)).collect(Collectors.toList());
- if (logger.isDebugEnabled()) {
- logger.debug("Resulting vertex list: " + retrievedVertices);
- }
+ if (logger.isDebugEnabled()) {
+ logger.debug("Resulting vertex list: " + retrievedVertices);
+ }
- // ...and return it to the caller.
- return vertices;
- }
+ // ...and return it to the caller.
+ return vertices;
+ }
- private Object getRelKey(String id) {
- Object key = id;
- // convert into Long if applicable . TODO : revisit in story NUC-304
- try {
- key = Long.parseLong(id);
- } catch (NumberFormatException e) {
- // The id isn't a Long, leave it as a string
- }
+ private Object getRelKey(String id) {
+ Object key = id;
+ // convert into Long if applicable . TODO : revisit in story NUC-304
+ try {
+ key = Long.parseLong(id);
+ } catch (NumberFormatException e) {
+ // The id isn't a Long, leave it as a string
+ }
- return key;
- }
+ return key;
+ }
+
+ @Override
+ public Edge getEdge(String id, String type) throws CrudException {
+
+ if (logger.isDebugEnabled()) {
+ logger.debug("Get edge with id: " + id);
+ }
+
+ try {
+
+ // Request the edge from the graph db.
+ Optional<ChampRelationship> relationship = champApi.retrieveRelationship(getRelKey(id));
+
+ // Did we find it?
+ if (relationship.isPresent() && relationship.get().getType().equals(type)) {
+
+ // Yup - return the result.
+ return edgeFromChampRelationship(relationship.get());
+
+ } else {
- @Override
- public Edge getEdge(String id, String type) throws CrudException {
+ // We didn't find an edge with the supplied id, so throw an exception.
+ throw new CrudException("No edge with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
+
+ // Something went wrong, so throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties) throws CrudException {
+
+ // For now, assume source and target are straight ids...
+ try {
+
+ Optional<ChampObject> sourceObject = champApi.retrieveObject(Long.parseLong(source.getId().get()));
+ if (!sourceObject.isPresent() || !sourceObject.get().getType().equals(source.getType())) {
+ throw new CrudException(
+ "Error creating edge - source vertex with id " + source + " does not exist in graph data base",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
+
+ Optional<ChampObject> targetObject = champApi.retrieveObject(Long.parseLong(target.getId().get()));
+ if (!targetObject.isPresent() || !targetObject.get().getType().equals(target.getType())) {
+ throw new CrudException(
+ "Error creating edge - target vertex with id " + target + " does not exist in graph data base",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
- if (logger.isDebugEnabled()) {
- logger.debug("Get edge with id: " + id);
- }
+ // Now, create the ChampRelationship object for our edge and store it in
+ // the graph database.
+ return edgeFromChampRelationship(champApi.storeRelationship(
+ new ChampRelationship.Builder(sourceObject.get(), targetObject.get(), type).properties(properties).build()));
- try {
+ } catch (ChampMarshallingException | ChampObjectNotExistsException | ChampSchemaViolationException
+ | ChampRelationshipNotExistsException | ChampUnmarshallingException | NumberFormatException
+ | ChampTransactionException e) {
- // Request the edge from the graph db.
- Optional<ChampRelationship> relationship = champApi.retrieveRelationship(getRelKey(id));
+ throw new CrudException("Error creating edge: " + e.getMessage(),
+ javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
- // Did we find it?
- if (relationship.isPresent() && relationship.get().getType().equals(type)) {
+ @Override
+ public List<Edge> getEdges(String type, Map<String, Object> filter) throws CrudException {
- // Yup - return the result.
- return edgeFromChampRelationship(relationship.get());
+ filter.put(ChampRelationship.ReservedPropertyKeys.CHAMP_RELATIONSHIP_TYPE.toString(), type);
- } else {
+ Stream<ChampRelationship> retrievedRelationships;
+ try {
+ retrievedRelationships = champApi.queryRelationships(filter);
- // We didn't find an edge with the supplied id, so throw an exception.
- throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+
+ // Process the result stream from the Champ library into an Edge list,
+ // keeping only
+ // edges of the specified type.
+ List<Edge> edges = retrievedRelationships.map(r -> edgeFromChampRelationship(r)).collect(Collectors.toList());
+
+ return edges;
+ }
+
+ @Override
+ public Edge updateEdge(Edge edge) throws CrudException {
+
+ if (logger.isDebugEnabled()) {
+ logger.debug(
+ "Update edge with id: " + edge.getId() + " with properties: " + propertiesMapToString(edge.getProperties()));
+ }
- } catch (ChampUnmarshallingException | ChampTransactionException e) {
+ try {
+ // Now, build the updated version of the Champ Relationship...
+ ChampRelationship updateRelationship = new ChampRelationship.Builder(
+ buildChampObject(edge.getSource().getId().get(), edge.getSource().getType(),
+ edge.getSource().getProperties()),
+ buildChampObject(edge.getTarget().getId().get(), edge.getTarget().getType(),
+ edge.getTarget().getProperties()),
+ edge.getType()).key(getRelKey(edge.getId().get())).properties(edge.getProperties()).build();
+ // ...and send it to the Champ library.
+ return edgeFromChampRelationship(champApi.replaceRelationship(updateRelationship));
+
+ } catch (ChampRelationshipNotExistsException ex) {
+ throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ } catch (NumberFormatException | ChampUnmarshallingException | ChampMarshallingException
+ | ChampSchemaViolationException | ChampTransactionException ex) {
+
+ throw new CrudException(ex.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public void deleteVertex(String id, String type) throws CrudException {
+
+ try {
+
+ // First, retrieve the vertex that we intend to delete.
+ Optional<ChampObject> retrievedVertex = champApi.retrieveObject(Long.parseLong(id));
+
+ // Did we find it?
+ if (!retrievedVertex.isPresent() || !retrievedVertex.get().getType().equals(type)) {
+ throw new CrudException("Failed to delete vertex with id: " + id + " - vertex does not exist.",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+
+ // Now, verify that there are no edges incident to the vertex (they must
+ // be deleted
+ // first if so).
+ Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get());
+
+ if (relationships.count() > 0) {
+ throw new CrudException("Attempt to delete vertex with id " + id + " which has incident edges.",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
+
+ // Finally, we can attempt to delete our vertex.
+ champApi.deleteObject(Long.parseLong(id));
+
+ } catch (NumberFormatException | ChampUnmarshallingException | ChampObjectNotExistsException
+ | ChampTransactionException e) {
+
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public void deleteEdge(String id, String type) throws CrudException {
+
+ try {
+
+ // First, retrieve the edge that we want to delete.
+ Optional<ChampRelationship> relationshipToDelete = champApi.retrieveRelationship(getRelKey(id));
+
+ // Did we find it?
+ if (!relationshipToDelete.isPresent() || !relationshipToDelete.get().getType().equals(type)) {
+ throw new CrudException("Failed to delete edge with id: " + id + " - edge does not exist",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+
+ // Now we can delete the edge.
+ champApi.deleteRelationship(relationshipToDelete.get());
+
+ } catch (ChampRelationshipNotExistsException | NumberFormatException | ChampUnmarshallingException
+ | ChampTransactionException e) {
+
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ /**
+ * This helper method generates a string representation of a properties map
+ * for logging purposes.
+ *
+ * @param properties
+ * - The properties map to be converted.
+ * @return - The log statement friendly conversion of the properties map.
+ */
+ private String propertiesMapToString(Map<String, Object> properties) {
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("{");
+
+ for (String key : properties.keySet()) {
+ sb.append("(").append(key).append(" -> ").append(properties.get(key)).append(") ");
+ }
+
+ sb.append("}");
+
+ return sb.toString();
+ }
+
+ /**
+ * This helper method constructs a {@link ChampObject} suitable for passing to
+ * the Champ library.
+ *
+ * @param type
+ * - The type to assign to our ChampObject
+ * @param properties
+ * - The set of properties to assign to our ChampObject
+ * @return - A populated ChampObject
+ */
+ private ChampObject buildChampObject(String type, Map<String, Object> properties) {
+
+ ObjectBuildOrPropertiesStep objectInProgress = ChampObject.create().ofType(type).withoutKey();
+
+ for (String key : properties.keySet()) {
+ objectInProgress.withProperty(key, properties.get(key));
+ }
+ return objectInProgress.build();
+ }
+
+ /**
+ * This helper method constructs a {@link ChampObject} suitable for passing to
+ * the Champ library.
+ *
+ * @param id
+ * - Unique identifier for this object.
+ * @param type
+ * - The type to assign to our ChampObject
+ * @param properties
+ * - The set of properties to assign to our ChampObject
+ * @return - A populated ChampObject
+ */
+ private ChampObject buildChampObject(String id, String type, Map<String, Object> properties) {
+
+ ObjectBuildOrPropertiesStep objectInProgress = ChampObject.create().ofType(type).withKey(Long.parseLong(id));
+
+ for (String key : properties.keySet()) {
+ objectInProgress.withProperty(key, properties.get(key));
+ }
+ return objectInProgress.build();
+ }
+
+ private Vertex vertexFromChampObject(ChampObject champObject, String type) {
+
+ // Get the identifier for this vertex from the Champ object.
+ Object id = champObject.getKey().orElse("");
+
+ // Start building our {@link Vertex} object.
+ Vertex.Builder vertexBuilder = new Vertex.Builder(type);
+ vertexBuilder.id(id.toString());
+
+ // Convert the properties associated with the Champ object into the form
+ // expected for
+ // a Vertex object.
+ for (String key : champObject.getProperties().keySet()) {
+ vertexBuilder.property(key, champObject.getProperties().get(key));
+ }
+
+ // ...and return it.
+ return vertexBuilder.build();
+ }
+
+ /**
+ * This helper method converts a {@link ChampRelationship} from the Champ
+ * library into an equivalent {@link Edge} object that is understood by the
+ * CRUD Service.
+ *
+ * @param relationship
+ * - The ChampRelationship object to be converted.
+ * @return - An Edge object corresponding to the supplied ChampRelationship
+ */
+ private Edge edgeFromChampRelationship(ChampRelationship relationship) {
+
+ // Populate the edge's id, if available.
+ Object relationshipId = relationship.getKey().orElse("");
+
+ Edge.Builder edgeBuilder = new Edge.Builder(relationship.getType()).id(relationshipId.toString());
+ edgeBuilder.source(vertexFromChampObject(relationship.getSource(),
+ relationship.getSource().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) == null
+ ? relationship.getSource().getType()
+ : relationship.getSource().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()));
+ edgeBuilder.target(vertexFromChampObject(relationship.getTarget(),
+ relationship.getTarget().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) == null
+ ? relationship.getTarget().getType()
+ : relationship.getTarget().getProperties()
+ .get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()));
+
+ for (String key : relationship.getProperties().keySet()) {
+ edgeBuilder.property(key, relationship.getProperties().get(key).toString());
+ }
+
+ return edgeBuilder.build();
+ }
+
+ /**
+ * Performs any necessary shut down operations when the DAO is no longer
+ * needed.
+ */
+ public void close() {
+
+ if (champApi != null) {
+
+ logger.info(CrudServiceMsgs.STOPPING_CHAMP_DAO);
+
+ champApi.shutdown();
+ }
+ }
+
+ @Override
+ public String openTransaction() {
+
+ ChampTransaction transaction = champApi.openTransaction();
+
+ transactions.put(transaction.id(), transaction);
+ logger.info(CrudServiceMsgs.TRANSACTION, "Stored transaction " + transaction.id() + " in hashmap");
+ logger.info(CrudServiceMsgs.TRANSACTION, "Hash map contents:");
+ for (String key : transactions.keySet()) {
+ logger.info(CrudServiceMsgs.TRANSACTION, key);
+ }
+ return transaction.id();
+ }
+
+ @Override
+ public void commitTransaction(String id) throws CrudException {
+
+ try {
+ champApi.commitTransaction(getTransaction(id));
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Error while commiting transaction " + id,
+ javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ transactions.remove(id);
+ }
+
+ @Override
+ public void rollbackTransaction(String id) throws CrudException {
+
+ try {
+ champApi.rollbackTransaction(getTransaction(id));
+ } catch (ChampTransactionException e) {
+ throw new CrudException("Error while transaction rollback " + id,
+ javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ transactions.remove(id);
+ }
+
+ private ChampTransaction getTransaction(String id) throws CrudException {
+
+ logger.info(CrudServiceMsgs.TRANSACTION, "Looking up transaction " + id);
+ if (transactions.containsKey(id)) {
+ logger.info(CrudServiceMsgs.TRANSACTION, "Found it!");
+ return (transactions.get(id));
+ } else {
+ logger.info(CrudServiceMsgs.TRANSACTION, "Didn't find transaction id " + id + ". Hash map contains: ");
+ for (String key : transactions.keySet()) {
+ logger.info(CrudServiceMsgs.TRANSACTION, key);
+ }
+ throw new CrudException("No open transaction with id: " + id, javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+ }
+
+ @Override
+ public Vertex addVertex(String type, Map<String, Object> properties, String txId) throws CrudException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Add/update vertex: {label: " + type + " properties:" + propertiesMapToString(properties));
+ }
+
+ // Add the aai_node_type so that AAI can read the data created by gizmo
+ properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
+
+ // Create an object to represent our vertex in the format expected by the
+ // Champ library.
+ ChampObject objectToCreate = buildChampObject(type, properties);
+
+ try {
+
+ // Ask the Champ library to store our vertex, placing the returned object
+ // into a
+ // list so that we can easily put that into our result object.
+ return vertexFromChampObject(champApi.storeObject(objectToCreate, Optional.of(getTransaction(txId))), type);
+
+ } catch (ChampMarshallingException | ChampSchemaViolationException | ChampObjectNotExistsException
+ | ChampTransactionException e) {
+
+ // Something went wrong - throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties, String txId)
+ throws CrudException {
+ // For now, assume source and target are straight ids...
+ try {
+
+ Optional<ChampObject> sourceObject = champApi.retrieveObject(Long.parseLong(source.getId().get()),
+ Optional.of(getTransaction(txId)));
+ if (!sourceObject.isPresent() || !sourceObject.get().getType().equals(source.getType())) {
+ throw new CrudException(
+ "Error creating edge - source vertex with id " + source + " does not exist in graph data base",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
+
+ Optional<ChampObject> targetObject = champApi.retrieveObject(Long.parseLong(target.getId().get()),
+ Optional.of(getTransaction(txId)));
+ if (!targetObject.isPresent() || !targetObject.get().getType().equals(target.getType())) {
+ throw new CrudException(
+ "Error creating edge - target vertex with id " + target + " does not exist in graph data base",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
+
+ // Now, create the ChampRelationship object for our edge and store it in
+ // the graph database.
+ return edgeFromChampRelationship(champApi.storeRelationship(
+ new ChampRelationship.Builder(sourceObject.get(), targetObject.get(), type).properties(properties).build(),
+ Optional.of(getTransaction(txId))));
+
+ } catch (ChampMarshallingException | ChampObjectNotExistsException | ChampSchemaViolationException
+ | ChampTransactionException | ChampRelationshipNotExistsException | ChampUnmarshallingException e) {
+
+ throw new CrudException("Error creating edge: " + e.getMessage(),
+ javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+
+ }
+
+ @Override
+ public Vertex updateVertex(String id, String type, Map<String, Object> properties, String txId) throws CrudException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Update vertex with id: " + id + " with properties: " + propertiesMapToString(properties));
+ }
+ // Add the aai_node_type so that AAI can read the data created by gizmo
+ properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
+
+ try {
+ // Now, build the updated version of the Champ Object...
+ ChampObject updateObject = buildChampObject(id, type, properties);
+ // ...and send it to the Champ library.
+ return vertexFromChampObject(champApi.replaceObject(updateObject, Optional.of(getTransaction(txId))), type);
+
+ } catch (ChampObjectNotExistsException e) {
+ throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ } catch (NumberFormatException | ChampMarshallingException | ChampTransactionException
+ | ChampSchemaViolationException e) {
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public boolean transactionExists(String id) throws CrudException {
+ return transactions.containsKey(id);
+ }
+
+ @Override
+ public void deleteVertex(String id, String type, String txId) throws CrudException {
+ try {
+
+ // First, retrieve the vertex that we intend to delete.
+ Optional<ChampObject> retrievedVertex = champApi.retrieveObject(Long.parseLong(id),
+ Optional.of(getTransaction(txId)));
+
+ // Did we find it?
+ if (!retrievedVertex.isPresent() || !retrievedVertex.get().getType().equals(type)) {
+ throw new CrudException("Failed to delete vertex with id: " + id + " - vertex does not exist.",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+
+ // Now, verify that there are no edges incident to the vertex (they must
+ // be deleted
+ // first if so).
+ Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get(),
+ Optional.of(getTransaction(txId)));
+
+ if (relationships.count() > 0) {
+ throw new CrudException("Attempt to delete vertex with id " + id + " which has incident edges.",
+ javax.ws.rs.core.Response.Status.BAD_REQUEST);
+ }
+
+ // Finally, we can attempt to delete our vertex.
+ champApi.deleteObject(Long.parseLong(id), Optional.of(getTransaction(txId)));
+
+ } catch (NumberFormatException | ChampUnmarshallingException | ChampObjectNotExistsException
+ | ChampTransactionException e) {
+
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+
+ }
+
+ @Override
+ public Edge updateEdge(Edge edge, String txId) throws CrudException {
+ if (logger.isDebugEnabled()) {
+ logger.debug(
+ "Update edge with id: " + edge.getId() + " with properties: " + propertiesMapToString(edge.getProperties()));
+ }
+
+ try {
+ // Now, build the updated version of the Champ Relationship...
+ ChampRelationship updateRelationship = new ChampRelationship.Builder(
+ buildChampObject(edge.getSource().getId().get(), edge.getSource().getType(),
+ edge.getSource().getProperties()),
+ buildChampObject(edge.getTarget().getId().get(), edge.getTarget().getType(),
+ edge.getTarget().getProperties()),
+ edge.getType()).key(getRelKey(edge.getId().get())).properties(edge.getProperties()).build();
+ // ...and send it to the Champ library.
+ return edgeFromChampRelationship(
+ champApi.replaceRelationship(updateRelationship, Optional.of(getTransaction(txId))));
+
+ } catch (ChampRelationshipNotExistsException ex) {
+ throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ } catch (NumberFormatException | ChampUnmarshallingException | ChampMarshallingException
+ | ChampSchemaViolationException | ChampTransactionException ex) {
+
+ throw new CrudException(ex.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
+
+ @Override
+ public void deleteEdge(String id, String type, String txId) throws CrudException {
+ try {
+
+ // First, retrieve the edge that we want to delete.
+ Optional<ChampRelationship> relationshipToDelete = champApi.retrieveRelationship(getRelKey(id),
+ Optional.of(getTransaction(txId)));
+
+ // Did we find it?
+ if (!relationshipToDelete.isPresent() || !relationshipToDelete.get().getType().equals(type)) {
+ throw new CrudException("Failed to delete edge with id: " + id + " - edge does not exist",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
+
+ // Now we can delete the edge.
+ champApi.deleteRelationship(relationshipToDelete.get(), Optional.of(getTransaction(txId)));
+
+ } catch (ChampRelationshipNotExistsException | NumberFormatException | ChampUnmarshallingException
+ | ChampTransactionException e) {
+
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+
+ }
+
+ @Override
+ public Edge getEdge(String id, String type, String txId) throws CrudException {
+ if (logger.isDebugEnabled()) {
+ logger.debug("Get edge with id: " + id);
+ }
+
+ try {
+
+ // Request the edge from the graph db.
+ Optional<ChampRelationship> relationship = champApi.retrieveRelationship(getRelKey(id),
+ Optional.of(getTransaction(txId)));
+
+ // Did we find it?
+ if (relationship.isPresent() && relationship.get().getType().equals(type)) {
+
+ // Yup - return the result.
+ return edgeFromChampRelationship(relationship.get());
+
+ } else {
+
+ // We didn't find an edge with the supplied id, so throw an exception.
+ throw new CrudException("No edge with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
+ }
- // Something went wrong, so throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties) throws CrudException {
-
- // For now, assume source and target are straight ids...
- try {
-
- Optional<ChampObject> sourceObject = champApi.retrieveObject(Long.parseLong(source.getId().get()));
- if (!sourceObject.isPresent() || !sourceObject.get().getType().equals(source.getType())) {
- throw new CrudException("Error creating edge - source vertex with id " + source + " does not exist in graph data base",
- javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- Optional<ChampObject> targetObject = champApi.retrieveObject(Long.parseLong(target.getId().get()));
- if (!targetObject.isPresent() || !targetObject.get().getType().equals(target.getType())) {
- throw new CrudException("Error creating edge - target vertex with id " + target + " does not exist in graph data base",
- javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- // Now, create the ChampRelationship object for our edge and store it in
- // the graph database.
- return edgeFromChampRelationship(
- champApi.storeRelationship(new ChampRelationship.Builder(sourceObject.get(), targetObject.get(), type).properties(properties).build()));
-
- } catch (ChampMarshallingException | ChampObjectNotExistsException | ChampSchemaViolationException | ChampRelationshipNotExistsException
- | ChampUnmarshallingException | NumberFormatException | ChampTransactionException e) {
-
- throw new CrudException("Error creating edge: " + e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public List<Edge> getEdges(String type, Map<String, Object> filter) throws CrudException {
-
- filter.put(ChampRelationship.ReservedPropertyKeys.CHAMP_RELATIONSHIP_TYPE.toString(), type);
-
- Stream<ChampRelationship> retrievedRelationships;
- try {
- retrievedRelationships = champApi.queryRelationships(filter);
-
- } catch (ChampTransactionException e) {
- throw new CrudException("Transaction error occured", javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
-
- // Process the result stream from the Champ library into an Edge list, keeping only
- // edges of the specified type.
- List<Edge> edges = retrievedRelationships.map(r -> edgeFromChampRelationship(r)).collect(Collectors.toList());
-
- return edges;
- }
-
- @Override
- public Edge updateEdge(Edge edge) throws CrudException {
-
- if (logger.isDebugEnabled()) {
- logger.debug("Update edge with id: " + edge.getId() + " with properties: " + propertiesMapToString(edge.getProperties()));
- }
-
- try {
- // Now, build the updated version of the Champ Relationship...
- ChampRelationship updateRelationship = new ChampRelationship.Builder(
- buildChampObject(edge.getSource().getId().get(), edge.getSource().getType(), edge.getSource().getProperties()),
- buildChampObject(edge.getTarget().getId().get(), edge.getTarget().getType(), edge.getTarget().getProperties()), edge.getType())
- .key(getRelKey(edge.getId().get())).properties(edge.getProperties()).build();
- // ...and send it to the Champ library.
- return edgeFromChampRelationship(champApi.replaceRelationship(updateRelationship));
-
- } catch (ChampRelationshipNotExistsException ex) {
- throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
- } catch (NumberFormatException | ChampUnmarshallingException | ChampMarshallingException | ChampSchemaViolationException
- | ChampTransactionException ex) {
-
- throw new CrudException(ex.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public void deleteVertex(String id, String type) throws CrudException {
-
- try {
-
- // First, retrieve the vertex that we intend to delete.
- Optional<ChampObject> retrievedVertex = champApi.retrieveObject(Long.parseLong(id));
-
- // Did we find it?
- if (!retrievedVertex.isPresent() || !retrievedVertex.get().getType().equals(type)) {
- throw new CrudException("Failed to delete vertex with id: " + id + " - vertex does not exist.", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
-
- // Now, verify that there are no edges incident to the vertex (they must be deleted
- // first if so).
- Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get());
-
- if (relationships.count() > 0) {
- throw new CrudException("Attempt to delete vertex with id " + id + " which has incident edges.", javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- // Finally, we can attempt to delete our vertex.
- champApi.deleteObject(Long.parseLong(id));
-
- } catch (NumberFormatException | ChampUnmarshallingException | ChampObjectNotExistsException | ChampTransactionException e) {
-
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public void deleteEdge(String id, String type) throws CrudException {
-
- try {
-
- // First, retrieve the edge that we want to delete.
- Optional<ChampRelationship> relationshipToDelete = champApi.retrieveRelationship(getRelKey(id));
-
- // Did we find it?
- if (!relationshipToDelete.isPresent() || !relationshipToDelete.get().getType().equals(type)) {
- throw new CrudException("Failed to delete edge with id: " + id + " - edge does not exist", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
-
- // Now we can delete the edge.
- champApi.deleteRelationship(relationshipToDelete.get());
-
- } catch (ChampRelationshipNotExistsException | NumberFormatException | ChampUnmarshallingException | ChampTransactionException e) {
-
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- /**
- * This helper method generates a string representation of a properties map for logging purposes.
- *
- * @param properties
- * - The properties map to be converted.
- * @return - The log statement friendly conversion of the properties map.
- */
- private String propertiesMapToString(Map<String, Object> properties) {
-
- StringBuilder sb = new StringBuilder();
- sb.append("{");
-
- for (String key : properties.keySet()) {
- sb.append("(").append(key).append(" -> ").append(properties.get(key)).append(") ");
- }
-
- sb.append("}");
-
- return sb.toString();
- }
-
- /**
- * This helper method constructs a {@link ChampObject} suitable for passing to the Champ library.
- *
- * @param type
- * - The type to assign to our ChampObject
- * @param properties
- * - The set of properties to assign to our ChampObject
- * @return - A populated ChampObject
- */
- private ChampObject buildChampObject(String type, Map<String, Object> properties) {
-
- ObjectBuildOrPropertiesStep objectInProgress = ChampObject.create().ofType(type).withoutKey();
-
- for (String key : properties.keySet()) {
- objectInProgress.withProperty(key, properties.get(key));
- }
- return objectInProgress.build();
- }
-
- /**
- * This helper method constructs a {@link ChampObject} suitable for passing to the Champ library.
- *
- * @param id
- * - Unique identifier for this object.
- * @param type
- * - The type to assign to our ChampObject
- * @param properties
- * - The set of properties to assign to our ChampObject
- * @return - A populated ChampObject
- */
- private ChampObject buildChampObject(String id, String type, Map<String, Object> properties) {
-
- ObjectBuildOrPropertiesStep objectInProgress = ChampObject.create().ofType(type).withKey(Long.parseLong(id));
-
- for (String key : properties.keySet()) {
- objectInProgress.withProperty(key, properties.get(key));
- }
- return objectInProgress.build();
- }
-
- private Vertex vertexFromChampObject(ChampObject champObject, String type) {
-
- // Get the identifier for this vertex from the Champ object.
- Object id = champObject.getKey().orElse("");
-
- // Start building our {@link Vertex} object.
- Vertex.Builder vertexBuilder = new Vertex.Builder(type);
- vertexBuilder.id(id.toString());
-
- // Convert the properties associated with the Champ object into the form expected for
- // a Vertex object.
- for (String key : champObject.getProperties().keySet()) {
- vertexBuilder.property(key, champObject.getProperties().get(key));
- }
-
- // ...and return it.
- return vertexBuilder.build();
- }
-
- /**
- * This helper method converts a {@link ChampRelationship} from the Champ library into an equivalent {@link Edge}
- * object that is understood by the CRUD Service.
- *
- * @param relationship
- * - The ChampRelationship object to be converted.
- * @return - An Edge object corresponding to the supplied ChampRelationship
- */
- private Edge edgeFromChampRelationship(ChampRelationship relationship) {
-
- // Populate the edge's id, if available.
- Object relationshipId = relationship.getKey().orElse("");
-
- Edge.Builder edgeBuilder = new Edge.Builder(relationship.getType()).id(relationshipId.toString());
- edgeBuilder.source(vertexFromChampObject(relationship.getSource(),
- relationship.getSource().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) == null
- ? relationship.getSource().getType()
- : relationship.getSource().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()));
- edgeBuilder.target(vertexFromChampObject(relationship.getTarget(),
- relationship.getTarget().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()) == null
- ? relationship.getTarget().getType()
- : relationship.getTarget().getProperties().get(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName()).toString()));
-
- for (String key : relationship.getProperties().keySet()) {
- edgeBuilder.property(key, relationship.getProperties().get(key).toString());
- }
-
- return edgeBuilder.build();
- }
-
- /**
- * Performs any necessary shut down operations when the DAO is no longer needed.
- */
- public void close() {
-
- if (champApi != null) {
-
- logger.info(CrudServiceMsgs.STOPPING_CHAMP_DAO);
-
- champApi.shutdown();
- }
- }
-
- @Override
- public String openTransaction() {
-
- ChampTransaction transaction = champApi.openTransaction();
-
- transactions.put(transaction.id(), transaction);
- logger.info(CrudServiceMsgs.TRANSACTION, "Stored transaction " + transaction.id() + " in hashmap");
- logger.info(CrudServiceMsgs.TRANSACTION, "Hash map contents:");
- for (String key : transactions.keySet()) {
- logger.info(CrudServiceMsgs.TRANSACTION, key);
- }
- return transaction.id();
- }
-
- @Override
- public void commitTransaction(String id) throws CrudException {
-
- try {
- champApi.commitTransaction(getTransaction(id));
- } catch (ChampTransactionException e) {
- throw new CrudException("Error while commiting transaction " + id, javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- transactions.remove(id);
- }
-
- @Override
- public void rollbackTransaction(String id) throws CrudException {
-
- try {
- champApi.rollbackTransaction(getTransaction(id));
- } catch (ChampTransactionException e) {
- throw new CrudException("Error while transaction rollback " + id, javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- transactions.remove(id);
- }
-
- private ChampTransaction getTransaction(String id) throws CrudException {
-
- logger.info(CrudServiceMsgs.TRANSACTION, "Looking up transaction " + id);
- if (transactions.containsKey(id)) {
- logger.info(CrudServiceMsgs.TRANSACTION, "Found it!");
- return (transactions.get(id));
- } else {
- logger.info(CrudServiceMsgs.TRANSACTION, "Didn't find transaction id " + id + ". Hash map contains: ");
- for (String key : transactions.keySet()) {
- logger.info(CrudServiceMsgs.TRANSACTION, key);
- }
- throw new CrudException("No open transaction with id: " + id, javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
- }
-
- @Override
- public Vertex addVertex(String type, Map<String, Object> properties, String txId) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Add/update vertex: {label: " + type + " properties:" + propertiesMapToString(properties));
- }
-
- // Add the aai_node_type so that AAI can read the data created by gizmo
- properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
-
- // Create an object to represent our vertex in the format expected by the Champ library.
- ChampObject objectToCreate = buildChampObject(type, properties);
-
- try {
-
- // Ask the Champ library to store our vertex, placing the returned object into a
- // list so that we can easily put that into our result object.
- return vertexFromChampObject(champApi.storeObject(objectToCreate, Optional.of(getTransaction(txId))), type);
-
- } catch (ChampMarshallingException | ChampSchemaViolationException | ChampObjectNotExistsException | ChampTransactionException e) {
-
- // Something went wrong - throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties, String txId) throws CrudException {
- // For now, assume source and target are straight ids...
- try {
-
- Optional<ChampObject> sourceObject = champApi.retrieveObject(Long.parseLong(source.getId().get()), Optional.of(getTransaction(txId)));
- if (!sourceObject.isPresent() || !sourceObject.get().getType().equals(source.getType())) {
- throw new CrudException("Error creating edge - source vertex with id " + source + " does not exist in graph data base",
- javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- Optional<ChampObject> targetObject = champApi.retrieveObject(Long.parseLong(target.getId().get()), Optional.of(getTransaction(txId)));
- if (!targetObject.isPresent() || !targetObject.get().getType().equals(target.getType())) {
- throw new CrudException("Error creating edge - target vertex with id " + target + " does not exist in graph data base",
- javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- // Now, create the ChampRelationship object for our edge and store it in
- // the graph database.
- return edgeFromChampRelationship(
- champApi.storeRelationship(new ChampRelationship.Builder(sourceObject.get(), targetObject.get(), type).properties(properties).build(),
- Optional.of(getTransaction(txId))));
-
- } catch (ChampMarshallingException | ChampObjectNotExistsException | ChampSchemaViolationException | ChampTransactionException
- | ChampRelationshipNotExistsException | ChampUnmarshallingException e) {
-
- throw new CrudException("Error creating edge: " + e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
-
- }
-
- @Override
- public Vertex updateVertex(String id, String type, Map<String, Object> properties, String txId) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Update vertex with id: " + id + " with properties: " + propertiesMapToString(properties));
- }
- // Add the aai_node_type so that AAI can read the data created by gizmo
- properties.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
-
- try {
- // Now, build the updated version of the Champ Object...
- ChampObject updateObject = buildChampObject(id, type, properties);
- // ...and send it to the Champ library.
- return vertexFromChampObject(champApi.replaceObject(updateObject, Optional.of(getTransaction(txId))), type);
-
- } catch (ChampObjectNotExistsException e) {
- throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
- } catch (NumberFormatException | ChampMarshallingException | ChampTransactionException | ChampSchemaViolationException e) {
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public boolean transactionExists(String id) throws CrudException {
- return transactions.containsKey(id);
- }
-
- @Override
- public void deleteVertex(String id, String type, String txId) throws CrudException {
- try {
-
- // First, retrieve the vertex that we intend to delete.
- Optional<ChampObject> retrievedVertex = champApi.retrieveObject(Long.parseLong(id), Optional.of(getTransaction(txId)));
-
- // Did we find it?
- if (!retrievedVertex.isPresent() || !retrievedVertex.get().getType().equals(type)) {
- throw new CrudException("Failed to delete vertex with id: " + id + " - vertex does not exist.", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
-
- // Now, verify that there are no edges incident to the vertex (they must be deleted
- // first if so).
- Stream<ChampRelationship> relationships = champApi.retrieveRelationships(retrievedVertex.get(), Optional.of(getTransaction(txId)));
-
- if (relationships.count() > 0) {
- throw new CrudException("Attempt to delete vertex with id " + id + " which has incident edges.", javax.ws.rs.core.Response.Status.BAD_REQUEST);
- }
-
- // Finally, we can attempt to delete our vertex.
- champApi.deleteObject(Long.parseLong(id), Optional.of(getTransaction(txId)));
-
- } catch (NumberFormatException | ChampUnmarshallingException | ChampObjectNotExistsException | ChampTransactionException e) {
-
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
-
- }
-
- @Override
- public Edge updateEdge(Edge edge, String txId) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Update edge with id: " + edge.getId() + " with properties: " + propertiesMapToString(edge.getProperties()));
- }
-
- try {
- // Now, build the updated version of the Champ Relationship...
- ChampRelationship updateRelationship = new ChampRelationship.Builder(
- buildChampObject(edge.getSource().getId().get(), edge.getSource().getType(), edge.getSource().getProperties()),
- buildChampObject(edge.getTarget().getId().get(), edge.getTarget().getType(), edge.getTarget().getProperties()), edge.getType())
- .key(getRelKey(edge.getId().get())).properties(edge.getProperties()).build();
- // ...and send it to the Champ library.
- return edgeFromChampRelationship(champApi.replaceRelationship(updateRelationship, Optional.of(getTransaction(txId))));
-
- } catch (ChampRelationshipNotExistsException ex) {
- throw new CrudException("Not Found", javax.ws.rs.core.Response.Status.NOT_FOUND);
- } catch (NumberFormatException | ChampUnmarshallingException | ChampMarshallingException | ChampSchemaViolationException
- | ChampTransactionException ex) {
-
- throw new CrudException(ex.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
-
- @Override
- public void deleteEdge(String id, String type, String txId) throws CrudException {
- try {
-
- // First, retrieve the edge that we want to delete.
- Optional<ChampRelationship> relationshipToDelete = champApi.retrieveRelationship(getRelKey(id), Optional.of(getTransaction(txId)));
-
- // Did we find it?
- if (!relationshipToDelete.isPresent() || !relationshipToDelete.get().getType().equals(type)) {
- throw new CrudException("Failed to delete edge with id: " + id + " - edge does not exist", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
-
- // Now we can delete the edge.
- champApi.deleteRelationship(relationshipToDelete.get(), Optional.of(getTransaction(txId)));
-
- } catch (ChampRelationshipNotExistsException | NumberFormatException | ChampUnmarshallingException | ChampTransactionException e) {
-
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
-
- }
-
- @Override
- public Edge getEdge(String id, String type, String txId) throws CrudException {
- if (logger.isDebugEnabled()) {
- logger.debug("Get edge with id: " + id);
- }
-
- try {
-
- // Request the edge from the graph db.
- Optional<ChampRelationship> relationship = champApi.retrieveRelationship(getRelKey(id), Optional.of(getTransaction(txId)));
-
- // Did we find it?
- if (relationship.isPresent() && relationship.get().getType().equals(type)) {
-
- // Yup - return the result.
- return edgeFromChampRelationship(relationship.get());
-
- } else {
-
- // We didn't find an edge with the supplied id, so throw an exception.
- throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
- }
-
- } catch (ChampUnmarshallingException | ChampTransactionException e) {
-
- // Something went wrong, so throw an exception.
- throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
- }
- }
+ } catch (ChampUnmarshallingException | ChampTransactionException e) {
+
+ // Something went wrong, so throw an exception.
+ throw new CrudException(e.getMessage(), javax.ws.rs.core.Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ }
}
private Logger logger = LoggerFactory.getInstance().getLogger(ChampionDao.class.getName());
- // We use a custom vertex serializer for Champion because it expects "key" instead of "id"
+ // We use a custom vertex serializer for Champion because it expects "key"
+ // instead of "id"
private static final Gson championGson = new GsonBuilder()
.registerTypeAdapterFactory(new GsonJava8TypeAdapterFactory())
.registerTypeAdapter(Vertex.class, new ChampionVertexSerializer())
- .registerTypeAdapter(Edge.class, new ChampionEdgeSerializer())
- .create();
+ .registerTypeAdapter(Edge.class, new ChampionEdgeSerializer()).create();
public ChampionDao(String championUrl, String certPassword) {
try {
- client = new RestClient().authenticationMode(RestAuthenticationMode.SSL_CERT)
- .validateServerHostname(false)
- .validateServerCertChain(false)
- .clientCertFile(CrudServiceConstants.CRD_CHAMPION_AUTH_FILE)
+ client = new RestClient().authenticationMode(RestAuthenticationMode.SSL_CERT).validateServerHostname(false)
+ .validateServerCertChain(false).clientCertFile(CrudServiceConstants.CRD_CHAMPION_AUTH_FILE)
.clientCertPassword(Password.deobfuscate(certPassword));
baseUrl = championUrl;
if (getResult.getResultCode() == 200) {
return Vertex.fromJson(getResult.getResult());
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
Vertex vert = Vertex.fromJson(getResult.getResult());
if (!vert.getType().equalsIgnoreCase(type)) {
- // We didn't find a vertex with the supplied type, so just throw an exception.
- throw new CrudException("No vertex with id " + id + "and type " + type + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied type, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + "and type " + type + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
return vert;
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
OperationResult getResult = client.get(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == 200) {
- return championGson.fromJson(getResult.getResult(), new TypeToken<List<Edge>>(){}.getType());
+ return championGson.fromJson(getResult.getResult(), new TypeToken<List<Edge>>() {
+ }.getType());
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
public List<Vertex> getVertices(String type, Map<String, Object> filter) throws CrudException {
filter.put(org.openecomp.schema.OxmModelValidator.Metadata.NODE_TYPE.propertyName(), type);
- String url = baseUrl + "objects/filter" + "?" +
- URLEncodedUtils.format(convertToNameValuePair(filter), Charset.defaultCharset());
+ String url = baseUrl + "objects/filter" + "?"
+ + URLEncodedUtils.format(convertToNameValuePair(filter), Charset.defaultCharset());
Map<String, List<String>> headers = new HashMap<>();
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
OperationResult getResult = client.get(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == 200) {
- return championGson.fromJson(getResult.getResult(), new TypeToken<List<Vertex>>(){}.getType());
+ return championGson.fromJson(getResult.getResult(), new TypeToken<List<Vertex>>() {
+ }.getType());
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
- throw new CrudException("No vertices found in graph for given filters", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertices found in graph for given filters",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
Edge edge = Edge.fromJson(getResult.getResult());
if (!edge.getType().equalsIgnoreCase(type)) {
- // We didn't find an edge with the supplied type, so just throw an exception.
- throw new CrudException("No edge with id " + id + "and type " + type + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find an edge with the supplied type, so just throw an
+ // exception.
+ throw new CrudException("No edge with id " + id + "and type " + type + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
return edge;
} else {
- // We didn't find a edge with the supplied type, so just throw an exception.
+ // We didn't find a edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
@Override
public List<Edge> getEdges(String type, Map<String, Object> filter) throws CrudException {
- String url = baseUrl + "relationships/filter" + "?" +
- URLEncodedUtils.format(convertToNameValuePair(filter), Charset.defaultCharset());
+ String url = baseUrl + "relationships/filter" + "?"
+ + URLEncodedUtils.format(convertToNameValuePair(filter), Charset.defaultCharset());
Map<String, List<String>> headers = new HashMap<>();
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
OperationResult getResult = client.get(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == 200) {
- return championGson.fromJson(getResult.getResult(), new TypeToken<List<Edge>>(){}.getType());
+ return championGson.fromJson(getResult.getResult(), new TypeToken<List<Edge>>() {
+ }.getType());
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
throw new CrudException("No edges found in graph for given filters", javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
properties.forEach(insertVertexBuilder::property);
Vertex insertVertex = insertVertexBuilder.build();
- OperationResult getResult = client.post(url, insertVertex.toJson(), headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.post(url, insertVertex.toJson(), headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.CREATED.getStatusCode()) {
return Vertex.fromJson(getResult.getResult());
} else {
- // We didn't create a vertex with the supplied type, so just throw an exception.
+ // We didn't create a vertex with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to create vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
Vertex insertVertex = insertVertexBuilder.build();
String payload = insertVertex.toJson(championGson);
- OperationResult getResult = client.put(url, payload, headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.put(url, payload, headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.OK.getStatusCode()) {
return Vertex.fromJson(getResult.getResult());
} else {
- // We didn't create a vertex with the supplied type, so just throw an exception.
+ // We didn't create a vertex with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to update vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
OperationResult getResult = client.delete(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() != Response.Status.OK.getStatusCode()) {
- // We didn't delete a vertex with the supplied id, so just throw an exception.
+ // We didn't delete a vertex with the supplied id, so just throw an
+ // exception.
throw new CrudException("Failed to delete vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
Edge insertEdge = insertEdgeBuilder.build();
String edgeJson = insertEdge.toJson(championGson);
- OperationResult getResult = client.post(url, edgeJson, headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.post(url, edgeJson, headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.CREATED.getStatusCode()) {
return Edge.fromJson(getResult.getResult());
} else {
- // We didn't create an edge with the supplied type, so just throw an exception.
+ // We didn't create an edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to create edge", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
@Override
public Edge updateEdge(Edge edge) throws CrudException {
- if (!edge.getId().isPresent())
- {
+ if (!edge.getId().isPresent()) {
throw new CrudException("Unable to identify edge: " + edge.toString(), Response.Status.BAD_REQUEST);
}
String url = baseUrl + "relationships/" + edge.getId().get();
headers.put(HEADER_TRANS_ID, Arrays.asList(MDC.get(LoggingContext.LoggingField.REQUEST_ID.toString())));
String edgeJson = edge.toJson(championGson);
- OperationResult getResult = client.put(url, edgeJson, headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.put(url, edgeJson, headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.OK.getStatusCode()) {
return Edge.fromJson(getResult.getResult());
} else {
- // We didn't create an edge with the supplied type, so just throw an exception.
+ // We didn't create an edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to update edge", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
OperationResult getResult = client.delete(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() != 200) {
- // We didn't find an edge with the supplied type, so just throw an exception.
+ // We didn't find an edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
headers.put(HEADER_TRANS_ID, Arrays.asList(MDC.get(LoggingContext.LoggingField.REQUEST_ID.toString())));
- OperationResult getResult = client.put(url, "{\"method\": \"commit\"}", headers, MediaType.APPLICATION_JSON_TYPE, MediaType.TEXT_PLAIN_TYPE);
+ OperationResult getResult = client.put(url, "{\"method\": \"commit\"}", headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.TEXT_PLAIN_TYPE);
if (getResult.getResultCode() != 200) {
- throw new CrudException("Unable to commit transaction", Response.Status.fromStatusCode(getResult.getResultCode()));
+ throw new CrudException("Unable to commit transaction",
+ Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
headers.put(HEADER_TRANS_ID, Arrays.asList(MDC.get(LoggingContext.LoggingField.REQUEST_ID.toString())));
- OperationResult getResult = client.put(url, "{\"method\": \"rollback\"}", headers, MediaType.APPLICATION_JSON_TYPE, MediaType.TEXT_PLAIN_TYPE);
+ OperationResult getResult = client.put(url, "{\"method\": \"rollback\"}", headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.TEXT_PLAIN_TYPE);
if (getResult.getResultCode() != 200) {
- throw new CrudException("Unable to rollback transaction", Response.Status.fromStatusCode(getResult.getResultCode()));
+ throw new CrudException("Unable to rollback transaction",
+ Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
properties.forEach(insertVertexBuilder::property);
Vertex insertVertex = insertVertexBuilder.build();
- OperationResult getResult = client.post(url, insertVertex.toJson(), headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.post(url, insertVertex.toJson(), headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.CREATED.getStatusCode()) {
return Vertex.fromJson(getResult.getResult());
} else {
- // We didn't create a vertex with the supplied type, so just throw an exception.
+ // We didn't create a vertex with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to create vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
@Override
- public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties, String txId) throws CrudException {
+ public Edge addEdge(String type, Vertex source, Vertex target, Map<String, Object> properties, String txId)
+ throws CrudException {
String url = baseUrl + "relationships?transactionId=" + txId;
Map<String, List<String>> headers = new HashMap<>();
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
if (getResult.getResultCode() == Response.Status.CREATED.getStatusCode()) {
return Edge.fromJson(getResult.getResult());
} else {
- // We didn't create an edge with the supplied type, so just throw an exception.
+ // We didn't create an edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to create edge", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
Vertex insertVertex = insertVertexBuilder.build();
String payload = insertVertex.toJson(championGson);
- OperationResult getResult = client.put(url, payload, headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.put(url, payload, headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.OK.getStatusCode()) {
return Vertex.fromJson(getResult.getResult());
} else {
- // We didn't create a vertex with the supplied type, so just throw an exception.
+ // We didn't create a vertex with the supplied type, so just throw an
+ // exception.
throw new CrudException("Failed to update vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
OperationResult getResult = client.delete(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() != Response.Status.OK.getStatusCode()) {
- // We didn't delete a vertex with the supplied id, so just throw an exception.
+ // We didn't delete a vertex with the supplied id, so just throw an
+ // exception.
throw new CrudException("Failed to delete vertex", Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
@Override
public Edge updateEdge(Edge edge, String txId) throws CrudException {
- if (!edge.getId().isPresent())
- {
+ if (!edge.getId().isPresent()) {
throw new CrudException("Unable to identify edge: " + edge.toString(), Response.Status.BAD_REQUEST);
}
String url = baseUrl + "relationships/" + edge.getId().get() + "?transactionId=" + txId;
headers.put(HEADER_FROM_APP, Arrays.asList("Gizmo"));
headers.put(HEADER_TRANS_ID, Arrays.asList(MDC.get(LoggingContext.LoggingField.REQUEST_ID.toString())));
- OperationResult getResult = client.put(url, edge.toJson(championGson), headers,
- MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON_TYPE);
+ OperationResult getResult = client.put(url, edge.toJson(championGson), headers, MediaType.APPLICATION_JSON_TYPE,
+ MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() == Response.Status.OK.getStatusCode()) {
return Edge.fromJson(getResult.getResult());
} else {
- // We didn't create an edge with the supplied type, so just throw an exception.
- throw new CrudException("Failed to update edge: " + getResult.getFailureCause(), Response.Status.fromStatusCode(getResult.getResultCode()));
+ // We didn't create an edge with the supplied type, so just throw an
+ // exception.
+ throw new CrudException("Failed to update edge: " + getResult.getFailureCause(),
+ Response.Status.fromStatusCode(getResult.getResultCode()));
}
}
OperationResult getResult = client.delete(url, headers, MediaType.APPLICATION_JSON_TYPE);
if (getResult.getResultCode() != 200) {
- // We didn't find an edge with the supplied type, so just throw an exception.
+ // We didn't find an edge with the supplied type, so just throw an
+ // exception.
throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
Edge edge = Edge.fromJson(getResult.getResult());
if (!edge.getType().equalsIgnoreCase(type)) {
- // We didn't find an edge with the supplied type, so just throw an exception.
- throw new CrudException("No edge with id " + id + "and type " + type + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find an edge with the supplied type, so just throw an
+ // exception.
+ throw new CrudException("No edge with id " + id + "and type " + type + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
return edge;
} else {
- // We didn't find an edge with the supplied id, so just throw an exception.
+ // We didn't find an edge with the supplied id, so just throw an
+ // exception.
throw new CrudException("No edge with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
Vertex vert = Vertex.fromJson(getResult.getResult());
if (!vert.getType().equalsIgnoreCase(type)) {
- // We didn't find a vertex with the supplied type, so just throw an exception.
- throw new CrudException("No vertex with id " + id + "and type " + type + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied type, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + "and type " + type + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
return vert;
} else {
- // We didn't find a vertex with the supplied id, so just throw an exception.
- throw new CrudException("No vertex with id " + id + " found in graph", javax.ws.rs.core.Response.Status.NOT_FOUND);
+ // We didn't find a vertex with the supplied id, so just throw an
+ // exception.
+ throw new CrudException("No vertex with id " + id + " found in graph",
+ javax.ws.rs.core.Response.Status.NOT_FOUND);
}
}
import java.util.Optional;
public class Edge {
- private static final Gson gson = new GsonBuilder()
- .registerTypeAdapterFactory(new GsonJava8TypeAdapterFactory())
+ private static final Gson gson = new GsonBuilder().registerTypeAdapterFactory(new GsonJava8TypeAdapterFactory())
.create();
- @SerializedName(value="id", alternate={"key"})
+ @SerializedName(value = "id", alternate = { "key" })
private final Optional<String> id;
private final String type;
private final Map<String, Object> properties;
private final Vertex source;
private final Vertex target;
-
private Edge(Builder builder) {
this.id = builder.id;
this.type = builder.type;
}
}
-
@Override
public String toString() {
- return "Edge [id=" + id + ", type=" + type + ", properties=" + properties
- + ", source=" + source + ", target=" + target + "]";
+ return "Edge [id=" + id + ", type=" + type + ", properties=" + properties + ", source=" + source + ", target="
+ + target + "]";
}
public String toJson() {
return target;
}
-
}
import java.util.Optional;
public class Vertex {
- private static final Gson gson = new GsonBuilder()
- .registerTypeAdapterFactory(new GsonJava8TypeAdapterFactory()).create();
+ private static final Gson gson = new GsonBuilder().registerTypeAdapterFactory(new GsonJava8TypeAdapterFactory())
+ .create();
- @SerializedName(value="id", alternate={"key"})
+ @SerializedName(value = "id", alternate = { "key" })
private final Optional<String> id;
private final String type;
private final Map<String, Object> properties;
-
private Vertex(Builder builder) {
this.id = builder.id;
this.type = builder.type;
public enum CrudServiceMsgs implements LogMessageEnum {
/**
- * Received request {0} {1} from {2}. Sending response: {3}
+ * Received request {0} {1} from {2}. Sending response: {3}
*
- * <p>Arguments:
- * {0} = operation
- * {1} = target URL
- * {2} = source
- * {3} = response code
+ * <p>
+ * Arguments: {0} = operation {1} = target URL {2} = source {3} = response
+ * code
*/
PROCESS_REST_REQUEST,
- INVALID_OXM_FILE,
- INVALID_OXM_DIR,
- OXM_FILE_CHANGED,
- TRANSACTION,
+ INVALID_OXM_FILE, INVALID_OXM_DIR, OXM_FILE_CHANGED, TRANSACTION,
/**
* Successfully loaded schema: {0}
*
- * <p>Arguments:
- * {0} = oxm filename
+ * <p>
+ * Arguments: {0} = oxm filename
*/
LOADED_OXM_FILE,
/**
* Unable to load OXM schema: {0}
*
- * <p>Arguments:
- * {0} = error
+ * <p>
+ * Arguments: {0} = error
*/
OXM_LOAD_ERROR,
/**
* Stopping ChampDAO...
*
- * <p>Arguments:
+ * <p>
+ * Arguments:
*/
STOPPING_CHAMP_DAO,
/**
- * Failure instantiating CRUD Rest Service. Cause: {0}
+ * Failure instantiating CRUD Rest Service. Cause: {0}
*
- * <p>Arguments:
- * {0} - Failure cause.
+ * <p>
+ * Arguments: {0} - Failure cause.
*/
INSTANTIATE_AUTH_ERR,
/**
- * Arguments:
- * {0} Opertaion
- * {1} URI
- * {2} = Exception
+ * Arguments: {0} Opertaion {1} URI {2} = Exception
*/
EXCEPTION_DURING_METHOD_CALL;
-
/**
- * Static initializer to ensure the resource bundles for this class are loaded...
+ * Static initializer to ensure the resource bundles for this class are
+ * loaded...
*/
static {
EELFResourceManager.loadMessageBundle("logging/CrudServiceMsgs");
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;
-
public class LoggingUtil {
/**
* Initializes mdc context.
/**
* Logs the rest request.
*/
- public static void logRestRequest(Logger logger, Logger auditLogger,
- HttpServletRequest req, Response response) {
+ public static void logRestRequest(Logger logger, Logger auditLogger, HttpServletRequest req, Response response) {
String respStatusString = "";
if (Response.Status.fromStatusCode(response.getStatus()) != null) {
respStatusString = Response.Status.fromStatusCode(response.getStatus()).toString();
}
// Generate error log
- logger.info(CrudServiceMsgs.PROCESS_REST_REQUEST, req.getMethod(),
- req.getRequestURL().toString(), req.getRemoteHost(),
- Integer.toString(response.getStatus()));
+ logger.info(CrudServiceMsgs.PROCESS_REST_REQUEST, req.getMethod(), req.getRequestURL().toString(),
+ req.getRemoteHost(), Integer.toString(response.getStatus()));
// Generate audit log.
auditLogger.info(CrudServiceMsgs.PROCESS_REST_REQUEST,
- new LogFields()
- .setField(LogLine.DefinedFields.RESPONSE_CODE, response.getStatus())
+ new LogFields().setField(LogLine.DefinedFields.RESPONSE_CODE, response.getStatus())
.setField(LogLine.DefinedFields.RESPONSE_DESCRIPTION, respStatusString),
- (req != null) ? req.getMethod() : "Unknown",
- (req != null) ? req.getRequestURL().toString() : "Unknown",
- (req != null) ? req.getRemoteHost() : "Unknown",
- Integer.toString(response.getStatus()) + " payload: " + (response.getEntity() == null ? ""
- : response.getEntity().toString()));
+ (req != null) ? req.getMethod() : "Unknown", (req != null) ? req.getRequestURL().toString() : "Unknown",
+ (req != null) ? req.getRemoteHost() : "Unknown", Integer.toString(response.getStatus()) + " payload: "
+ + (response.getEntity() == null ? "" : response.getEntity().toString()));
MDC.clear();
}
}
public static final String SOURCE = "source";
public static final String TARGET = "target";
public static final String URL_BASE = "services/inventory/";
-
- public static String buildUpsertBulkResponse(HashMap<String,Vertex> vertices, HashMap<String,Edge> edges , String version,BulkPayload incomingPayload)
- throws CrudException {
-
- for (JsonElement e : incomingPayload.getObjects()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(e.getAsJsonObject().entrySet());
-
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- Vertex responseVertex = vertices.get(item.getKey());
- if(responseVertex != null){
- JsonObject v = gson.fromJson(buildUpsertVertexResponse(responseVertex,version), JsonObject.class);
- item.setValue(v);
- }else{
- item.setValue(gson.fromJson("{}", JsonObject.class));
- }
-
- }
- for (JsonElement e : incomingPayload.getRelationships()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(e.getAsJsonObject().entrySet());
-
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- Edge responseEdge = edges.get(item.getKey());
- if(responseEdge != null){
- JsonObject v = gson.fromJson(buildUpsertEdgeResponse(responseEdge,version), JsonObject.class);
- item.setValue(v);
- }else{
- item.setValue(gson.fromJson("{}", JsonObject.class));
- }
-
- }
- return incomingPayload.toJson();
- }
-
-
-
- public static String buildUpsertVertexResponse(Vertex vertex, String version)
- throws CrudException {
+
+ public static String buildUpsertBulkResponse(HashMap<String, Vertex> vertices, HashMap<String, Edge> edges,
+ String version, BulkPayload incomingPayload) throws CrudException {
+
+ for (JsonElement e : incomingPayload.getObjects()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ e.getAsJsonObject().entrySet());
+
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ Vertex responseVertex = vertices.get(item.getKey());
+ if (responseVertex != null) {
+ JsonObject v = gson.fromJson(buildUpsertVertexResponse(responseVertex, version), JsonObject.class);
+ item.setValue(v);
+ } else {
+ item.setValue(gson.fromJson("{}", JsonObject.class));
+ }
+
+ }
+ for (JsonElement e : incomingPayload.getRelationships()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ e.getAsJsonObject().entrySet());
+
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ Edge responseEdge = edges.get(item.getKey());
+ if (responseEdge != null) {
+ JsonObject v = gson.fromJson(buildUpsertEdgeResponse(responseEdge, version), JsonObject.class);
+ item.setValue(v);
+ } else {
+ item.setValue(gson.fromJson("{}", JsonObject.class));
+ }
+
+ }
+ return incomingPayload.toJson();
+ }
+
+ public static String buildUpsertVertexResponse(Vertex vertex, String version) throws CrudException {
VertexPayload payload = new VertexPayload();
payload.setId(vertex.getId().get());
payload.setType(vertex.getType());
return buildGetEdgeResponse(edge, version);
}
- public static String buildGetVertexResponse(Vertex vertex, List<Edge> edges, String version)
- throws CrudException {
+ public static String buildGetVertexResponse(Vertex vertex, List<Edge> edges, String version) throws CrudException {
VertexPayload vertexPayload = new VertexPayload();
vertexPayload.setId(vertex.getId().get());
vertexPayload.setType(vertex.getType());
EdgePayload inEdge = new EdgePayload();
inEdge.setId(e.getId().get());
inEdge.setType(e.getType());
- inEdge.setUrl(URL_BASE + "relationships/"
- + RelationshipSchemaLoader.getLatestSchemaVersion()
- + "/" + e.getType() + "/" + e.getId().get());
- inEdge.setSource(
- URL_BASE + version + "/" + e.getSource().getType() + "/" + e.getSource().getId().get());
+ inEdge.setUrl(URL_BASE + "relationships/" + RelationshipSchemaLoader.getLatestSchemaVersion() + "/"
+ + e.getType() + "/" + e.getId().get());
+ inEdge.setSource(URL_BASE + version + "/" + e.getSource().getType() + "/" + e.getSource().getId().get());
inEdges.add(inEdge);
} else if (e.getSource().getId().get().equals(vertex.getId().get())) {
EdgePayload outEdge = new EdgePayload();
outEdge.setId(e.getId().get());
outEdge.setType(e.getType());
- outEdge.setUrl(URL_BASE + "relationships/"
- + RelationshipSchemaLoader.getLatestSchemaVersion()
- + "/" + e.getType() + "/" + e.getId().get());
- outEdge.setTarget(
- URL_BASE + version + "/" + e.getTarget().getType() + "/" + e.getTarget().getId().get());
+ outEdge.setUrl(URL_BASE + "relationships/" + RelationshipSchemaLoader.getLatestSchemaVersion() + "/"
+ + e.getType() + "/" + e.getId().get());
+ outEdge.setTarget(URL_BASE + version + "/" + e.getTarget().getType() + "/" + e.getTarget().getId().get());
outEdges.add(outEdge);
}
}
-
vertexPayload.setIn(inEdges);
vertexPayload.setOut(outEdges);
return vertexPayload.toJson();
}
- public static String buildGetVerticesResponse(List<Vertex> items, String version)
- throws CrudException {
+ public static String buildGetVerticesResponse(List<Vertex> items, String version) throws CrudException {
JsonArray arry = new JsonArray();
for (Vertex v : items) {
JsonObject item = new JsonObject();
item.addProperty("id", v.getId().get());
item.addProperty("type", v.getType());
- item.addProperty("url", "services/inventory/" + version + "/"
- + v.getType() + "/" + v.getId().get());
+ item.addProperty("url", "services/inventory/" + version + "/" + v.getType() + "/" + v.getId().get());
arry.add(item);
}
EdgePayload payload = new EdgePayload();
payload.setId(edge.getId().get());
payload.setType(edge.getType());
- payload.setUrl(URL_BASE + "relationships/" + version + "/" + edge.getType()
- + "/" + edge.getId().get());
- payload.setSource(
- URL_BASE + version + "/" + edge.getSource().getType()
- + "/" + edge.getSource().getId().get());
- payload.setTarget(
- URL_BASE + version + "/" + edge.getTarget().getType()
- + "/" + edge.getTarget().getId().get());
+ payload.setUrl(URL_BASE + "relationships/" + version + "/" + edge.getType() + "/" + edge.getId().get());
+ payload.setSource(URL_BASE + version + "/" + edge.getSource().getType() + "/" + edge.getSource().getId().get());
+ payload.setTarget(URL_BASE + version + "/" + edge.getTarget().getType() + "/" + edge.getTarget().getId().get());
JsonObject props = new JsonObject();
for (String key : edge.getProperties().keySet()) {
return payload.toJson();
}
- public static String buildGetEdgesResponse(List<Edge> items, String version)
- throws CrudException {
+ public static String buildGetEdgesResponse(List<Edge> items, String version) throws CrudException {
JsonArray arry = new JsonArray();
for (Edge e : items) {
JsonObject item = new JsonObject();
item.addProperty("id", e.getId().get());
item.addProperty("type", e.getType());
- item.addProperty("url", URL_BASE + "relationships/" + version + "/" + e.getType()
- + "/" + e.getId().get());
- item.addProperty(SOURCE, "services/inventory/" + version + "/" + e.getSource().getType()
- + "/" + e.getSource().getId().get());
- item.addProperty(TARGET, "services/inventory/" + version + "/" + e.getTarget().getType()
- + "/" + e.getTarget().getId().get());
+ item.addProperty("url", URL_BASE + "relationships/" + version + "/" + e.getType() + "/" + e.getId().get());
+ item.addProperty(SOURCE,
+ "services/inventory/" + version + "/" + e.getSource().getType() + "/" + e.getSource().getId().get());
+ item.addProperty(TARGET,
+ "services/inventory/" + version + "/" + e.getTarget().getType() + "/" + e.getTarget().getId().get());
arry.add(item);
}
import javax.ws.rs.core.Response.Status;
public class BulkPayload {
- public enum OperationType {
- CREATE, UPDATE, DELETE
- }
-
-
-
- private List<JsonElement> objects = new ArrayList<JsonElement>();
- private List<JsonElement> relationships = new ArrayList<JsonElement>();
-
- private static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
-
- public String toJson() {
- return gson.toJson(this);
- }
-
- public static BulkPayload fromJson(String payload) throws CrudException {
- try {
- if (payload == null || payload.isEmpty()) {
- throw new CrudException("Invalid Json Payload", Status.BAD_REQUEST);
- }
- return gson.fromJson(payload, BulkPayload.class);
- } catch (Exception ex) {
- throw new CrudException("Invalid Json Payload", Status.BAD_REQUEST);
- }
- }
-
- public List<JsonElement> getObjects() {
- return objects;
- }
-
- public void setObjects(List<JsonElement> objects) {
- this.objects = objects;
- }
-
- public List<JsonElement> getRelationships() {
- return relationships;
- }
-
- public void setRelationships(List<JsonElement> relationships) {
- this.relationships = relationships;
- }
-
- @Override
- public String toString() {
- return "BulkPayload [objects=" + objects + ", relationships=" + relationships + "]";
- }
-
- public static void main(String[] args) throws Exception {
- BulkPayload p = new BulkPayload();
- JsonObject root = new JsonObject();
- JsonArray vertices = new JsonArray();
- JsonObject v1 = new JsonObject();
- JsonObject v2 = new JsonObject();
- JsonObject prop = new JsonObject();
-
- prop.addProperty("p1","value1");
- prop.addProperty("p2","value2");
- v1.add("v1", prop);
- v2.add("v2",prop);
-
- vertices.add(v1);
- vertices.add(v2);
-
-
- root.add("objects", vertices);
-
- String s = "{\"objects\":[{\"v1\":{\"p1\":\"value1\",\"p2\":\"value2\"}},{\"v2\":{\"p1\":\"value1\",\"p2\":\"value2\"}}]}";
-
- p = BulkPayload.fromJson(s);
-
- List<JsonElement> po = p.getObjects();
- List<String> ids = new ArrayList<String>();
- for (JsonElement e : po){
- Set<Map.Entry<String, JsonElement>> entries = e.getAsJsonObject().entrySet();
-
- for (Map.Entry<String, JsonElement> entry : entries) {
- ids.add(entry.getKey());
- }
- }
-
-
- System.out.println("root: " + root.toString());
- System.out.println("payload ids: " + ids.toString());
-
- }
+ public enum OperationType {
+ CREATE, UPDATE, DELETE
+ }
+
+ private List<JsonElement> objects = new ArrayList<JsonElement>();
+ private List<JsonElement> relationships = new ArrayList<JsonElement>();
+
+ private static final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
+
+ public String toJson() {
+ return gson.toJson(this);
+ }
+
+ public static BulkPayload fromJson(String payload) throws CrudException {
+ try {
+ if (payload == null || payload.isEmpty()) {
+ throw new CrudException("Invalid Json Payload", Status.BAD_REQUEST);
+ }
+ return gson.fromJson(payload, BulkPayload.class);
+ } catch (Exception ex) {
+ throw new CrudException("Invalid Json Payload", Status.BAD_REQUEST);
+ }
+ }
+
+ public List<JsonElement> getObjects() {
+ return objects;
+ }
+
+ public void setObjects(List<JsonElement> objects) {
+ this.objects = objects;
+ }
+
+ public List<JsonElement> getRelationships() {
+ return relationships;
+ }
+
+ public void setRelationships(List<JsonElement> relationships) {
+ this.relationships = relationships;
+ }
+
+ @Override
+ public String toString() {
+ return "BulkPayload [objects=" + objects + ", relationships=" + relationships + "]";
+ }
+
+ public static void main(String[] args) throws Exception {
+ BulkPayload p = new BulkPayload();
+ JsonObject root = new JsonObject();
+ JsonArray vertices = new JsonArray();
+ JsonObject v1 = new JsonObject();
+ JsonObject v2 = new JsonObject();
+ JsonObject prop = new JsonObject();
+
+ prop.addProperty("p1", "value1");
+ prop.addProperty("p2", "value2");
+ v1.add("v1", prop);
+ v2.add("v2", prop);
+
+ vertices.add(v1);
+ vertices.add(v2);
+
+ root.add("objects", vertices);
+
+ String s = "{\"objects\":[{\"v1\":{\"p1\":\"value1\",\"p2\":\"value2\"}},{\"v2\":{\"p1\":\"value1\",\"p2\":\"value2\"}}]}";
+
+ p = BulkPayload.fromJson(s);
+
+ List<JsonElement> po = p.getObjects();
+ List<String> ids = new ArrayList<String>();
+ for (JsonElement e : po) {
+ Set<Map.Entry<String, JsonElement>> entries = e.getAsJsonObject().entrySet();
+
+ for (Map.Entry<String, JsonElement> entry : entries) {
+ ids.add(entry.getKey());
+ }
+ }
+
+ System.out.println("root: " + root.toString());
+ System.out.println("payload ids: " + ids.toString());
+
+ }
}
\ No newline at end of file
private GraphDao dao;
public CrudGraphDataService(ChampGraph graphImpl) throws CrudException {
- this.dao = new ChampDao(graphImpl);
-
- loadModels();
- }
+ this.dao = new ChampDao(graphImpl);
+ loadModels();
+ }
- public CrudGraphDataService(GraphDao dao) throws CrudException {
- this.dao = dao;
+ public CrudGraphDataService(GraphDao dao) throws CrudException {
+ this.dao = dao;
- loadModels();
- }
+ loadModels();
+ }
- private void loadModels() throws CrudException {
- //load the schemas
- try {
+ private void loadModels() throws CrudException {
+ // load the schemas
+ try {
OxmModelLoader.loadModels();
} catch (Exception e) {
throw new CrudException(e);
}
- RelationshipSchemaLoader.loadModels();
- }
+ RelationshipSchemaLoader.loadModels();
+ }
public String addVertex(String version, String type, VertexPayload payload) throws CrudException {
- Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(null, version, type,
- payload.getProperties());
+ Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(null, version, type, payload.getProperties());
return addVertex(version, vertex);
}
-
- public String addBulk(String version, BulkPayload payload) throws CrudException {
- HashMap<String, Vertex> vertices = new HashMap<String, Vertex>();
- HashMap<String, Edge> edges = new HashMap<String, Edge>();
- String txId = dao.openTransaction();
- try {
- // Handle vertices
- for (JsonElement v : payload.getObjects()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(v.getAsJsonObject().entrySet());
-
- if (entries.size() != 2) {
- throw new CrudException("", Status.BAD_REQUEST);
- }
- Map.Entry<String, JsonElement> opr = entries.get(0);
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- VertexPayload vertexPayload = VertexPayload.fromJson(item.getValue().getAsJsonObject().toString());
-
- if (opr.getValue().getAsString().equalsIgnoreCase("add") || opr.getValue().getAsString().equalsIgnoreCase("modify")) {
- Vertex validatedVertex;
- Vertex persistedVertex;
- if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
- validatedVertex = OxmModelValidator.validateIncomingUpsertPayload(null, version, vertexPayload.getType(),
- vertexPayload.getProperties());
- // Call champDAO to add the vertex
- persistedVertex = dao.addVertex(validatedVertex.getType(), validatedVertex.getProperties(), txId);
- } else {
- validatedVertex = OxmModelValidator.validateIncomingUpsertPayload(vertexPayload.getId(), version, vertexPayload.getType(),
- vertexPayload.getProperties());
- // Call champDAO to update the vertex
- persistedVertex = dao.updateVertex(vertexPayload.getId(), validatedVertex.getType(), validatedVertex.getProperties(), txId);
- }
-
- Vertex outgoingVertex = OxmModelValidator.validateOutgoingPayload(version, persistedVertex);
-
- vertices.put(item.getKey(), outgoingVertex);
-
- } else if (opr.getValue().getAsString().equalsIgnoreCase("delete")) {
- dao.deleteVertex(vertexPayload.getId(), OxmModelValidator.resolveCollectionType(version, vertexPayload.getType()), txId);
- }
-
- }
- // Handle Edges
- for (JsonElement v : payload.getRelationships()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(v.getAsJsonObject().entrySet());
-
- if (entries.size() != 2) {
- throw new CrudException("", Status.BAD_REQUEST);
- }
- Map.Entry<String, JsonElement> opr = entries.get(0);
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- EdgePayload edgePayload = EdgePayload.fromJson(item.getValue().getAsJsonObject().toString());
-
- if (opr.getValue().getAsString().equalsIgnoreCase("add") || opr.getValue().getAsString().equalsIgnoreCase("modify")) {
- Edge validatedEdge;
- Edge persistedEdge;
- if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
- // Fix the source/detination
- if (edgePayload.getSource().startsWith("$")) {
- Vertex source = vertices.get(edgePayload.getSource().substring(1));
- if (source == null) {
- throw new CrudException("Not able to find vertex: " + edgePayload.getSource().substring(1), Status.INTERNAL_SERVER_ERROR);
- }
- edgePayload.setSource("services/inventory/" + version + "/" + source.getType() + "/" + source.getId().get());
- }
- if (edgePayload.getTarget().startsWith("$")) {
- Vertex target = vertices.get(edgePayload.getTarget().substring(1));
- if (target == null) {
- throw new CrudException("Not able to find vertex: " + edgePayload.getTarget().substring(1), Status.INTERNAL_SERVER_ERROR);
- }
- edgePayload.setTarget("services/inventory/" + version + "/" + target.getType() + "/" + target.getId().get());
- }
- validatedEdge = RelationshipSchemaValidator.validateIncomingAddPayload(version, edgePayload.getType(), edgePayload);
- persistedEdge = dao.addEdge(validatedEdge.getType(), validatedEdge.getSource(), validatedEdge.getTarget(),
- validatedEdge.getProperties(), txId);
- } else {
- Edge edge = dao.getEdge(edgePayload.getId(), edgePayload.getType(), txId);
- validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge, version, edgePayload);
- persistedEdge = dao.updateEdge(edge, txId);
- }
-
- Edge outgoingEdge = RelationshipSchemaValidator.validateOutgoingPayload(version, persistedEdge);
-
- edges.put(item.getKey(), outgoingEdge);
-
- } else if (opr.getValue().getAsString().equalsIgnoreCase("delete")) {
- RelationshipSchemaValidator.validateType(version, edgePayload.getType());
- dao.deleteEdge(edgePayload.getId(), edgePayload.getType(), txId);
- }
-
- }
- // close champ TX
- dao.commitTransaction(txId);
- } catch (CrudException ex) {
- dao.rollbackTransaction(txId);
- throw ex;
- } catch (Exception ex) {
- dao.rollbackTransaction(txId);
- throw ex;
- } finally {
- if (dao.transactionExists(txId)) {
- dao.rollbackTransaction(txId);
- }
- }
-
-
- return CrudResponseBuilder.buildUpsertBulkResponse(vertices, edges, version, payload);
- }
+
+ public String addBulk(String version, BulkPayload payload) throws CrudException {
+ HashMap<String, Vertex> vertices = new HashMap<String, Vertex>();
+ HashMap<String, Edge> edges = new HashMap<String, Edge>();
+ String txId = dao.openTransaction();
+ try {
+ // Handle vertices
+ for (JsonElement v : payload.getObjects()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ v.getAsJsonObject().entrySet());
+
+ if (entries.size() != 2) {
+ throw new CrudException("", Status.BAD_REQUEST);
+ }
+ Map.Entry<String, JsonElement> opr = entries.get(0);
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ VertexPayload vertexPayload = VertexPayload.fromJson(item.getValue().getAsJsonObject().toString());
+
+ if (opr.getValue().getAsString().equalsIgnoreCase("add")
+ || opr.getValue().getAsString().equalsIgnoreCase("modify")) {
+ Vertex validatedVertex;
+ Vertex persistedVertex;
+ if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
+ validatedVertex = OxmModelValidator.validateIncomingUpsertPayload(null, version, vertexPayload.getType(),
+ vertexPayload.getProperties());
+ // Call champDAO to add the vertex
+ persistedVertex = dao.addVertex(validatedVertex.getType(), validatedVertex.getProperties(), txId);
+ } else {
+ validatedVertex = OxmModelValidator.validateIncomingUpsertPayload(vertexPayload.getId(), version,
+ vertexPayload.getType(), vertexPayload.getProperties());
+ // Call champDAO to update the vertex
+ persistedVertex = dao.updateVertex(vertexPayload.getId(), validatedVertex.getType(),
+ validatedVertex.getProperties(), txId);
+ }
+
+ Vertex outgoingVertex = OxmModelValidator.validateOutgoingPayload(version, persistedVertex);
+
+ vertices.put(item.getKey(), outgoingVertex);
+
+ } else if (opr.getValue().getAsString().equalsIgnoreCase("delete")) {
+ dao.deleteVertex(vertexPayload.getId(),
+ OxmModelValidator.resolveCollectionType(version, vertexPayload.getType()), txId);
+ }
+
+ }
+ // Handle Edges
+ for (JsonElement v : payload.getRelationships()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ v.getAsJsonObject().entrySet());
+
+ if (entries.size() != 2) {
+ throw new CrudException("", Status.BAD_REQUEST);
+ }
+ Map.Entry<String, JsonElement> opr = entries.get(0);
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ EdgePayload edgePayload = EdgePayload.fromJson(item.getValue().getAsJsonObject().toString());
+
+ if (opr.getValue().getAsString().equalsIgnoreCase("add")
+ || opr.getValue().getAsString().equalsIgnoreCase("modify")) {
+ Edge validatedEdge;
+ Edge persistedEdge;
+ if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
+ // Fix the source/detination
+ if (edgePayload.getSource().startsWith("$")) {
+ Vertex source = vertices.get(edgePayload.getSource().substring(1));
+ if (source == null) {
+ throw new CrudException("Not able to find vertex: " + edgePayload.getSource().substring(1),
+ Status.INTERNAL_SERVER_ERROR);
+ }
+ edgePayload
+ .setSource("services/inventory/" + version + "/" + source.getType() + "/" + source.getId().get());
+ }
+ if (edgePayload.getTarget().startsWith("$")) {
+ Vertex target = vertices.get(edgePayload.getTarget().substring(1));
+ if (target == null) {
+ throw new CrudException("Not able to find vertex: " + edgePayload.getTarget().substring(1),
+ Status.INTERNAL_SERVER_ERROR);
+ }
+ edgePayload
+ .setTarget("services/inventory/" + version + "/" + target.getType() + "/" + target.getId().get());
+ }
+ validatedEdge = RelationshipSchemaValidator.validateIncomingAddPayload(version, edgePayload.getType(),
+ edgePayload);
+ persistedEdge = dao.addEdge(validatedEdge.getType(), validatedEdge.getSource(), validatedEdge.getTarget(),
+ validatedEdge.getProperties(), txId);
+ } else {
+ Edge edge = dao.getEdge(edgePayload.getId(), edgePayload.getType(), txId);
+ validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge, version, edgePayload);
+ persistedEdge = dao.updateEdge(edge, txId);
+ }
+
+ Edge outgoingEdge = RelationshipSchemaValidator.validateOutgoingPayload(version, persistedEdge);
+
+ edges.put(item.getKey(), outgoingEdge);
+
+ } else if (opr.getValue().getAsString().equalsIgnoreCase("delete")) {
+ RelationshipSchemaValidator.validateType(version, edgePayload.getType());
+ dao.deleteEdge(edgePayload.getId(), edgePayload.getType(), txId);
+ }
+
+ }
+ // close champ TX
+ dao.commitTransaction(txId);
+ } catch (CrudException ex) {
+ dao.rollbackTransaction(txId);
+ throw ex;
+ } catch (Exception ex) {
+ dao.rollbackTransaction(txId);
+ throw ex;
+ } finally {
+ if (dao.transactionExists(txId)) {
+ dao.rollbackTransaction(txId);
+ }
+ }
+
+ return CrudResponseBuilder.buildUpsertBulkResponse(vertices, edges, version, payload);
+ }
private String addVertex(String version, Vertex vertex) throws CrudException {
Vertex addedVertex = dao.addVertex(vertex.getType(), vertex.getProperties());
return CrudResponseBuilder
- .buildUpsertVertexResponse(OxmModelValidator.validateOutgoingPayload(version, addedVertex),
- version);
+ .buildUpsertVertexResponse(OxmModelValidator.validateOutgoingPayload(version, addedVertex), version);
}
public String addEdge(String version, String type, EdgePayload payload) throws CrudException {
}
private String addEdge(String version, Edge edge) throws CrudException {
- Edge addedEdge = dao.addEdge(edge.getType(), edge.getSource(), edge.getTarget(),
- edge.getProperties());
- return CrudResponseBuilder.buildUpsertEdgeResponse(
- RelationshipSchemaValidator.validateOutgoingPayload(version, addedEdge), version);
+ Edge addedEdge = dao.addEdge(edge.getType(), edge.getSource(), edge.getTarget(), edge.getProperties());
+ return CrudResponseBuilder
+ .buildUpsertEdgeResponse(RelationshipSchemaValidator.validateOutgoingPayload(version, addedEdge), version);
}
public String getEdge(String version, String id, String type) throws CrudException {
RelationshipSchemaValidator.validateType(version, type);
Edge edge = dao.getEdge(id, type);
- return CrudResponseBuilder.buildGetEdgeResponse(RelationshipSchemaValidator
- .validateOutgoingPayload(version, edge),
+ return CrudResponseBuilder.buildGetEdgeResponse(RelationshipSchemaValidator.validateOutgoingPayload(version, edge),
version);
}
- public String getEdges(String version, String type, Map<String, String> filter)
- throws CrudException {
+ public String getEdges(String version, String type, Map<String, String> filter) throws CrudException {
RelationshipSchemaValidator.validateType(version, type);
- List<Edge> items = dao.getEdges(type, RelationshipSchemaValidator
- .resolveCollectionfilter(version, type, filter));
+ List<Edge> items = dao.getEdges(type, RelationshipSchemaValidator.resolveCollectionfilter(version, type, filter));
return CrudResponseBuilder.buildGetEdgesResponse(items, version);
}
-
- public String updateVertex(String version, String id, String type, VertexPayload payload)
- throws CrudException {
- Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(id, version, type,
- payload.getProperties());
+ public String updateVertex(String version, String id, String type, VertexPayload payload) throws CrudException {
+ Vertex vertex = OxmModelValidator.validateIncomingUpsertPayload(id, version, type, payload.getProperties());
return updateVertex(version, vertex);
}
private String updateVertex(String version, Vertex vertex) throws CrudException {
- Vertex updatedVertex = dao.updateVertex(vertex.getId().get(), vertex.getType(),
- vertex.getProperties());
+ Vertex updatedVertex = dao.updateVertex(vertex.getId().get(), vertex.getType(), vertex.getProperties());
return CrudResponseBuilder
- .buildUpsertVertexResponse(OxmModelValidator.validateOutgoingPayload(version,
- updatedVertex), version);
+ .buildUpsertVertexResponse(OxmModelValidator.validateOutgoingPayload(version, updatedVertex), version);
}
- public String patchVertex(String version, String id, String type, VertexPayload payload)
- throws CrudException {
- Vertex existingVertex = dao.getVertex(id, OxmModelValidator.resolveCollectionType(version,
- type));
- Vertex vertex = OxmModelValidator.validateIncomingPatchPayload(id, version, type,
- payload.getProperties(), existingVertex);
+ public String patchVertex(String version, String id, String type, VertexPayload payload) throws CrudException {
+ Vertex existingVertex = dao.getVertex(id, OxmModelValidator.resolveCollectionType(version, type));
+ Vertex vertex = OxmModelValidator.validateIncomingPatchPayload(id, version, type, payload.getProperties(),
+ existingVertex);
return updateVertex(version, vertex);
}
}
- public String updateEdge(String version, String id, String type, EdgePayload payload)
- throws CrudException {
+ public String updateEdge(String version, String id, String type, EdgePayload payload) throws CrudException {
Edge edge = dao.getEdge(id, type);
- Edge validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge,
- version, payload);
+ Edge validatedEdge = RelationshipSchemaValidator.validateIncomingUpdatePayload(edge, version, payload);
return updateEdge(version, validatedEdge);
}
private String updateEdge(String version, Edge edge) throws CrudException {
Edge updatedEdge = dao.updateEdge(edge);
- return CrudResponseBuilder.buildUpsertEdgeResponse(
- RelationshipSchemaValidator.validateOutgoingPayload(version, updatedEdge), version);
+ return CrudResponseBuilder
+ .buildUpsertEdgeResponse(RelationshipSchemaValidator.validateOutgoingPayload(version, updatedEdge), version);
}
- public String patchEdge(String version, String id, String type, EdgePayload payload)
- throws CrudException {
+ public String patchEdge(String version, String id, String type, EdgePayload payload) throws CrudException {
Edge edge = dao.getEdge(id, type);
- Edge patchedEdge = RelationshipSchemaValidator.validateIncomingPatchPayload(edge,
- version, payload);
+ Edge patchedEdge = RelationshipSchemaValidator.validateIncomingPatchPayload(edge, version, payload);
return updateEdge(version, patchedEdge);
}
public Vertex getVertex(String id) throws CrudException {
return dao.getVertex(id);
}
-
+
public String getVertex(String version, String id, String type) throws CrudException {
type = OxmModelValidator.resolveCollectionType(version, type);
Vertex vertex = dao.getVertex(id, type);
List<Edge> edges = dao.getVertexEdges(id);
- return CrudResponseBuilder.buildGetVertexResponse(OxmModelValidator
- .validateOutgoingPayload(version, vertex), edges, version);
+ return CrudResponseBuilder.buildGetVertexResponse(OxmModelValidator.validateOutgoingPayload(version, vertex), edges,
+ version);
}
- public String getVertices(String version, String type, Map<String, String> filter)
- throws CrudException {
+ public String getVertices(String version, String type, Map<String, String> filter) throws CrudException {
type = OxmModelValidator.resolveCollectionType(version, type);
- List<Vertex> items = dao.getVertices(type, OxmModelValidator.resolveCollectionfilter(version,
- type, filter));
+ List<Vertex> items = dao.getVertices(type, OxmModelValidator.resolveCollectionfilter(version, type, filter));
return CrudResponseBuilder.buildGetVerticesResponse(items, version);
}
-
-
}
@GET
@Path("/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response getVertex(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response getVertex(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@GET
@Path("/{version}/{type}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response getVertices(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
- @Context HttpHeaders headers, @Context UriInfo uriInfo,
- @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response getVertices(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers, @Context UriInfo uriInfo,
+ @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@GET
@Path("/relationships/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response getEdge(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response getEdge(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@GET
@Path("/relationships/{version}/{type}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response getEdges(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
- @Context HttpHeaders headers, @Context UriInfo uriInfo,
- @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response getEdges(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers, @Context UriInfo uriInfo,
+ @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
@PUT
@Path("/relationships/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response updateEdge(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response updateEdge(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
String result;
if (headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE) != null
- && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE)
- .equalsIgnoreCase("PATCH")) {
+ && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE).equalsIgnoreCase("PATCH")) {
result = crudGraphDataService.patchEdge(version, id, type, payload);
} else {
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
@PATCH
@Path("/relationships/{version}/{type}/{id}")
- @Consumes({"application/merge-patch+json"})
- @Produces({MediaType.APPLICATION_JSON})
- public Response patchEdge(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ "application/merge-patch+json" })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response patchEdge(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.PATCH,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.PATCH, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
EdgePayload payload = EdgePayload.fromJson(content);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@PUT
@Path("/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response updateVertex(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response updateVertex(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
}
String result;
if (headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE) != null
- && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE)
- .equalsIgnoreCase("PATCH")) {
+ && headers.getRequestHeaders().getFirst(HTTP_PATCH_METHOD_OVERRIDE).equalsIgnoreCase("PATCH")) {
result = crudGraphDataService.patchVertex(version, id, type, payload);
} else {
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@PATCH
@Path("/{version}/{type}/{id}")
- @Consumes({"application/merge-patch+json"})
- @Produces({MediaType.APPLICATION_JSON})
- public Response patchVertex(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ "application/merge-patch+json" })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response patchVertex(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.PATCH,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.PATCH, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
VertexPayload payload = VertexPayload.fromJson(content);
if (payload.getProperties() == null || payload.getProperties().isJsonNull()) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@POST
@Path("/{version}/{type}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response addVertex(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
- @Context HttpHeaders headers, @Context UriInfo uriInfo,
- @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response addVertex(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers, @Context UriInfo uriInfo,
+ @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.POST,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
VertexPayload payload = VertexPayload.fromJson(content);
throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
}
if (payload.getId() != null) {
- throw new CrudException("ID specified , use Http PUT to update Vertex",
- Status.BAD_REQUEST);
+ throw new CrudException("ID specified , use Http PUT to update Vertex", Status.BAD_REQUEST);
}
if (payload.getType() != null && !payload.getType().equals(type)) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
return response;
}
-
- private void validateBulkPayload(BulkPayload payload) throws CrudException {
- List<String> vertices = new ArrayList<String>();
- List<String> edges = new ArrayList<String>();
-
- for (JsonElement v : payload.getObjects()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(v.getAsJsonObject().entrySet());
-
- if (entries.size() != 2) {
- throw new CrudException("", Status.BAD_REQUEST);
- }
- Map.Entry<String, JsonElement> opr = entries.get(0);
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- if (vertices.contains(item.getKey())) {
- throw new CrudException("duplicate vertex in payload: " + item.getKey(), Status.BAD_REQUEST);
- }
- VertexPayload vertexPayload = VertexPayload.fromJson(item.getValue().getAsJsonObject().toString());
- if (vertexPayload.getType() == null) {
- throw new CrudException("Vertex Type cannot be null for: " + item.getKey(), Status.BAD_REQUEST);
- }
-
- if (!opr.getKey().equalsIgnoreCase("operation")) {
- throw new CrudException("operation missing in item: " + item.getKey(), Status.BAD_REQUEST);
- }
-
- if (!opr.getValue().getAsString().equalsIgnoreCase("add") && !opr.getValue().getAsString().equalsIgnoreCase("modify")
- && !opr.getValue().getAsString().equalsIgnoreCase("delete")) {
- throw new CrudException("Invalid operation at item: " + item.getKey(), Status.BAD_REQUEST);
- }
- // check if ID is populate for modify/delete operation
- if ((opr.getValue().getAsString().equalsIgnoreCase("modify") || opr.getValue().getAsString().equalsIgnoreCase("delete"))
- && (vertexPayload.getId() == null)) {
-
- throw new CrudException("Mising ID at item: " + item.getKey(), Status.BAD_REQUEST);
-
- }
-
- vertices.add(item.getKey());
- }
-
- for (JsonElement v : payload.getRelationships()) {
- List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(v.getAsJsonObject().entrySet());
-
- if (entries.size() != 2) {
- throw new CrudException("", Status.BAD_REQUEST);
- }
- Map.Entry<String, JsonElement> opr = entries.get(0);
- Map.Entry<String, JsonElement> item = entries.get(1);
-
- if (edges.contains(item.getKey())) {
- throw new CrudException("duplicate Edge in payload: " + item.getKey(), Status.BAD_REQUEST);
- }
-
- EdgePayload edgePayload = EdgePayload.fromJson(item.getValue().getAsJsonObject().toString());
-
- if (edgePayload.getType() == null) {
- throw new CrudException("Edge Type cannot be null for: " + item.getKey(), Status.BAD_REQUEST);
- }
-
- if (!opr.getKey().equalsIgnoreCase("operation")) {
- throw new CrudException("operation missing in item: " + item.getKey(), Status.BAD_REQUEST);
- }
-
- if (!opr.getValue().getAsString().equalsIgnoreCase("add") && !opr.getValue().getAsString().equalsIgnoreCase("modify")
- && !opr.getValue().getAsString().equalsIgnoreCase("delete")) {
- throw new CrudException("Invalid operation at item: " + item.getKey(), Status.BAD_REQUEST);
- }
- // check if ID is populate for modify/delete operation
- if ((edgePayload.getId() == null) && (opr.getValue().getAsString().equalsIgnoreCase("modify")
- || opr.getValue().getAsString().equalsIgnoreCase("delete"))) {
-
- throw new CrudException("Mising ID at item: " + item.getKey(), Status.BAD_REQUEST);
-
- }
- if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
- if(edgePayload.getSource()==null || edgePayload.getTarget()==null){
- throw new CrudException("Source/Target cannot be null for edge: " + item.getKey(),
- Status.BAD_REQUEST);
- }
- if (edgePayload.getSource().startsWith("$") && !vertices.contains(edgePayload.getSource().substring(1))) {
- throw new CrudException("Source Vertex " + edgePayload.getSource().substring(1) + " not found for Edge: " + item.getKey(),
- Status.BAD_REQUEST);
- }
-
- if (edgePayload.getTarget().startsWith("$") && !vertices.contains(edgePayload.getTarget().substring(1))) {
- throw new CrudException("Target Vertex " + edgePayload.getSource().substring(1) + " not found for Edge: " + item.getKey(),
- Status.BAD_REQUEST);
- }
- }
- edges.add(item.getKey());
-
- }
-
- }
-
+
+ private void validateBulkPayload(BulkPayload payload) throws CrudException {
+ List<String> vertices = new ArrayList<String>();
+ List<String> edges = new ArrayList<String>();
+
+ for (JsonElement v : payload.getObjects()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ v.getAsJsonObject().entrySet());
+
+ if (entries.size() != 2) {
+ throw new CrudException("", Status.BAD_REQUEST);
+ }
+ Map.Entry<String, JsonElement> opr = entries.get(0);
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ if (vertices.contains(item.getKey())) {
+ throw new CrudException("duplicate vertex in payload: " + item.getKey(), Status.BAD_REQUEST);
+ }
+ VertexPayload vertexPayload = VertexPayload.fromJson(item.getValue().getAsJsonObject().toString());
+ if (vertexPayload.getType() == null) {
+ throw new CrudException("Vertex Type cannot be null for: " + item.getKey(), Status.BAD_REQUEST);
+ }
+
+ if (!opr.getKey().equalsIgnoreCase("operation")) {
+ throw new CrudException("operation missing in item: " + item.getKey(), Status.BAD_REQUEST);
+ }
+
+ if (!opr.getValue().getAsString().equalsIgnoreCase("add")
+ && !opr.getValue().getAsString().equalsIgnoreCase("modify")
+ && !opr.getValue().getAsString().equalsIgnoreCase("delete")) {
+ throw new CrudException("Invalid operation at item: " + item.getKey(), Status.BAD_REQUEST);
+ }
+ // check if ID is populate for modify/delete operation
+ if ((opr.getValue().getAsString().equalsIgnoreCase("modify")
+ || opr.getValue().getAsString().equalsIgnoreCase("delete")) && (vertexPayload.getId() == null)) {
+
+ throw new CrudException("Mising ID at item: " + item.getKey(), Status.BAD_REQUEST);
+
+ }
+
+ vertices.add(item.getKey());
+ }
+
+ for (JsonElement v : payload.getRelationships()) {
+ List<Map.Entry<String, JsonElement>> entries = new ArrayList<Map.Entry<String, JsonElement>>(
+ v.getAsJsonObject().entrySet());
+
+ if (entries.size() != 2) {
+ throw new CrudException("", Status.BAD_REQUEST);
+ }
+ Map.Entry<String, JsonElement> opr = entries.get(0);
+ Map.Entry<String, JsonElement> item = entries.get(1);
+
+ if (edges.contains(item.getKey())) {
+ throw new CrudException("duplicate Edge in payload: " + item.getKey(), Status.BAD_REQUEST);
+ }
+
+ EdgePayload edgePayload = EdgePayload.fromJson(item.getValue().getAsJsonObject().toString());
+
+ if (edgePayload.getType() == null) {
+ throw new CrudException("Edge Type cannot be null for: " + item.getKey(), Status.BAD_REQUEST);
+ }
+
+ if (!opr.getKey().equalsIgnoreCase("operation")) {
+ throw new CrudException("operation missing in item: " + item.getKey(), Status.BAD_REQUEST);
+ }
+
+ if (!opr.getValue().getAsString().equalsIgnoreCase("add")
+ && !opr.getValue().getAsString().equalsIgnoreCase("modify")
+ && !opr.getValue().getAsString().equalsIgnoreCase("delete")) {
+ throw new CrudException("Invalid operation at item: " + item.getKey(), Status.BAD_REQUEST);
+ }
+ // check if ID is populate for modify/delete operation
+ if ((edgePayload.getId() == null) && (opr.getValue().getAsString().equalsIgnoreCase("modify")
+ || opr.getValue().getAsString().equalsIgnoreCase("delete"))) {
+
+ throw new CrudException("Mising ID at item: " + item.getKey(), Status.BAD_REQUEST);
+
+ }
+ if (opr.getValue().getAsString().equalsIgnoreCase("add")) {
+ if (edgePayload.getSource() == null || edgePayload.getTarget() == null) {
+ throw new CrudException("Source/Target cannot be null for edge: " + item.getKey(), Status.BAD_REQUEST);
+ }
+ if (edgePayload.getSource().startsWith("$") && !vertices.contains(edgePayload.getSource().substring(1))) {
+ throw new CrudException(
+ "Source Vertex " + edgePayload.getSource().substring(1) + " not found for Edge: " + item.getKey(),
+ Status.BAD_REQUEST);
+ }
+
+ if (edgePayload.getTarget().startsWith("$") && !vertices.contains(edgePayload.getTarget().substring(1))) {
+ throw new CrudException(
+ "Target Vertex " + edgePayload.getSource().substring(1) + " not found for Edge: " + item.getKey(),
+ Status.BAD_REQUEST);
+ }
+ }
+ edges.add(item.getKey());
+
+ }
+
+ }
+
@POST
@Path("/{version}/bulk/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response addBulk(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
- @Context HttpHeaders headers, @Context UriInfo uriInfo,
- @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response addBulk(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers, @Context UriInfo uriInfo,
+ @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.POST,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
BulkPayload payload = BulkPayload.fromJson(content);
- if ((payload.getObjects() == null && payload.getRelationships() == null) || (payload.getObjects() != null && payload.getObjects().isEmpty()
- && payload.getRelationships() != null && payload.getRelationships().isEmpty())) {
+ if ((payload.getObjects() == null && payload.getRelationships() == null)
+ || (payload.getObjects() != null && payload.getObjects().isEmpty() && payload.getRelationships() != null
+ && payload.getRelationships().isEmpty())) {
throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
}
-
- validateBulkPayload(payload);
- String result = crudGraphDataService.addBulk(version, payload);
+
+ validateBulkPayload(payload);
+ String result = crudGraphDataService.addBulk(version, payload);
response = Response.status(Status.OK).entity(result).type(mediaType).build();
} catch (CrudException ce) {
response = Response.status(ce.getHttpStatus()).entity(ce.getMessage()).build();
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@POST
@Path("/{version}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response addVertex(String content, @PathParam("version") String version,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response addVertex(String content, @PathParam("version") String version, @PathParam("uri") @Encoded String uri,
+ @Context HttpHeaders headers, @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.POST,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
VertexPayload payload = VertexPayload.fromJson(content);
throw new CrudException("Invalid request Payload", Status.BAD_REQUEST);
}
if (payload.getId() != null) {
- throw new CrudException("ID specified , use Http PUT to update Vertex",
- Status.BAD_REQUEST);
+ throw new CrudException("ID specified , use Http PUT to update Vertex", Status.BAD_REQUEST);
}
if (payload.getType() == null || payload.getType().isEmpty()) {
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@POST
@Path("/relationships/{version}/{type}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response addEdge(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("uri") @Encoded String uri,
- @Context HttpHeaders headers, @Context UriInfo uriInfo,
- @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response addEdge(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers, @Context UriInfo uriInfo,
+ @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.POST,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
-
+ if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
EdgePayload payload = EdgePayload.fromJson(content);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@POST
@Path("/relationships/{version}/")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response addEdge(String content, @PathParam("version") String version,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response addEdge(String content, @PathParam("version") String version, @PathParam("uri") @Encoded String uri,
+ @Context HttpHeaders headers, @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.POST,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
-
+ if (validateRequest(req, uri, content, Action.POST, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
EdgePayload payload = EdgePayload.fromJson(content);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@DELETE
@Path("/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response deleteVertex(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response deleteVertex(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.DELETE,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
-
+ if (validateRequest(req, uri, content, Action.DELETE, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
String result = crudGraphDataService.deleteVertex(version, id, type);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
@DELETE
@Path("/relationships/{version}/{type}/{id}")
- @Consumes({MediaType.APPLICATION_JSON})
- @Produces({MediaType.APPLICATION_JSON})
- public Response deleteEdge(String content, @PathParam("version") String version,
- @PathParam("type") String type, @PathParam("id") String id,
- @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
- @Context UriInfo uriInfo, @Context HttpServletRequest req) {
+ @Consumes({ MediaType.APPLICATION_JSON })
+ @Produces({ MediaType.APPLICATION_JSON })
+ public Response deleteEdge(String content, @PathParam("version") String version, @PathParam("type") String type,
+ @PathParam("id") String id, @PathParam("uri") @Encoded String uri, @Context HttpHeaders headers,
+ @Context UriInfo uriInfo, @Context HttpServletRequest req) {
LoggingUtil.initMdcContext(req, headers);
logger.debug("Incoming request..." + content);
Response response = null;
- if (validateRequest(req, uri, content, Action.DELETE,
- CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
+ if (validateRequest(req, uri, content, Action.DELETE, CrudServiceConstants.CRD_AUTH_POLICY_NAME)) {
try {
String result = crudGraphDataService.deleteEdge(version, id, type);
response = Response.status(Status.INTERNAL_SERVER_ERROR).entity(e.getMessage()).build();
}
} else {
- response = Response.status(Status.FORBIDDEN).entity(content)
- .type(MediaType.APPLICATION_JSON).build();
+ response = Response.status(Status.FORBIDDEN).entity(content).type(MediaType.APPLICATION_JSON).build();
}
LoggingUtil.logRestRequest(logger, auditLogger, req, response);
return response;
}
- protected boolean validateRequest(HttpServletRequest req, String uri, String content,
- Action action, String authPolicyFunctionName) {
+ protected boolean validateRequest(HttpServletRequest req, String uri, String content, Action action,
+ String authPolicyFunctionName) {
try {
String cipherSuite = (String) req.getAttribute("javax.servlet.request.cipher_suite");
String authUser = null;
if (cipherSuite != null) {
- X509Certificate[] certChain = (X509Certificate[]) req
- .getAttribute("javax.servlet.request.X509Certificate");
+ X509Certificate[] certChain = (X509Certificate[]) req.getAttribute("javax.servlet.request.X509Certificate");
X509Certificate clientCert = certChain[0];
X500Principal subjectDn = clientCert.getSubjectX500Principal();
authUser = subjectDn.toString();
}
- return this.auth.validateRequest(authUser.toLowerCase(), action.toString()
- + ":" + authPolicyFunctionName);
+ return this.auth.validateRequest(authUser.toLowerCase(), action.toString() + ":" + authPolicyFunctionName);
} catch (Exception e) {
logResult(action, uri, e);
return false;
void logResult(Action op, String uri, Exception e) {
- logger.error(CrudServiceMsgs.EXCEPTION_DURING_METHOD_CALL, op.toString(), uri,
- e.getStackTrace().toString());
+ logger.error(CrudServiceMsgs.EXCEPTION_DURING_METHOD_CALL, op.toString(), uri, e.getStackTrace().toString());
// Clear the MDC context so that no other transaction inadvertently
// uses our transaction id.
public class OxmModelValidator {
public enum Metadata {
- NODE_TYPE("aai-node-type"),
- URI("aai-uri"),
- CREATED_TS("aai-created-ts"),
- SOT("source-of-truth"),
- LAST_MOD_SOT("last-mod-source-of-truth");
+ NODE_TYPE("aai-node-type"), URI("aai-uri"), CREATED_TS("aai-created-ts"), SOT("source-of-truth"), LAST_MOD_SOT(
+ "last-mod-source-of-truth");
private final String propName;
}
}
-
- public static Map<String, Object> resolveCollectionfilter(String version, String type,
- Map<String, String> filter)
+ public static Map<String, Object> resolveCollectionfilter(String version, String type, Map<String, String> filter)
throws CrudException {
DynamicJAXBContext jaxbContext = null;
if (jaxbContext == null) {
throw new CrudException("", Status.NOT_FOUND);
}
- final DynamicType modelObjectType = jaxbContext.getDynamicType(CaseFormat.LOWER_CAMEL
- .to(CaseFormat.UPPER_CAMEL,
- CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, type)));
+ final DynamicType modelObjectType = jaxbContext.getDynamicType(
+ CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, type)));
for (String key : filter.keySet()) {
String keyJavaName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, key);
if (modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName) != null) {
try {
- DatabaseMapping mapping = modelObjectType.getDescriptor()
- .getMappingForAttributeName(keyJavaName);
- Object value = CrudServiceUtil.validateFieldType(filter.get(key),
- mapping.getField().getType());
+ DatabaseMapping mapping = modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName);
+ Object value = CrudServiceUtil.validateFieldType(filter.get(key), mapping.getField().getType());
result.put(key, value);
} catch (Exception ex) {
// Skip any exceptions thrown while validating the filter
}
// Determine if the Object part is a collection type in the model
// definition
- final DynamicType modelObjectType = jaxbContext.getDynamicType(CaseFormat.LOWER_CAMEL
- .to(CaseFormat.UPPER_CAMEL,
- CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, type)));
+ final DynamicType modelObjectType = jaxbContext.getDynamicType(
+ CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, type)));
if (modelObjectType == null) {
throw new CrudException("", Status.NOT_FOUND);
if (modelObjectType.getDescriptor().getMappings().size() == 1
&& modelObjectType.getDescriptor().getMappings().get(0).isCollectionMapping()) {
- String childJavaObjectName = modelObjectType.getDescriptor().getMappings()
- .get(0).getAttributeName();
+ String childJavaObjectName = modelObjectType.getDescriptor().getMappings().get(0).getAttributeName();
childJavaObjectName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_CAMEL, childJavaObjectName);
final DynamicType childObjectType = jaxbContext.getDynamicType(childJavaObjectName);
if (childObjectType == null) {
}
-
- public static Vertex validateIncomingUpsertPayload(String id, String version, String type,
- JsonElement properties)
+ public static Vertex validateIncomingUpsertPayload(String id, String version, String type, JsonElement properties)
throws CrudException {
try {
final DynamicType modelObjectType = jaxbContext.getDynamicType(modelObjectClass);
final DynamicType reservedType = jaxbContext.getDynamicType("ReservedPropNames");
- Set<Map.Entry<String, JsonElement>> payloadEntriesSet = properties.getAsJsonObject()
- .entrySet();
+ Set<Map.Entry<String, JsonElement>> payloadEntriesSet = properties.getAsJsonObject().entrySet();
- //loop through input to validate against schema
+ // loop through input to validate against schema
for (Map.Entry<String, JsonElement> entry : payloadEntriesSet) {
String keyJavaName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, entry.getKey());
// check for valid field
if (modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName) == null) {
- if(reservedType.getDescriptor().getMappingForAttributeName(keyJavaName) == null){
- throw new CrudException("Invalid field: " + entry.getKey(), Status.BAD_REQUEST);
- }
+ if (reservedType.getDescriptor().getMappingForAttributeName(keyJavaName) == null) {
+ throw new CrudException("Invalid field: " + entry.getKey(), Status.BAD_REQUEST);
+ }
}
}
String keyName = field.getName().substring(0, field.getName().indexOf("/"));
- if (((XMLField) field).isRequired() && !entriesMap.containsKey(keyName)
- && !defaultValue.isEmpty()) {
- modelVertexBuilder.property(keyName,
- CrudServiceUtil.validateFieldType(defaultValue, field.getType()));
+ if (((XMLField) field).isRequired() && !entriesMap.containsKey(keyName) && !defaultValue.isEmpty()) {
+ modelVertexBuilder.property(keyName, CrudServiceUtil.validateFieldType(defaultValue, field.getType()));
}
// if schema field is required and not set then reject
- if (((XMLField) field).isRequired() && !entriesMap.containsKey(keyName)
- && defaultValue.isEmpty()) {
+ if (((XMLField) field).isRequired() && !entriesMap.containsKey(keyName) && defaultValue.isEmpty()) {
throw new CrudException("Missing required field: " + keyName, Status.BAD_REQUEST);
}
// If invalid field then reject
if (entriesMap.containsKey(keyName)) {
- Object value = CrudServiceUtil.validateFieldType(entriesMap.get(keyName)
- .getAsString(), field.getType());
+ Object value = CrudServiceUtil.validateFieldType(entriesMap.get(keyName).getAsString(), field.getType());
modelVertexBuilder.property(keyName, value);
}
// Set defaults
if (!defaultValue.isEmpty() && !entriesMap.containsKey(keyName)) {
- modelVertexBuilder.property(keyName,
- CrudServiceUtil.validateFieldType(defaultValue, field.getType()));
+ modelVertexBuilder.property(keyName, CrudServiceUtil.validateFieldType(defaultValue, field.getType()));
}
}
}
-
+
// Handle reserved properties
for (DatabaseMapping mapping : reservedType.getDescriptor().getMappings()) {
if (mapping.isAbstractDirectMapping()) {
String keyName = field.getName().substring(0, field.getName().indexOf("/"));
if (entriesMap.containsKey(keyName)) {
- Object value = CrudServiceUtil.validateFieldType(entriesMap.get(keyName)
- .getAsString(), field.getType());
+ Object value = CrudServiceUtil.validateFieldType(entriesMap.get(keyName).getAsString(), field.getType());
modelVertexBuilder.property(keyName, value);
}
}
}
}
- public static Vertex validateIncomingPatchPayload(String id, String version, String type,
- JsonElement properties, Vertex existingVertex)
- throws CrudException {
+ public static Vertex validateIncomingPatchPayload(String id, String version, String type, JsonElement properties,
+ Vertex existingVertex) throws CrudException {
try {
type = resolveCollectionType(version, type);
final DynamicType modelObjectType = jaxbContext.getDynamicType(modelObjectClass);
final DynamicType reservedType = jaxbContext.getDynamicType("ReservedPropNames");
- Set<Map.Entry<String, JsonElement>> payloadEntriesSet = properties.getAsJsonObject()
- .entrySet();
+ Set<Map.Entry<String, JsonElement>> payloadEntriesSet = properties.getAsJsonObject().entrySet();
// Loop through the payload properties and merge with existing
// vertex props
DatabaseField field = null;
String defaultValue = null;
-
+
if (modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName) != null) {
field = modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName).getField();
- defaultValue = modelObjectType.getDescriptor()
- .getMappingForAttributeName(keyJavaName)
- .getProperties().get("defaultValue") == null ? ""
- : modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName)
- .getProperties().get("defaultValue").toString();
- }
- else if (reservedType.getDescriptor().getMappingForAttributeName(keyJavaName) != null) {
+ defaultValue = modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName).getProperties()
+ .get("defaultValue") == null ? ""
+ : modelObjectType.getDescriptor().getMappingForAttributeName(keyJavaName).getProperties()
+ .get("defaultValue").toString();
+ } else if (reservedType.getDescriptor().getMappingForAttributeName(keyJavaName) != null) {
field = reservedType.getDescriptor().getMappingForAttributeName(keyJavaName).getField();
defaultValue = "";
}
-
+
if (field == null) {
throw new CrudException("Invalid field: " + entry.getKey(), Status.BAD_REQUEST);
}
// check if mandatory field is not set to null
- if (((XMLField) field).isRequired() && entry.getValue() instanceof JsonNull
- && !defaultValue.isEmpty()) {
+ if (((XMLField) field).isRequired() && entry.getValue() instanceof JsonNull && !defaultValue.isEmpty()) {
existingVertex.getProperties().put(entry.getKey(),
CrudServiceUtil.validateFieldType(defaultValue, field.getType()));
- } else if (((XMLField) field).isRequired() && entry.getValue() instanceof JsonNull
- && defaultValue.isEmpty()) {
- throw new CrudException("Mandatory field: " + entry.getKey()
- + " can't be set to null",
- Status.BAD_REQUEST);
+ } else if (((XMLField) field).isRequired() && entry.getValue() instanceof JsonNull && defaultValue.isEmpty()) {
+ throw new CrudException("Mandatory field: " + entry.getKey() + " can't be set to null", Status.BAD_REQUEST);
} else if (!((XMLField) field).isRequired() && entry.getValue() instanceof JsonNull
&& existingVertex.getProperties().containsKey(entry.getKey())) {
existingVertex.getProperties().remove(entry.getKey());
} else if (!(entry.getValue() instanceof JsonNull)) {
// add/update the value if found in existing vertex
- Object value = CrudServiceUtil.validateFieldType(entry.getValue().getAsString(),
- field.getType());
+ Object value = CrudServiceUtil.validateFieldType(entry.getValue().getAsString(), field.getType());
existingVertex.getProperties().put(entry.getKey(), value);
}
}
}
-
+
private static DatabaseField getDatabaseField(String fieldName, DynamicType modelObjectType) {
for (DatabaseField field : modelObjectType.getDescriptor().getAllFields()) {
int ix = field.getName().indexOf("/");
public static Vertex validateOutgoingPayload(String version, Vertex vertex) {
- Vertex.Builder modelVertexBuilder = new Vertex.Builder(vertex.getType())
- .id(vertex.getId().get());
+ Vertex.Builder modelVertexBuilder = new Vertex.Builder(vertex.getType()).id(vertex.getId().get());
try {
DynamicJAXBContext jaxbContext = OxmModelLoader.getContextForVersion(version);
}
-
}
final static Pattern propsFilePattern = Pattern.compile(edgePropsFiles + "(.*)" + fileExt);
final static Pattern versionPattern = Pattern.compile(".*(v\\d+)" + fileExt);
-
private static org.openecomp.cl.api.Logger logger = LoggerFactory.getInstance()
- .getLogger(RelationshipSchemaLoader.class.getName());
+ .getLogger(RelationshipSchemaLoader.class.getName());
public synchronized static void loadModels() throws CrudException {
load(rulesFilePattern, propsFilePattern);
RelationshipSchemaLoader.versionContextMap = new ConcurrentHashMap<>();
}
-
private static void load(Pattern rulesPattern, Pattern edgePropsPattern) throws CrudException {
ClassLoader cl = RelationshipSchemaLoader.class.getClassLoader();
ResourcePatternResolver rulesResolver = new PathMatchingResourcePatternResolver(cl);
try {
// getResources method returns objects of type "Resource"
- // 1. We are getting all the objects from the classpath which has "DbEdgeRules" in the name.
- // 2. We run them through a filter and return only the objects which match the supplied pattern "p"
- // 3. We then collect the objects in a list. At this point we have a list of the kind of files we require.
+ // 1. We are getting all the objects from the classpath which has
+ // "DbEdgeRules" in the name.
+ // 2. We run them through a filter and return only the objects which match
+ // the supplied pattern "p"
+ // 3. We then collect the objects in a list. At this point we have a list
+ // of the kind of files we require.
rulesFiles = Arrays.stream(rulesResolver.getResources("classpath*:/dbedgerules/DbEdgeRules*" + fileExt))
- .filter(r -> !myMatcher(rulesPattern, r.getFilename()).isEmpty())
- .collect(Collectors.toList());
+ .filter(r -> !myMatcher(rulesPattern, r.getFilename()).isEmpty()).collect(Collectors.toList());
- // This gets all the objects of type "File" from external directory (not on the classpath)
- // 1. From an external directory (one not on the classpath) we get all the objects of type "File"
- // 2. We only return the files whose names matched the supplied pattern "p2".
- // 3. We then collect all the objects in a list and add the contents of this list
- // to the previous collection (rulesFiles)
- rulesFiles.addAll(Arrays.stream(new File(rulesDir).listFiles((d, name) ->
- edgePropsPattern.matcher(name).matches())).collect(Collectors.toList()));
+ // This gets all the objects of type "File" from external directory (not
+ // on the classpath)
+ // 1. From an external directory (one not on the classpath) we get all the
+ // objects of type "File"
+ // 2. We only return the files whose names matched the supplied pattern
+ // "p2".
+ // 3. We then collect all the objects in a list and add the contents of
+ // this list
+ // to the previous collection (rulesFiles)
+ rulesFiles
+ .addAll(Arrays.stream(new File(rulesDir).listFiles((d, name) -> edgePropsPattern.matcher(name).matches()))
+ .collect(Collectors.toList()));
if (rulesFiles.isEmpty()) {
logger.error(CrudServiceMsgs.INVALID_OXM_DIR, rulesDir);
throw new FileNotFoundException("DbEdgeRules and edge_properties files were not found.");
}
- // Sort and then group the files with their versions, convert them to the schema, and add them to versionContextMap
- // 1. Sort the files. We need the DbEdgeRules files to be before the edgeProperties files.
- // 2. Group the files with their versions. ie. v11 -> ["DbEdgeRule_v11.json", "edgeProperties_v11.json"].
- // The "group method" returns a HashMap whose key is the version and the value is a list of objects.
- // 3. Go through each version and map the files into one schema using the "jsonFilesLoader" method.
- // Also update the "versionContextMap" with the version and it's schema.
+ // Sort and then group the files with their versions, convert them to the
+ // schema, and add them to versionContextMap
+ // 1. Sort the files. We need the DbEdgeRules files to be before the
+ // edgeProperties files.
+ // 2. Group the files with their versions. ie. v11 ->
+ // ["DbEdgeRule_v11.json", "edgeProperties_v11.json"].
+ // The "group method" returns a HashMap whose key is the version and the
+ // value is a list of objects.
+ // 3. Go through each version and map the files into one schema using the
+ // "jsonFilesLoader" method.
+ // Also update the "versionContextMap" with the version and it's schema.
rulesFiles.stream().sorted(Comparator.comparing(RelationshipSchemaLoader::filename))
- .collect(Collectors.groupingBy(f -> myMatcher(versionPattern, filename(f))))
- .forEach((version, resourceAndFile) -> {
- if (resourceAndFile.size() == 2 ) {
- versionContextMap.put(version, jsonFilesLoader(version, resourceAndFile));
- } else {
- String filenames = resourceAndFile.stream().map(f-> filename(f)).collect(Collectors.toList()).toString();
- String errorMsg = "Expecting a rules and a edge_properties files for " + version + ". Found: " + filenames;
- logger.warn(CrudServiceMsgs.INVALID_OXM_FILE, errorMsg);
- }});
- logger.info(CrudServiceMsgs.LOADED_OXM_FILE, "Relationship Schema and Properties files: " + rulesFiles.stream().map(f -> filename(f)).collect(Collectors.toList()));
+ .collect(Collectors.groupingBy(f -> myMatcher(versionPattern, filename(f))))
+ .forEach((version, resourceAndFile) -> {
+ if (resourceAndFile.size() == 2) {
+ versionContextMap.put(version, jsonFilesLoader(version, resourceAndFile));
+ } else {
+ String filenames = resourceAndFile.stream().map(f -> filename(f)).collect(Collectors.toList()).toString();
+ String errorMsg = "Expecting a rules and a edge_properties files for " + version + ". Found: "
+ + filenames;
+ logger.warn(CrudServiceMsgs.INVALID_OXM_FILE, errorMsg);
+ }
+ });
+ logger.info(CrudServiceMsgs.LOADED_OXM_FILE, "Relationship Schema and Properties files: "
+ + rulesFiles.stream().map(f -> filename(f)).collect(Collectors.toList()));
} catch (IOException e) {
logger.error(CrudServiceMsgs.INVALID_OXM_DIR, rulesDir);
throw new CrudException("DbEdgeRules or edge_properties files were not found.", new FileNotFoundException());
}
}
- private static String filename (Object k) throws ClassCastException {
- if (k instanceof UrlResource){
+ private static String filename(Object k) throws ClassCastException {
+ if (k instanceof UrlResource) {
return ((UrlResource) k).getFilename();
} else if (k instanceof File) {
return ((File) k).getName();
}
}
- private static RelationshipSchema jsonFilesLoader (String version, List<Object> files) {
+ private static RelationshipSchema jsonFilesLoader(String version, List<Object> files) {
List<String> fileContents = new ArrayList<>();
RelationshipSchema rsSchema = null;
if (files.size() == 2) {
} catch (CrudException | IOException e) {
e.printStackTrace();
logger.error(CrudServiceMsgs.INVALID_OXM_FILE,
- files.stream().map(f -> filename(f)).collect(Collectors.toList()).toString(), e.getMessage());
+ files.stream().map(f -> filename(f)).collect(Collectors.toList()).toString(), e.getMessage());
}
return rsSchema;
}
return rsSchema;
}
- private synchronized static void updateVersionContext(String version, RelationshipSchema rs){
+ private synchronized static void updateVersionContext(String version, RelationshipSchema rs) {
versionContextMap.put(version, rs);
}
- private synchronized static String jsonToRelationSchema (String version, Object file) {
+ private synchronized static String jsonToRelationSchema(String version, Object file) {
InputStream inputStream = null;
String content = null;
try {
- if (file instanceof UrlResource) {
+ if (file instanceof UrlResource) {
inputStream = ((UrlResource) file).getInputStream();
} else {
inputStream = new FileInputStream((File) file);
addtimer(version, file);
}
- content = IOUtils.toString(inputStream, "UTF-8");
+ content = IOUtils.toString(inputStream, "UTF-8");
} catch (IOException e) {
e.printStackTrace();
}
private static void addtimer(String version, Object file) {
TimerTask task = null;
- task = new FileWatcher(
- (File) file) {
+ task = new FileWatcher((File) file) {
protected void onChange(File file) {
// here we implement the onChange
logger.info(CrudServiceMsgs.OXM_FILE_CHANGED, file.getName());
try {
- // Cannot use the file object here because we also have to get the edge properties associated with that version.
+ // Cannot use the file object here because we also have to get the
+ // edge properties associated with that version.
// The properties are stored in a different file.
RelationshipSchemaLoader.loadModels(version);
} catch (Exception e) {
}
}
- private static String myMatcher (Pattern p, String s) {
+ private static String myMatcher(Pattern p, String s) {
Matcher m = p.matcher(s);
return m.matches() ? m.group(1) : "";
}
Code Review / aai / gizmo.git / commitdiff