diff options
Diffstat (limited to 'verigraph/src/it/polito/neo4j')
11 files changed, 3094 insertions, 0 deletions
diff --git a/verigraph/src/it/polito/neo4j/exceptions/DuplicateNodeException.java b/verigraph/src/it/polito/neo4j/exceptions/DuplicateNodeException.java new file mode 100644 index 0000000..fd798b6 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/exceptions/DuplicateNodeException.java @@ -0,0 +1,18 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.exceptions; + +public class DuplicateNodeException extends Exception { + + private static final long serialVersionUID = 1L; + + public DuplicateNodeException(String message){ + super(message); + } +} diff --git a/verigraph/src/it/polito/neo4j/exceptions/MyInvalidDirectionException.java b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidDirectionException.java new file mode 100644 index 0000000..1534ff9 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidDirectionException.java @@ -0,0 +1,19 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.exceptions; + +public class MyInvalidDirectionException extends Exception { + + private static final long serialVersionUID = 1L; + + public MyInvalidDirectionException(String message) + { + super(message); + } +} diff --git a/verigraph/src/it/polito/neo4j/exceptions/MyInvalidIdException.java b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidIdException.java new file mode 100644 index 0000000..05176fb --- /dev/null +++ b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidIdException.java @@ -0,0 +1,19 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.exceptions; + +public class MyInvalidIdException extends Exception { + + private static final long serialVersionUID = 1L; + + public MyInvalidIdException(String message) + { + super(message); + } +} diff --git a/verigraph/src/it/polito/neo4j/exceptions/MyInvalidObjectException.java b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidObjectException.java new file mode 100644 index 0000000..6bda7f2 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/exceptions/MyInvalidObjectException.java @@ -0,0 +1,18 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.exceptions; + +public class MyInvalidObjectException extends Exception { + + private static final long serialVersionUID = 1L; + + public MyInvalidObjectException(String message){ + super(message); + } +} diff --git a/verigraph/src/it/polito/neo4j/exceptions/MyNotFoundException.java b/verigraph/src/it/polito/neo4j/exceptions/MyNotFoundException.java new file mode 100644 index 0000000..53b09dc --- /dev/null +++ b/verigraph/src/it/polito/neo4j/exceptions/MyNotFoundException.java @@ -0,0 +1,19 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.exceptions; + +public class MyNotFoundException extends Exception +{ + private static final long serialVersionUID = -1337751234736465663L; + + public MyNotFoundException(String message) + { + super(message); + } +} diff --git a/verigraph/src/it/polito/neo4j/manager/Neo4jDBInteraction.java b/verigraph/src/it/polito/neo4j/manager/Neo4jDBInteraction.java new file mode 100644 index 0000000..d9e006e --- /dev/null +++ b/verigraph/src/it/polito/neo4j/manager/Neo4jDBInteraction.java @@ -0,0 +1,56 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.manager; + +import java.util.Set; + +import org.neo4j.graphdb.Label; +import org.neo4j.graphdb.RelationshipType; + +import it.polito.neo4j.jaxb.Graph; +import it.polito.neo4j.jaxb.Graphs; +import it.polito.neo4j.jaxb.Neighbour; +import it.polito.neo4j.jaxb.Paths; +import it.polito.neo4j.exceptions.DuplicateNodeException; +import it.polito.neo4j.exceptions.MyInvalidIdException; +import it.polito.neo4j.exceptions.MyInvalidObjectException; +import it.polito.neo4j.exceptions.MyNotFoundException; + +public interface Neo4jDBInteraction { + public enum NodeType implements Label + { + Nffg, Node, Firewall, EndHost, EndPoint, Antispam, Cache, DPI, Mailclient, Mailserver, NAT, VPNAccess, VPNExit, Webclient, Webserver, Configuration, Fieldmodifier; + } + public enum RelationType implements RelationshipType + { + PathRelationship, OwnerRelationship, ConfigurationRelantionship, ElementRelationship; + } + + public void createGraphs(Graphs graphs) throws MyNotFoundException, MyInvalidIdException; + public Graph createGraph(Graph graph) throws MyNotFoundException, MyInvalidIdException; + public it.polito.neo4j.jaxb.Node createNode(it.polito.neo4j.jaxb.Node node, long graphId) throws MyNotFoundException, DuplicateNodeException, MyInvalidIdException; + public Neighbour createNeighbour(Neighbour neighbour, long graphId, long nodeId) throws MyNotFoundException; + + public Graphs getGraphs(); + public Graph getGraph(long id) throws MyNotFoundException; + public Set<it.polito.neo4j.jaxb.Node> getNodes(long graphId) throws MyNotFoundException; + public it.polito.neo4j.jaxb.Node getNode(long graphId, long nodeId) throws MyNotFoundException; + public Set<Neighbour> getNeighbours(long graphId, long nodeId) throws MyNotFoundException; + public Neighbour getNeighbour(long graphId, long nodeId, long neighbourId) throws MyNotFoundException; + + public void deleteGraph(long id) throws MyNotFoundException; + public void deleteNode(long graphId, long nodeId) throws MyNotFoundException; + public void deleteNeighbour(long graphId, long nodeId, long neighbourId) throws MyNotFoundException; + + public it.polito.neo4j.jaxb.Node updateNode(it.polito.neo4j.jaxb.Node node, long graphId, long nodeId) throws MyNotFoundException, MyInvalidObjectException, MyInvalidIdException; + public Graph updateGraph(Graph graph, long graphId) throws MyNotFoundException, MyInvalidObjectException, DuplicateNodeException, MyInvalidIdException; + public it.polito.neo4j.jaxb.Node updateNeighbour(Neighbour neighbour, long graphId, long nodeId, long neighbourId) throws MyNotFoundException, MyInvalidObjectException; + + public Paths findAllPathsBetweenTwoNodes(long graphId, String srcName, String dstName, String direction) throws MyNotFoundException; +} diff --git a/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java b/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java new file mode 100644 index 0000000..40789c8 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java @@ -0,0 +1,381 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.manager; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.logging.Logger; + +import javax.ws.rs.BadRequestException; +import javax.ws.rs.ForbiddenException; +import javax.ws.rs.NotFoundException; +import javax.ws.rs.PathParam; +import javax.ws.rs.QueryParam; +import javax.xml.bind.JAXBException; + +import com.fasterxml.jackson.core.JsonParseException; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonMappingException; + +import it.polito.neo4j.exceptions.DuplicateNodeException; +import it.polito.neo4j.exceptions.MyInvalidObjectException; +import it.polito.neo4j.exceptions.MyNotFoundException; +import it.polito.neo4j.jaxb.ObjectFactory; +import it.polito.neo4j.jaxb.Paths; +import it.polito.neo4j.translator.GraphToNeo4j; +import it.polito.neo4j.translator.Neo4jToGraph; +import it.polito.neo4j.exceptions.MyInvalidDirectionException; +import it.polito.neo4j.exceptions.MyInvalidIdException; +import it.polito.verigraph.exception.DataNotFoundException; +import it.polito.verigraph.model.Configuration; +import it.polito.verigraph.model.Graph; +import it.polito.verigraph.model.Neighbour; +import it.polito.verigraph.model.Node; +import it.polito.verigraph.service.VerigraphLogger; + +public class Neo4jDBManager { + + public static Neo4jLibrary lib = Neo4jLibrary.getNeo4jLibrary(); + //static ObjectFactory obFactory = new ObjectFactory(); + + public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger(); + + + public it.polito.verigraph.model.Graph updateGraph(it.polito.verigraph.model.Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException{ + + it.polito.neo4j.jaxb.Graph graph_xml=GraphToNeo4j.generateObject(graph); + it.polito.neo4j.jaxb.Graph graphReturned; + long graphId; + + try{ + graphId = graph.getId(); + graphReturned = lib.updateGraph(graph_xml, graphId); + it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned); + return g; + + } + catch(MyNotFoundException e1){ + vlogger.logger.info("error update 1"); + throw new NotFoundException(); + } + + catch(DuplicateNodeException e3){ + vlogger.logger.info("error update 2"); + throw new BadRequestException(e3.getMessage()); + } + catch(MyInvalidObjectException e4){ + vlogger.logger.info("error update 3"); + throw new BadRequestException(e4.getMessage()); + } + } + + public void deleteGraph(long id){ + + try{ + lib.deleteGraph(id); + } + catch(MyNotFoundException e1){ + throw new NotFoundException(); + } + } + + public it.polito.verigraph.model.Graph addGraph(it.polito.verigraph.model.Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException { + + it.polito.neo4j.jaxb.Graph graph_xml=GraphToNeo4j.generateObject(graph); + it.polito.neo4j.jaxb.Graph graphReturned; + it.polito.neo4j.jaxb.Node node; + + try{ + graphReturned = lib.createGraph(graph_xml); + it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned); + return g; + + } + catch(MyNotFoundException e){ + e.printStackTrace(); + throw new NotFoundException(); + + } + } + public it.polito.verigraph.model.Graph getGraph(long graphId) throws JAXBException, JsonParseException, JsonMappingException, IOException { + + it.polito.neo4j.jaxb.Graph graphReturned; + + try{ + graphReturned = lib.getGraph(graphId); + + it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(graphReturned); + + return g; + + } + catch(MyNotFoundException e){ + e.printStackTrace(); + throw new NotFoundException(); + } + + } + + public List<it.polito.verigraph.model.Graph> getGraphs() throws JsonProcessingException, MyNotFoundException { + + List<it.polito.verigraph.model.Graph> graphsReturned=new ArrayList<it.polito.verigraph.model.Graph>(); + it.polito.neo4j.jaxb.Graphs graphs; + + graphs = lib.getGraphs(); + for(it.polito.neo4j.jaxb.Graph tmp : graphs.getGraph()){ + it.polito.verigraph.model.Graph g=Neo4jToGraph.generateGraph(tmp); + graphsReturned.add(g); + } + + return graphsReturned; + + } + + public it.polito.verigraph.model.Neighbour addNeighbours(long graphId, long nodeId, it.polito.verigraph.model.Neighbour neighbour) throws JsonProcessingException { + + it.polito.neo4j.jaxb.Neighbour neighbour_xml=GraphToNeo4j.NeighbourToNeo4j(neighbour); + it.polito.neo4j.jaxb.Neighbour neighReturned; + it.polito.verigraph.model.Neighbour n; + try{ + neighReturned = lib.createNeighbour(neighbour_xml, graphId, nodeId); + n=Neo4jToGraph.NeighbourToVerigraph(neighReturned); + return n; + } + catch(MyNotFoundException e2){ + e2.printStackTrace(); + throw new NotFoundException(); + } + } + + public Neighbour deleteNeighbour(long graphId, long nodeId, long neighbourId) { + + try{ + it.polito.neo4j.jaxb.Neighbour n=lib.getNeighbour(graphId, nodeId, neighbourId); + if(n==null){ + throw new DataNotFoundException("Neighbour validation failed: '"+ neighbourId + + "' is not a valid id for a neighbour of node '" + nodeId + "'" + "' of graph '" + graphId + "'"); + }else{ + lib.deleteNeighbour(graphId, nodeId, neighbourId); + return Neo4jToGraph.NeighbourToVerigraph(n); + } + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + }catch (JsonProcessingException e) { + throw new NotFoundException("jsonprocessing node"); + } + + } + + public Neighbour updateNeighbour(long graphId, long nodeId, it.polito.verigraph.model.Neighbour neighbour) throws JsonProcessingException { + it.polito.neo4j.jaxb.Neighbour neighbour_xml=GraphToNeo4j.NeighbourToNeo4j(neighbour); + it.polito.neo4j.jaxb.Node nodeReturned; + Neighbour r; + try{ + nodeReturned=lib.updateNeighbour(neighbour_xml, graphId, nodeId, neighbour_xml.getId()); + r=Neo4jToGraph.NeighbourToVerigraph(lib.getNeighbour(graphId, nodeReturned.getId(), neighbour_xml.getId())); + return r; + } + catch(MyNotFoundException e2){ + throw new NotFoundException(); + } catch (MyInvalidObjectException e) { + e.printStackTrace(); + } + return null; + + } + + public it.polito.verigraph.model.Node addNode(long graphId, it.polito.verigraph.model.Node node) throws IOException, MyInvalidIdException { + it.polito.neo4j.jaxb.Node node_xml=GraphToNeo4j.NodeToNeo4j(node); + it.polito.neo4j.jaxb.Node nodeReturned; + it.polito.verigraph.model.Node node_v=new it.polito.verigraph.model.Node(); + try + { + + nodeReturned = lib.createNode(node_xml, graphId); + node_v=Neo4jToGraph.NodeToVerigraph(nodeReturned); + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + + catch(DuplicateNodeException e3){ + e3.printStackTrace(); + throw new BadRequestException(); + } + return node_v; + } + + public Node updateNode(long graphId, Node node, long id) throws IOException, MyInvalidIdException { + it.polito.neo4j.jaxb.Node node_xml=GraphToNeo4j.NodeToNeo4j(node); + it.polito.neo4j.jaxb.Node nodeReturned; + Node node_v; + try{ + nodeReturned = lib.updateNode(node_xml, graphId, id); + node_v=Neo4jToGraph.NodeToVerigraph(nodeReturned); + return node_v; + } + catch(MyNotFoundException e2){ + e2.printStackTrace(); + throw new NotFoundException(); + } + catch(MyInvalidObjectException e3){ + e3.printStackTrace(); + throw new BadRequestException(e3.getMessage()); + } + + } + + public Node deleteNode(long graphId, long nodeId) { + + try{ + it.polito.neo4j.jaxb.Node n=lib.getNodeById(nodeId, graphId); + lib.deleteNode(graphId, nodeId); + return Neo4jToGraph.NodeToVerigraph(n); + } + catch(MyNotFoundException e1){ + throw new NotFoundException("graph or node not found"); + } catch (JsonProcessingException e) { + throw new NotFoundException("jsonprocessing node"); + } + } + + public Paths getPath(long graphId, String source, String destination, String direction) throws MyInvalidDirectionException { + it.polito.neo4j.jaxb.Paths paths=(new ObjectFactory()).createPaths(); + try{ + if(source == null || destination == null || direction == null) + throw new DataNotFoundException("Missing query parameters"); + paths = lib.findAllPathsBetweenTwoNodes(graphId, source, destination,direction); + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + + } + + return paths; + } + + public Map<Long, Node> getNodes(long graphId) throws JsonProcessingException { + Map<Long, Node> nodes=new HashMap<Long, Node>(); + try + { + Set<it.polito.neo4j.jaxb.Node> set= lib.getNodes(graphId); + nodes=Neo4jToGraph.NodesToVerigraph(set); + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + return nodes; + + } + + public Map<Long, Neighbour> getNeighbours(long graphId, long nodeId) throws JsonProcessingException { + Map<Long, Neighbour> neighbours=new HashMap<Long, Neighbour>(); + try + { + Set<it.polito.neo4j.jaxb.Neighbour> set= lib.getNeighbours(graphId, nodeId); + neighbours=Neo4jToGraph.NeighboursToVerigraph(set); + return neighbours; + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + + } + + public Node getNodeByName(long graphId, String name) throws JsonProcessingException { + + it.polito.verigraph.model.Node node; + try + { + it.polito.neo4j.jaxb.Node set= lib.getNodeByName(name, graphId); + if(set==null) + return null; + else{ + node=Neo4jToGraph.NodeToVerigraph(set); + return node; + } + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + + } + + public Node getNodeById(long nodeId, long graphId) throws JsonProcessingException { + it.polito.verigraph.model.Node node; + try + { + it.polito.neo4j.jaxb.Node set= lib.getNodeById(nodeId, graphId); + if(set==null) + return null; + else{ + node=Neo4jToGraph.NodeToVerigraph(set); + return node; + } + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + } + + public Neighbour getNeighbour(long graphId, long nodeId, long neighbourId) throws JsonProcessingException { + try + { + it.polito.neo4j.jaxb.Neighbour set= lib.getNeighbour(graphId, nodeId, neighbourId); + if(set!=null) + return Neo4jToGraph.NeighbourToVerigraph(set); + else + return null; + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + } + + public void checkGraph(long graphId) { + + try + { + lib.checkGraph(graphId); + } + catch(MyNotFoundException e1){ + e1.printStackTrace(); + throw new NotFoundException(); + } + } + + public Configuration updateConfiguration(long nodeId, long graphId, Configuration nodeConfiguration, Node node) throws JsonParseException, JsonMappingException, IOException, MyInvalidIdException { + + try{ + + it.polito.neo4j.jaxb.Configuration conf=GraphToNeo4j.ConfToNeo4j(nodeConfiguration, node); + it.polito.neo4j.jaxb.Configuration c=lib.updateConfiguration(nodeId, graphId, conf); + Configuration r=Neo4jToGraph.ConfToVerigraph(c); + return r; + } + catch(MyNotFoundException e2){ + e2.printStackTrace(); + throw new NotFoundException(); + } + } + +} diff --git a/verigraph/src/it/polito/neo4j/manager/Neo4jLibrary.java b/verigraph/src/it/polito/neo4j/manager/Neo4jLibrary.java new file mode 100644 index 0000000..994fa52 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/manager/Neo4jLibrary.java @@ -0,0 +1,1585 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.manager; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Set; +import java.util.logging.Logger; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.neo4j.graphalgo.GraphAlgoFactory; +import org.neo4j.graphalgo.PathFinder; +import org.neo4j.graphdb.Direction; +import org.neo4j.graphdb.GraphDatabaseService; +import org.neo4j.graphdb.Label; +import org.neo4j.graphdb.Node; +import org.neo4j.graphdb.NotFoundException; +import org.neo4j.graphdb.Path; +import org.neo4j.graphdb.PathExpanders; +import org.neo4j.graphdb.PropertyContainer; +import org.neo4j.graphdb.Relationship; +import org.neo4j.graphdb.RelationshipType; +import org.neo4j.graphdb.ResourceIterator; +import org.neo4j.graphdb.Transaction; +import org.neo4j.graphdb.factory.GraphDatabaseFactory; +import org.neo4j.graphdb.traversal.Paths; + +import com.fasterxml.jackson.core.JsonGenerationException; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.ObjectMapper; + +import it.polito.neo4j.jaxb.Antispam; +import it.polito.neo4j.jaxb.Cache; +import it.polito.neo4j.jaxb.Configuration; +import it.polito.neo4j.jaxb.Dpi; +import it.polito.neo4j.jaxb.Elements; +import it.polito.neo4j.jaxb.Endhost; +import it.polito.neo4j.jaxb.Endpoint; +import it.polito.neo4j.jaxb.Fieldmodifier; +import it.polito.neo4j.jaxb.Firewall; +import it.polito.neo4j.jaxb.FunctionalTypes; +import it.polito.neo4j.jaxb.Graph; +import it.polito.neo4j.jaxb.Graphs; +import it.polito.neo4j.jaxb.Mailclient; +import it.polito.neo4j.jaxb.Mailserver; +import it.polito.neo4j.jaxb.Nat; +import it.polito.neo4j.jaxb.Neighbour; +import it.polito.neo4j.jaxb.ObjectFactory; +import it.polito.neo4j.jaxb.ProtocolTypes; +import it.polito.neo4j.jaxb.Vpnaccess; +import it.polito.neo4j.jaxb.Vpnexit; +import it.polito.neo4j.jaxb.Webclient; +import it.polito.neo4j.jaxb.Webserver; +import it.polito.neo4j.manager.Neo4jDBInteraction.NodeType; +import it.polito.verigraph.exception.DataNotFoundException; +import it.polito.verigraph.service.VerigraphLogger; +import it.polito.neo4j.exceptions.DuplicateNodeException; +import it.polito.neo4j.exceptions.MyInvalidIdException; +import it.polito.neo4j.exceptions.MyInvalidObjectException; +import it.polito.neo4j.exceptions.MyNotFoundException; + + +public class Neo4jLibrary implements Neo4jDBInteraction +{ + private static final int MAX_DEPTH = 50; + + + private static final RelationshipType ElementRelationship = null; + + + + private GraphDatabaseFactory dbFactory; + private GraphDatabaseService graphDB; + private ObjectFactory obFactory; + private static Neo4jLibrary neo4jLib = new Neo4jLibrary(); + public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger(); + + private Neo4jLibrary() + { + try { + FileReader r; + Properties p = new Properties(); + String neo4j_path = System.getProperty("catalina.home"); + + if(neo4j_path != null){ + r = new FileReader(new File(neo4j_path+File.separator+"/webapps/verigraph/server.properties")); + + }else{ + neo4j_path=System.getProperty("user.dir"); + r= new FileReader(new File(neo4j_path+File.separator+"/server.properties")); + } + + p.load(r); + String pathDB = (String) p.get("graphDBPath"); + dbFactory = new GraphDatabaseFactory(); + graphDB = dbFactory.newEmbeddedDatabase(new File(neo4j_path + "/neo4j"+File.separator+pathDB)); + VerigraphLogger.logger.info("Database location is "+ neo4j_path + "/neo4j"+File.separator+pathDB); + registerShutdownHook(graphDB); + obFactory = new ObjectFactory(); + + } catch (FileNotFoundException e1) { + e1.printStackTrace(); + } + catch (IOException e) { + e.printStackTrace(); + } + } + + //singleton class + public static Neo4jLibrary getNeo4jLibrary(){ + return neo4jLib; + } + + private static void registerShutdownHook(final GraphDatabaseService graphDB) + { + // Registers a shutdown hook for the Neo4j instance so that it shuts down + // nicely when the VM exits (even if you "Ctrl-C" the running application). + Runtime.getRuntime().addShutdownHook(new Thread() + { + @Override + public void run() + { + graphDB.shutdown(); + } + }); + } + + public void createGraphs(Graphs graphs) throws MyNotFoundException, MyInvalidIdException + { + for (Graph graph : graphs.getGraph()) + { + createGraph(graph); + } + } + + public Graph createGraph(Graph graph) throws MyNotFoundException, MyInvalidIdException{ + Transaction tx = graphDB.beginTx(); + + try + { + Node nffgRoot = graphDB.createNode(NodeType.Nffg); + nffgRoot.setProperty("id", nffgRoot.getId()); + graph.setId(nffgRoot.getId()); + + for(it.polito.neo4j.jaxb.Node nodo : graph.getNode()){ + Node newNode = createNode(nffgRoot, nodo, graph); + nodo.setId(newNode.getId()); + it.polito.neo4j.jaxb.Configuration c=nodo.getConfiguration(); + Node newConf=createConfiguration(newNode, c); + c.setId(newConf.getId()); + + } + + //modify the neighbours id inserting the relationship + + for(it.polito.neo4j.jaxb.Node nodo : graph.getNode()){ + Map<String, Neighbour> neighs = addNeighbours(nodo, graph); + + for(Neighbour neig : nodo.getNeighbour()){ + Neighbour n = neighs.get(neig.getName()); + neig.setId(n.getId()); + + } + + } + + tx.success(); + + } + finally + { + tx.close(); + + } + return graph; + } + + private Node createConfiguration(Node newNode, Configuration c) throws MyInvalidIdException { + + Node newConf=graphDB.createNode(NodeType.Configuration); + newConf.setProperty("name", c.getName()); + newConf.setProperty("id", newConf.getId()); + c.setId(newConf.getId()); + if(c.getDescription()!=null) + newConf.setProperty("description", c.getDescription()); + + Relationship r=newConf.createRelationshipTo(newNode, RelationType.ConfigurationRelantionship); + r.setProperty("id", newNode.getId()); + setConfiguration(newConf, c.getName().toUpperCase(), c); + + return newConf; + + } + + private void setConfiguration(Node newConf, String type, it.polito.neo4j.jaxb.Configuration c) throws MyInvalidIdException { + + switch(type){ + + case "FIREWALL":{ + List<Elements> list=c.getFirewall().getElements(); + if(!list.isEmpty()){ + for(Elements e : list){ + Node newElem=graphDB.createNode(NodeType.Firewall); + newElem.setProperty("source", e.getSource()); + newElem.setProperty("destination", e.getDestination()); + + Relationship firewall=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + firewall.setProperty("id", newConf.getId()); + } + + }else{ + vlogger.logger.info("Configuration firewall empty"); + + } + break; + } + + case "ANTISPAM":{ + List<String> list=c.getAntispam().getSource(); + if(!list.isEmpty()){ + for(String s : list){ + Node newElem=graphDB.createNode(NodeType.Antispam); + newElem.setProperty("source", s); + Relationship antispam=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + antispam.setProperty("id", newConf.getId()); + } + + }else{ + vlogger.logger.info("Configuration Antispam empty"); + + } + break; + + } + case "CACHE":{ + List<String> list=c.getCache().getResource(); + if(!list.isEmpty()){ + for(String s : list){ + Node newElem=graphDB.createNode(NodeType.Cache); + newElem.setProperty("resource", s); + Relationship cache=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + cache.setProperty("id", newConf.getId()); + } + }else{ + vlogger.logger.info("Configuration Cache empty"); + + } + break; + + } + case "DPI":{ + List<String> list=c.getDpi().getNotAllowed(); + if(!list.isEmpty()){ + for(String s : list){ + Node newElem=graphDB.createNode(NodeType.DPI); + newElem.setProperty("notAllowed", s); + Relationship dpi=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + dpi.setProperty("id", newConf.getId()); + } + }else{ + vlogger.logger.info("Configuration Dpi empty"); + + } + break; + } + case "ENDHOST":{ + String destination=c.getEndhost().getDestination(); + String body=c.getEndhost().getBody(); + String email_from=c.getEndhost().getEmailFrom(); + ProtocolTypes protocol=c.getEndhost().getProtocol(); + String options=c.getEndhost().getOptions(); + String url=c.getEndhost().getUrl(); + BigInteger sequence=c.getEndhost().getSequence(); + if(destination!=null){ + Node dest=graphDB.createNode(NodeType.EndHost); + dest.setProperty("destination", destination); + Relationship d=dest.createRelationshipTo(newConf, RelationType.ElementRelationship); + d.setProperty("id", newConf.getId()); + d.setProperty("name", "destination"); + } + if(body!=null){ + Node b=graphDB.createNode(NodeType.EndHost); + b.setProperty("body", body); + Relationship bo=b.createRelationshipTo(newConf, RelationType.ElementRelationship); + bo.setProperty("id", newConf.getId()); + bo.setProperty("name", "body"); + + } + if(email_from!=null){ + Node email=graphDB.createNode(NodeType.EndHost); + email.setProperty("email_from", email_from); + Relationship e_from=email.createRelationshipTo(newConf, RelationType.ElementRelationship); + e_from.setProperty("id", newConf.getId()); + e_from.setProperty("name", "email_from"); + } + if(protocol!=null){ + String protocollo=c.getEndhost().getProtocol().value(); + Node proto=graphDB.createNode(NodeType.EndHost); + proto.setProperty("protocol", protocollo); + Relationship p=proto.createRelationshipTo(newConf, RelationType.ElementRelationship); + p.setProperty("id", newConf.getId()); + p.setProperty("name", "protocol"); + } + if(options!=null){ + Node opt=graphDB.createNode(NodeType.EndHost); + opt.setProperty("options", options); + Relationship o=opt.createRelationshipTo(newConf, RelationType.ElementRelationship); + o.setProperty("id", newConf.getId()); + o.setProperty("name", "options"); + } + if(url!=null){ + Node u=graphDB.createNode(NodeType.EndHost); + u.setProperty("url", url); + Relationship ur=u.createRelationshipTo(newConf, RelationType.ElementRelationship); + ur.setProperty("id", newConf.getId()); + ur.setProperty("name", "url"); + } + if(sequence != null && !sequence.equals(BigInteger.ZERO)){ + Node seq=graphDB.createNode(NodeType.EndHost); + seq.setProperty("sequence", sequence); + Relationship seque=seq.createRelationshipTo(newConf, RelationType.ElementRelationship); + seque.setProperty("id", newConf.getId()); + seque.setProperty("name", "sequence"); + } + + break; + } + case "ENDPOINT":{ + vlogger.logger.info("It is an ENDPOINT"); + + break; + } + case "FIELDMODIFIER":{ + vlogger.logger.info("It is a FIELMODIFIER"); + + break; + + } + + case "MAILCLIENT":{ + String list=c.getMailclient().getMailserver(); + if(list!=null){ + Node newElem=graphDB.createNode(NodeType.Mailclient); + newElem.setProperty("mailserver", list); + Relationship mailclient=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + mailclient.setProperty("id", newConf.getId()); + }else{ + vlogger.logger.info("Configuration Mailclient empty"); + + } + + break; + } + case "MAILSERVER":{ + vlogger.logger.info("It is a MAILSERVER"); + + break; + } + case "NAT":{ + + List<String> list=c.getNat().getSource(); + if(!list.isEmpty()){ + for(String s : list){ + Node newElem=graphDB.createNode(NodeType.NAT); + newElem.setProperty("source", s); + Relationship nat=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + nat.setProperty("id", newConf.getId()); + } + }else{ + vlogger.logger.info("Configuration Nat empty"); + + } + break; + } + + + case "VPNACCESS":{ + String list=c.getVpnaccess().getVpnexit(); + if(list!=null){ + Node newElem=graphDB.createNode(NodeType.VPNAccess); + newElem.setProperty("vpnexit", list); + Relationship vpnaccess=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + vpnaccess.setProperty("id", newConf.getId()); + }else{ + vlogger.logger.info("Configuration Vpnaccess empty"); + + } + + break; + } + case "VPNEXIT":{ + String list=c.getVpnexit().getVpnaccess(); + if(list!=null){ + Node newElem=graphDB.createNode(NodeType.VPNExit); + newElem.setProperty("vpnaccess", list); + Relationship vpnexit=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + vpnexit.setProperty("id", newConf.getId()); + }else{ + vlogger.logger.info("Configuration Vpnexit empty"); + + } + + break; + } + case "WEBCLIENT":{ + String list=c.getWebclient().getNameWebServer(); + if(list!=null){ + Node newElem=graphDB.createNode(NodeType.Webclient); + newElem.setProperty("webserver", list); + Relationship webclient=newElem.createRelationshipTo(newConf, RelationType.ElementRelationship); + webclient.setProperty("id", newConf.getId()); + }else{ + vlogger.logger.info("Configuration Webclient empty"); + + } + + break; + } + case "WEBSERVER":{ + vlogger.logger.info("It's a webserver"); + break; + } + default:{ + throw new MyInvalidIdException("Element node "+type+" not valid"); + } + } + + } + + private Node createNode(Node nffgRoot, it.polito.neo4j.jaxb.Node nodo, it.polito.neo4j.jaxb.Graph graph){ + Node newNode = graphDB.createNode(NodeType.Node); + newNode.setProperty("name", nodo.getName()); + newNode.setProperty("functionalType", nodo.getFunctionalType().value()); + nodo.setId(newNode.getId()); + newNode.setProperty("id", newNode.getId()); + Relationship r=newNode.createRelationshipTo(nffgRoot, RelationType.OwnerRelationship); + r.setProperty("id", graph.getId()); + + return newNode; + } + + private Map<String,Neighbour> addNeighbours(it.polito.neo4j.jaxb.Node nodo, Graph graph) throws MyNotFoundException{ + + Node srcNode = graphDB.findNode(NodeType.Node, "id", nodo.getId()); + if(srcNode==null){ + throw new DataNotFoundException("Source node (in neighbour node) not found"); + } + + + Map<String,Neighbour> neighbours = new HashMap<>(); + + for(Neighbour neighbour : nodo.getNeighbour()){ + + Node dstNode = findNodeByNameOfSpecificGraph(neighbour.getName(), graph.getId()); + + if(dstNode == null) + throw new DataNotFoundException("Destination node (in neighbour node) not found"); + + Relationship rel = srcNode.createRelationshipTo(dstNode,RelationType.PathRelationship); + + neighbour.setId(dstNode.getId()); + rel.setProperty("id", neighbour.getId()); + neighbours.put((String)dstNode.getProperty("name"),neighbour); + } + return neighbours; + } + + private Node findNodeByIdAndSpecificGraph(long nodoId, long graphId) throws MyNotFoundException { + + Node node=graphDB.findNode(NodeType.Node, "id", nodoId); + Node n; + + if(node == null) + throw new DataNotFoundException("There is no Node whose Id is '" + nodoId + "'"); + else{ + + for(Relationship rel : node.getRelationships(RelationType.OwnerRelationship)){ + Node[] nodi = rel.getNodes(); + if(nodi[0].getId() == graphId || nodi[1].getId() == graphId){ + if((long)rel.getProperty("id") == graphId) + return node; + + } + + } + } + return node; + } + + private Node findNodeByNameOfSpecificGraph(String nodeName, long graphId){ + + ResourceIterator<Node> nodes = graphDB.findNodes(NodeType.Node, "name", nodeName); + while (nodes.hasNext()){ + Node n = nodes.next(); + for(Relationship rel : n.getRelationships(RelationType.OwnerRelationship)){ + Node[] nodi = rel.getNodes(); + if((nodi[0].getId() == graphId || nodi[1].getId()== graphId)){ + if((long)rel.getProperty("id") == graphId) + return n; + } + } + } + return null; + } + + public it.polito.neo4j.jaxb.Node createNode(it.polito.neo4j.jaxb.Node node, long graphId) throws MyNotFoundException, DuplicateNodeException, MyInvalidIdException{ + Node graph; + Transaction tx = graphDB.beginTx(); + + + try{ + graph = findGraph(graphId); + Graph myGraph = getGraph(graphId); + if(DuplicateNode(node,myGraph)) + throw new DuplicateNodeException("This node is already present"); + Node newNode = createNode(graph,node,myGraph); + node.setId(newNode.getId()); + it.polito.neo4j.jaxb.Configuration c=node.getConfiguration(); + Node newConf=createConfiguration(newNode, c); + c.setId(newConf.getId()); + Map<String, Neighbour> neighs = addNeighbours(node, myGraph); + for(Neighbour neig : node.getNeighbour()){ + Neighbour n = neighs.get(neig.getName()); + neig.setId(n.getId()); + } + + tx.success(); + } + finally{ + tx.close(); + } + return node; + } + + private boolean DuplicateNode(it.polito.neo4j.jaxb.Node node, Graph myGraph) { + for(it.polito.neo4j.jaxb.Node n : myGraph.getNode()){ + if(n.getName().compareTo(node.getName()) == 0) + return true; + } + return false; + } + + public Graphs getGraphs(){ + Graphs graphs = obFactory.createGraphs(); + Transaction tx = graphDB.beginTx(); + + try{ + ResourceIterator<Node> graphNodes = graphDB.findNodes(NodeType.Nffg); + while(graphNodes.hasNext()){ + Node currentGraph = graphNodes.next(); + Graph g = getGraph(currentGraph.getId()); + graphs.getGraph().add(g); + } + tx.success(); + } + catch(MyNotFoundException e){ + //NEVER BEEN HERE + } + finally{ + tx.close(); + } + return graphs; + } + + public Graph getGraph(long id) throws MyNotFoundException{ + Graph graph = obFactory.createGraph(); + Transaction tx = graphDB.beginTx(); + + try + { + findGraph(id);//this method rises an exception if not found graph with Id id + graph.setId(id); + Set<Node> nodes = retrieveNodesOfSpecificGraph(id); + + for(Node nodo : nodes){ + + graph.getNode().add(retrieveNode(nodo)); + } + tx.success(); + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + return graph; + } + + private Set<Node> retrieveNodesOfSpecificGraph(long graphId){ + Set<Node> nodi = new HashSet<>(); + + Node nodo; + ResourceIterator<Node> nodes = graphDB.findNodes(NodeType.Node); + while (nodes.hasNext()) + { + nodo = nodes.next(); + Relationship rel = nodo.getSingleRelationship(RelationType.OwnerRelationship, Direction.BOTH); + if(rel != null){ + Node[] nodiRelation = rel.getNodes(); + if((nodiRelation[0].getId()==graphId || nodiRelation[1].getId()==graphId)) + if((long)rel.getProperty("id")==graphId) + nodi.add(nodo); + } + } + return nodi; + } + + private Node findGraph(long graphId) throws MyNotFoundException{ + Node graph; + + try{ + graph=graphDB.findNode(NodeType.Nffg, "id", graphId); + if(graph==null){ + throw new DataNotFoundException("There is no Graph whose Id is '" + graphId + "'"); + + } + } + catch(NotFoundException e){ + throw new MyNotFoundException("There is no Graph whose Id is '" + graphId + "'"); + } + + return graph; + } + + private Node findNode(long nodeId) throws MyNotFoundException{ + Node node; + + try{ + node=graphDB.findNode(NodeType.Node, "id", nodeId); + if(node==null) + throw new DataNotFoundException("There is no Node whose Id is '" + nodeId + "'"); + } + catch(NotFoundException e){ + throw new MyNotFoundException("There is no Node whose Id is '" + nodeId + "'"); + } + + return node; + } + + + private void addNeighbour(it.polito.neo4j.jaxb.Node src, Node dst, long neighbourId){ + Neighbour vicino = obFactory.createNeighbour(); + vicino.setId(neighbourId); + vicino.setName((String) dst.getProperty("name")); + src.getNeighbour().add(vicino); + } + + private it.polito.neo4j.jaxb.Node retrieveNode(Node nodo){ + it.polito.neo4j.jaxb.Node n = obFactory.createNode(); + + n.setId(nodo.getId()); + n.setName( nodo.getProperty("name").toString()); + n.setFunctionalType(it.polito.neo4j.jaxb.FunctionalTypes.valueOf((String) nodo.getProperty("functionalType"))); + + //retrieve neighbours: + Iterable<Relationship> links = nodo.getRelationships(RelationType.PathRelationship, Direction.OUTGOING); + Iterator<Relationship> linksIt = links.iterator(); + while(linksIt.hasNext()){ + Relationship link = linksIt.next(); + Node endpoint = link.getEndNode(); + addNeighbour(n, endpoint, (long)link.getProperty("id")); + } + + //retrieve configuration: + it.polito.neo4j.jaxb.Configuration c=obFactory.createConfiguration(); + c=retrieveconfiguration(nodo); + n.setConfiguration(c); + + return n; + } + + private Configuration retrieveconfiguration(Node nodo) { + it.polito.neo4j.jaxb.Configuration c=obFactory.createConfiguration(); + Relationship rel = nodo.getSingleRelationship(RelationType.ConfigurationRelantionship, Direction.BOTH); + if(rel != null){ + Node conf; + Node[] nodiRelation = rel.getNodes(); + String func_type; + if((nodiRelation[0].getId()==nodo.getId() || nodiRelation[1].getId()==nodo.getId())){ + if((long)rel.getProperty("id") == nodo.getId()){ + if(nodiRelation[0].hasLabel(NodeType.Configuration)){ + conf=nodiRelation[0]; + }else{ + conf=nodiRelation[1]; + } + func_type=conf.getProperty("name").toString(); + c.setId((long)conf.getProperty("id")); + Object value=conf.getProperty("description", "null"); + if(value!="null") + c.setDescription(conf.getProperty("description").toString()); + c.setName(func_type); + switch(c.getName().toUpperCase()){ + + case "FIREWALL":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Firewall firewall=new Firewall(); + List<Elements> element_list=new ArrayList<Elements>(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.Firewall)){ + Elements e=new Elements(); + e.setDestination(element.getProperty("destination").toString()); + e.setSource(element.getProperty("source").toString()); + element_list.add(e); + } + } + firewall.getElements().addAll(element_list); + c.setFirewall(firewall); + break; + + } + + case "ANTISPAM":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Antispam antispam=new Antispam(); + List<String> source=new ArrayList<String>(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.Antispam)){ + String s=element.getProperty("source").toString(); + source.add(s); + } + } + antispam.getSource().addAll(source); + c.setAntispam(antispam); + break; + } + + case "CACHE":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Cache cache=new Cache(); + List<String> resource=new ArrayList<String>(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.Cache)){ + String s=element.getProperty("resource").toString(); + resource.add(s); + } + } + cache.getResource().addAll(resource); + c.setCache(cache); + break; + } + case "DPI":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Dpi dpi=new Dpi(); + List<String> notAllowed=new ArrayList<String>(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.DPI)){ + String s=element.getProperty("notAllowed").toString(); + notAllowed.add(s); + } + } + dpi.getNotAllowed().addAll(notAllowed); + c.setDpi(dpi); + break; + } + + case "ENDHOST":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Endhost endhost=new Endhost(); + String destination=new String(); + String body=new String(); + String email_from=new String(); + String protocol=new String(); + String options=new String(); + String url=new String(); + BigInteger sequence=null; + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.EndHost)){ + String type=relConf.getProperty("name").toString(); + if(type.compareTo("destination")==0){ + destination=element.getProperty("destination").toString(); + }else + if(type.compareTo("body")==0){ + body=element.getProperty("body").toString(); + }else + if(type.compareTo("email_from")==0){ + email_from=element.getProperty("email_from").toString(); + }else + if(type.compareTo("protocol")==0){ + protocol=element.getProperty("protocol").toString(); + }else + if(type.compareTo("options")==0){ + options=element.getProperty("options").toString(); + }else + if(type.compareTo("url")==0){ + url=element.getProperty("url").toString(); + }else + if(type.compareTo("sequence")==0){ + sequence=new BigInteger((byte[]) element.getProperty("sequence")); + } + + } + } + + endhost.setBody(body); + endhost.setDestination(destination); + endhost.setEmailFrom(email_from); + endhost.setOptions(options); + endhost.setSequence(sequence); + endhost.setUrl(url); + if(!protocol.isEmpty()) + endhost.setProtocol(ProtocolTypes.fromValue(protocol)); + c.setEndhost(endhost); + break; + } + + case "ENDPOINT":{ + Endpoint endpoint=new Endpoint(); + c.setEndpoint(endpoint); + break; + } + + case "FIELDMODIFIER":{ + + Fieldmodifier field=new Fieldmodifier(); + c.setFieldmodifier(field); + break; + } + case "MAILCLIENT":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Mailclient mailclient=new Mailclient(); + String mailserver= new String(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.Mailclient)){ + mailserver=element.getProperty("mailserver").toString(); + } + } + mailclient.setMailserver(mailserver); + c.setMailclient(mailclient); + break; + } + + case "MAILSERVER":{ + + Mailserver mailserver=new Mailserver(); + c.setMailserver(mailserver); + break; + } + + case "NAT":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Nat nat=new Nat(); + List<String> list=new ArrayList<String>(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.NAT)){ + String s=element.getProperty("source").toString(); + list.add(s); + } + } + nat.getSource().addAll(list); + c.setNat(nat); + break; + } + + case "VPNACCESS":{ + + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Vpnaccess vpnaccess=new Vpnaccess(); + String vpnexit= new String(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.VPNAccess)){ + vpnexit=element.getProperty("vpnexit").toString(); + } + } + vpnaccess.setVpnexit(vpnexit); + c.setVpnaccess(vpnaccess); + break; + } + + case "VPNEXIT":{ + + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Vpnexit vpnexit=new Vpnexit(); + String vpnaccess= new String(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.VPNExit)){ + vpnaccess=element.getProperty("vpnaccess").toString(); + } + } + vpnexit.setVpnaccess(vpnaccess); + c.setVpnexit(vpnexit); + break; + } + + case "WEBCLIENT":{ + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + Webclient webclient=new Webclient(); + String webserver= new String(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + if(element.hasLabel(NodeType.Webclient)){ + webserver=element.getProperty("webserver").toString(); + } + } + webclient.setNameWebServer(webserver); + c.setWebclient(webclient); + break; + } + + case "WEBSERVER":{ + + Webserver webserver=new Webserver(); + c.setWebserver(webserver); + break; + } + + + + + } + + } + } + + }else{ + vlogger.logger.info("Not valid functional type"); + + } + return c; + } + + public void deleteGraph(long id) throws MyNotFoundException{ + Node graph; + Transaction tx = graphDB.beginTx(); + + try{ + graph = findGraph(id); + for(Relationship rel: graph.getRelationships(RelationType.OwnerRelationship)){ + Node[] nodes = rel.getNodes(); + if(nodes[0].hasLabel(NodeType.Node)) + deleteNode(nodes[0]); + else + deleteNode(nodes[1]); + } + deleteNode(graph); + tx.success(); + } + finally{ + tx.close(); + } + } + + private void deleteNode(Node n) + { + n.getAllProperties().clear(); + + deleteConfiguration(n); + + for (Relationship r : n.getRelationships()) + { + r.getAllProperties().clear(); + r.delete(); + } + + n.delete(); + } + + private void deleteConfiguration(Node n) { + //delete configuration + Relationship rel = n.getSingleRelationship(RelationType.ConfigurationRelantionship, Direction.BOTH); + if(rel != null){ + Node conf=rel.getStartNode(); + Iterable<Relationship> confs= conf.getRelationships(RelationType.ElementRelationship); + Iterator<Relationship> confsIt = confs.iterator(); + while(confsIt.hasNext()){ + Relationship relConf = confsIt.next(); + Node element = relConf.getStartNode(); + element.getAllProperties().clear(); + relConf.getAllProperties().clear(); + relConf.delete(); + element.delete(); + } + conf.getAllProperties().clear(); + conf.delete(); + rel.getAllProperties().clear(); + rel.delete(); + } + + } + + public void deleteNode(long graphId, long nodeId) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + if(nodo==null){ + tx.failure(); + throw new MyNotFoundException("There is no Node whose id is '" + nodeId+"'"); + } + + + deleteNode(nodo); + tx.success(); + } + finally{ + tx.close(); + } + } + + public it.polito.neo4j.jaxb.Node getNode(long graphId, String nodeName) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + nodo = findNodeByNameOfSpecificGraph(nodeName, graphId); + if(nodo==null) + return null; + + else{ + tx.success(); + return retrieveNode(nodo); + } + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + } + + public it.polito.neo4j.jaxb.Node getNode(long graphId, long nodeId) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + tx.success(); + return retrieveNode(nodo); + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + } + public Set<it.polito.neo4j.jaxb.Node> getNodes(long graphId) throws MyNotFoundException{ + Node graph; + Transaction tx = graphDB.beginTx(); + Set<it.polito.neo4j.jaxb.Node> set = new HashSet<>(); + + try{ + graph = findGraph(graphId); + for(Relationship rel : graph.getRelationships(RelationType.OwnerRelationship)){ + Node[] nodes = rel.getNodes(); + it.polito.neo4j.jaxb.Node nodeAdded=null; + for(Label l: nodes[0].getLabels()){ + if(l.name().compareTo(NodeType.Nffg.name())==0){ + nodeAdded = retrieveNode(nodes[1]); + }else{ + nodeAdded = retrieveNode(nodes[0]); + } + } + set.add(nodeAdded); + } + tx.success(); + } + finally{ + tx.close(); + } + return set; + } + + public Neighbour createNeighbour(Neighbour neighbour, long graphId, long nodeId) throws MyNotFoundException{ + Node nodosrc,nododst; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + nodosrc=findNode(nodeId); + nododst = findNodeByNameOfSpecificGraph(neighbour.getName(), graphId); + if(nododst == null){ + tx.failure(); + throw new MyNotFoundException("There is no Node whose name is '" + neighbour.getName() + "'"); + } + Relationship rel = nodosrc.createRelationshipTo(nododst,RelationType.PathRelationship); + rel.setProperty("id", neighbour.getId()); + tx.success(); + } + finally{ + tx.close(); + } + return neighbour; + } + + public Set<Neighbour> getNeighbours(long graphId, long nodeId) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + Set<Neighbour> set = new HashSet<>(); + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + for(Relationship rel : nodo.getRelationships(Direction.OUTGOING,RelationType.PathRelationship)){ + Neighbour newNeigh = obFactory.createNeighbour(); + Node endpoint = rel.getEndNode(); + newNeigh.setName((String)endpoint.getProperty("name")); + newNeigh.setId((long)rel.getProperty("id")); + set.add(newNeigh); + } + tx.success(); + return set; + } + finally{ + tx.close(); + } + } + + public Neighbour getNeighbour(long graphId, long nodeId, long neighbourId) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + Neighbour newNeigh = obFactory.createNeighbour(); + + try{ + findGraph(graphId); + nodo = findNeighbourNode(nodeId); + if(nodo!=null){ + for(Relationship rel : nodo.getRelationships(Direction.OUTGOING, RelationType.PathRelationship)){ + if((long)rel.getProperty("id") == neighbourId){ + Node endpoint = rel.getEndNode(); + newNeigh.setName((String)endpoint.getProperty("name")); + newNeigh.setId((long)rel.getProperty("id")); + tx.success(); + tx.close(); + return newNeigh; + } + } + } + //if we arrive at this point it means there is not neighbour ad id neghbourId + tx.failure(); + return null; + } + finally{ + tx.close(); + } + } + + private Node findNeighbourNode(long nodeId) throws MyNotFoundException { + Node node; + + try{ + node=graphDB.findNode(NodeType.Node, "id",nodeId); + + } + catch(NotFoundException e){ + throw new MyNotFoundException("There is no Node whose Id is '" + nodeId + "'"); + } + + return node; + } + + public void deleteNeighbour(long graphId, long nodeId, long neighbourId) throws MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + boolean trovato=false; + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + for(Relationship rel : nodo.getRelationships(Direction.OUTGOING, RelationType.PathRelationship)){ + if((long)rel.getProperty("id") == neighbourId){ + rel.delete(); + trovato=true; + break; + } + } + if(!trovato){ + tx.close(); + throw new MyNotFoundException("There is no Neighbour whose Id is '" + neighbourId + "'"); + } + tx.success(); + } + finally{ + tx.close(); + } + } + + public it.polito.neo4j.jaxb.Node updateNode(it.polito.neo4j.jaxb.Node node, long graphId, long nodeId) throws MyInvalidObjectException,MyNotFoundException, MyInvalidIdException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + it.polito.neo4j.jaxb.Node returnedNode; + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + if(validNode(node,getGraph(graphId)) == false) + throw new MyInvalidObjectException("Invalid node"); + nodo.setProperty("name", node.getName()); + nodo.setProperty("functionalType", node.getFunctionalType().value()); + for(Neighbour neigh : node.getNeighbour()){ + Neighbour n = updateNeighbour(nodo, neigh, graphId); + neigh.setId(n.getId()); + } + + deleteConfiguration(nodo); + createConfiguration(nodo, node.getConfiguration()); + returnedNode = retrieveNode(nodo); + tx.success(); + } + finally{ + tx.close(); + } + return returnedNode; + } + + private boolean validNode(it.polito.neo4j.jaxb.Node node, Graph graph) { + int cntNeighbour = 0; + for(it.polito.neo4j.jaxb.Node n : graph.getNode()){ + if(node.getId().longValue() != n.getId().longValue() && node.getName().compareTo(n.getName()) == 0) + return false; + if(node.getId() != n.getId()){ + for(Neighbour neigh : node.getNeighbour()){ + if(neigh.getName().compareTo(n.getName()) == 0) + cntNeighbour++; + } + } + else{ + for(Neighbour neigh : node.getNeighbour()){ + if(neigh.getName().compareTo(node.getName()) == 0) + return false; + } + } + } + if(cntNeighbour == node.getNeighbour().size()) + return true; + else + return false; + } + + private Neighbour updateNeighbour(Node nodo, Neighbour neigh, long graphId){ + Node dst = findNodeByNameOfSpecificGraph(neigh.getName(), graphId); + + try{ + boolean trovato = false; + Iterable<Relationship> rels = nodo.getRelationships(Direction.OUTGOING, RelationType.PathRelationship); + Iterator<Relationship> relIt = rels.iterator(); + if(neigh.getId() != null){ + while(relIt.hasNext()){ + Relationship r = relIt.next(); + if((long)r.getProperty("id") == neigh.getId()){ + trovato = true; + break; + } + } + } + if(!trovato) + throw new NotFoundException(); + //graphDB.getRelationshipById(neigh.getId()); + try { + changeNeighbour(nodo, neigh, neigh.getId(), graphId); + } catch (MyNotFoundException e) { + e.printStackTrace(); + } + return neigh; + } + catch(NotFoundException e){ + Relationship rel = nodo.createRelationshipTo(dst, RelationType.PathRelationship); + rel.setProperty("id", neigh.getId()); + } + + + return neigh; + } + + + + public Graph updateGraph(Graph graph, long graphId) throws MyNotFoundException,DuplicateNodeException,MyInvalidObjectException, MyInvalidIdException{ + Transaction tx = graphDB.beginTx(); + Node nodo; + Node graph_old; + + try{ + graph_old = findGraph(graphId); + for(Relationship rel: graph_old.getRelationships(RelationType.OwnerRelationship)){ + Node[] nodes = rel.getNodes(); + if(nodes[0].hasLabel(NodeType.Node)) + deleteNode(nodes[0]); + else + deleteNode(nodes[1]); + } + + for(it.polito.neo4j.jaxb.Node tmpnodo : graph.getNode()){ + Node newNode = createNode(graph_old, tmpnodo, graph); + tmpnodo.setId(newNode.getId()); + it.polito.neo4j.jaxb.Configuration c=tmpnodo.getConfiguration(); + Node newConf=createConfiguration(newNode, c); + c.setId(newConf.getId()); + + } + + //modify neighbours ids inserting ids relationship + + + for(it.polito.neo4j.jaxb.Node tmpnodo : graph.getNode()){ + Map<String, Neighbour> neighs = addNeighbours(tmpnodo, graph); + + for(Neighbour neig : tmpnodo.getNeighbour()){ + Neighbour n = neighs.get(neig.getName()); + neig.setId(n.getId()); + + } + + + } + + tx.success(); + } + finally{ + tx.close(); + } + return graph; + } + + + + private boolean ValidGraph(Graph graph) { + if (duplicateNodesInsideGraph(graph)) + return false; + for(it.polito.neo4j.jaxb.Node n :graph.getNode()){ + int cnt = 0; + for(Neighbour neig : n.getNeighbour()){ + if(neig.getName().compareTo(n.getName()) == 0) + return false; + for(it.polito.neo4j.jaxb.Node n2 : graph.getNode()){ + if(neig.getName().compareTo(n2.getName()) == 0){ + cnt++; + break; + } + } + } + if(cnt != n.getNeighbour().size()) + return false; + } + return true; + } + + private boolean duplicateNodesInsideGraph(Graph graph) { + for(it.polito.neo4j.jaxb.Node n :graph.getNode()){ + for(it.polito.neo4j.jaxb.Node n2 : graph.getNode()){ + if(n!=n2 && n.getName().compareTo(n2.getName()) == 0) + return true; + } + } + return false; + } + + + public it.polito.neo4j.jaxb.Node updateNeighbour(Neighbour neighbour, long graphId, long nodeId, long neighbourId) throws MyInvalidObjectException,MyNotFoundException{ + Node nodo; + Transaction tx = graphDB.beginTx(); + it.polito.neo4j.jaxb.Node returnedNode; + + try{ + findGraph(graphId); + nodo = findNode(nodeId); + if(validNeighbour(neighbour,getGraph(graphId),getNode(graphId, nodeId)) == false) + throw new MyInvalidObjectException("Invalid neighbour"); + changeNeighbour(nodo,neighbour,neighbourId,graphId); + returnedNode = retrieveNode(nodo); + tx.success(); + } + finally{ + tx.close(); + } + //return; + return returnedNode; + } + + private boolean validNeighbour(Neighbour neighbour, Graph graph, it.polito.neo4j.jaxb.Node node) { + if(neighbour.getName().compareTo(node.getName()) == 0) + return false; + for(it.polito.neo4j.jaxb.Node n : graph.getNode()){ + if(neighbour.getName().compareTo(n.getName()) == 0) + return true; + } + return false; + } + + private void changeNeighbour(Node nodo, Neighbour neigh, long neighbourId, long graphId) throws MyNotFoundException{ + boolean trovato = false; + Relationship rel = null; + Iterable<Relationship> rels = nodo.getRelationships(Direction.OUTGOING, RelationType.PathRelationship); + Iterator<Relationship> relIt = rels.iterator(); + while(relIt.hasNext()){ + Relationship r = relIt.next(); + if((long)r.getProperty("id") == neighbourId){ + trovato=true; + rel=r; + break; + } + } + if(!trovato) + throw new MyNotFoundException("There is no Relationship with id '" + neigh.getId() + "'"); + rel.delete(); + Node dst = findNodeByNameOfSpecificGraph(neigh.getName(), graphId); + if(dst == null) + throw new MyNotFoundException("There is no Node whose name is '" + neigh.getName() + "'"); + Relationship relationship = nodo.createRelationshipTo(dst, RelationType.PathRelationship); + + relationship.setProperty("id", neigh.getId()); + + } + + public it.polito.neo4j.jaxb.Paths findAllPathsBetweenTwoNodes(long graphId, String srcName, String dstName, String direction) throws MyNotFoundException{ + Transaction tx = graphDB.beginTx(); + Set<String> pathPrinted = new HashSet<>(); + + try{ + findGraph(graphId); + Node src = findNodeByNameOfSpecificGraph(srcName, graphId); + Node dst = findNodeByNameOfSpecificGraph(dstName, graphId); + if(src == null ){ + tx.failure(); + throw new DataNotFoundException("Source node "+src+" not exists"); + }else + if(dst == null){ + tx.failure(); + throw new DataNotFoundException("Destination node "+dst+" not exists"); + } + PathFinder<Path> finder = GraphAlgoFactory.allSimplePaths(PathExpanders.forTypeAndDirection(RelationType.PathRelationship, Direction.valueOf(direction.toUpperCase())), MAX_DEPTH); + + for (Path p : finder.findAllPaths(src, dst)) + { + + pathPrinted.add(Paths.simplePathToString(p, "name")); + } + } + finally{ + tx.close(); + } + + it.polito.neo4j.jaxb.Paths paths = obFactory.createPaths(); + paths.setSource(srcName); + paths.setDestination(dstName); + paths.setDirection(direction); + if(pathPrinted.isEmpty()) + paths.setMessage("No available paths"); + else + paths.getPath().addAll(pathPrinted); + return paths; + } + + public it.polito.neo4j.jaxb.Node getNodeByName(String name, long graphId) throws MyNotFoundException { + Node nodo; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + + nodo = findNodeByNameOfSpecificGraph(name, graphId); + tx.success(); + if(nodo!=null) + return retrieveNode(nodo); + else + return null; + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + } + + public it.polito.neo4j.jaxb.Node getNodeById(long nodeId, long graphId) throws MyNotFoundException { + Node nodo; + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + + nodo = findNodeByIdAndSpecificGraph(nodeId, graphId); + tx.success(); + if(nodo==null){ + return null; + }else + return retrieveNode(nodo); + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + } + + public void checkGraph(long graphId) throws MyNotFoundException { + + Transaction tx = graphDB.beginTx(); + + try{ + findGraph(graphId); + + + tx.success(); + + } + catch(MyNotFoundException e){ + tx.close(); + throw new MyNotFoundException(e.getMessage()); + } + finally{ + tx.close(); + } + + } + + public it.polito.neo4j.jaxb.Configuration updateConfiguration(long nodeId, long graphId, it.polito.neo4j.jaxb.Configuration nodeConfiguration) throws MyNotFoundException, MyInvalidIdException { + Node nodo; + Transaction tx = graphDB.beginTx(); + it.polito.neo4j.jaxb.Configuration returnedConf; + + try{ + findGraph(graphId); + nodo=findNode(nodeId); + deleteConfiguration(nodo); + createConfiguration(nodo, nodeConfiguration); + returnedConf = retrieveconfiguration(nodo); + tx.success(); + } + finally{ + tx.close(); + } + return returnedConf; + } + + +}
\ No newline at end of file diff --git a/verigraph/src/it/polito/neo4j/translator/GraphToNeo4j.java b/verigraph/src/it/polito/neo4j/translator/GraphToNeo4j.java new file mode 100644 index 0000000..8641cbc --- /dev/null +++ b/verigraph/src/it/polito/neo4j/translator/GraphToNeo4j.java @@ -0,0 +1,614 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.translator; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI; + +import java.io.File; +import java.io.IOException; +import java.io.StringWriter; +import java.math.BigInteger; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedList; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBElement; +import javax.xml.bind.JAXBException; +import javax.xml.bind.Marshaller; +import javax.xml.bind.UnmarshalException; +import javax.xml.bind.Unmarshaller; +import javax.xml.bind.ValidationEvent; +import javax.xml.bind.ValidationEventHandler; +import javax.xml.bind.ValidationEventLocator; +import javax.xml.stream.FactoryConfigurationError; +import javax.xml.stream.XMLOutputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamWriter; +import javax.xml.validation.Schema; +import javax.xml.validation.SchemaFactory; + +import com.fasterxml.jackson.core.JsonFactory; +import com.fasterxml.jackson.core.JsonGenerationException; +import com.fasterxml.jackson.core.JsonParseException; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.fasterxml.jackson.databind.util.JSONWrappedObject; + +import it.polito.neo4j.jaxb.Antispam; +import it.polito.neo4j.jaxb.Cache; +import it.polito.neo4j.jaxb.Dpi; +import it.polito.neo4j.jaxb.Elements; +import it.polito.neo4j.jaxb.Endhost; +import it.polito.neo4j.jaxb.Endpoint; +import it.polito.neo4j.jaxb.Fieldmodifier; +import it.polito.neo4j.jaxb.Firewall; +import it.polito.neo4j.jaxb.FunctionalTypes; +import it.polito.neo4j.jaxb.Graph; +import it.polito.neo4j.jaxb.Node; +import it.polito.neo4j.jaxb.ObjectFactory; +import it.polito.neo4j.jaxb.ProtocolTypes; +import it.polito.neo4j.jaxb.Vpnaccess; +import it.polito.neo4j.jaxb.Vpnexit; +import it.polito.neo4j.jaxb.Webclient; +import it.polito.neo4j.jaxb.Webserver; +import it.polito.verigraph.model.Configuration; +import it.polito.verigraph.service.VerigraphLogger; +import it.polito.neo4j.jaxb.Graphs; +import it.polito.neo4j.jaxb.Mailclient; +import it.polito.neo4j.jaxb.Mailserver; +import it.polito.neo4j.jaxb.Nat; +import it.polito.neo4j.jaxb.Neighbour; + +public class GraphToNeo4j { + public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger(); + public static it.polito.neo4j.jaxb.Graph generateObject(it.polito.verigraph.model.Graph gr) throws JsonParseException, JsonMappingException, IOException { + it.polito.neo4j.jaxb.Graph graph; + graph=(new ObjectFactory()).createGraph(); + graph.setId(gr.getId()); + + List<it.polito.neo4j.jaxb.Node> nodes=new ArrayList<it.polito.neo4j.jaxb.Node>(); + for(Map.Entry<Long, it.polito.verigraph.model.Node> c : gr.getNodes().entrySet()){ + it.polito.neo4j.jaxb.Node node=(new ObjectFactory()).createNode(); + node.setId(c.getValue().getId()); + node.setName(c.getValue().getName()); + node.setFunctionalType(FunctionalTypes.fromValue(c.getValue().getFunctional_type().toUpperCase())); + List<Neighbour> neighbours=new ArrayList<Neighbour>(); + + /* setNeighbours*/ + for(Map.Entry<Long, it.polito.verigraph.model.Neighbour> a : c.getValue().getNeighbours().entrySet()){ + Neighbour neighbour=(new ObjectFactory()).createNeighbour(); + neighbour.setId(a.getValue().getId()); + neighbour.setName(a.getValue().getName()); + neighbours.add(neighbour); + } + node.getNeighbour().addAll(neighbours); + + /* setConfigurations */ + it.polito.neo4j.jaxb.Configuration configuration=(new ObjectFactory()).createConfiguration(); + JsonNode json=c.getValue().getConfiguration().getConfiguration(); + setConfiguration(configuration, c.getValue(), json); + node.setConfiguration(configuration); + nodes.add(node); + } + graph.getNode().addAll(nodes); + return graph; + } + + public static it.polito.neo4j.jaxb.Configuration ConfToNeo4j(it.polito.verigraph.model.Configuration nodeConfiguration, it.polito.verigraph.model.Node node) throws JsonParseException, JsonMappingException, IOException { + it.polito.neo4j.jaxb.Configuration configuration=(new ObjectFactory()).createConfiguration(); + JsonNode nodes=nodeConfiguration.getConfiguration(); + setConfiguration(configuration, node, nodes); + + return configuration; + + } + + @SuppressWarnings("unchecked") + private static void setConfiguration(it.polito.neo4j.jaxb.Configuration configuration, it.polito.verigraph.model.Node node, JsonNode nodes) throws JsonParseException, JsonMappingException, IOException { + + String empty="[]"; + + switch(node.getFunctional_type().toUpperCase()){ + case "FIREWALL":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Firewall firewall=new Firewall(); + List<Elements> elements_list=new ArrayList<Elements>(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}"); + List<String> list = new ArrayList<String>(); + Matcher match= pattern.matcher(input); + while (match.find()) { + list.add(match.group()); + } + + try{ + for(String string : list){ + map.putAll(mapper.readValue(string, LinkedHashMap.class)); + } + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + Elements e=new Elements(); + e.setDestination(m.getKey()); + e.setSource(m.getValue()); + elements_list.add(e); + } + + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + else{ + vlogger.logger.info("elements_list of Firewall " +node.getName()+" empty"); + } + firewall.getElements().addAll(elements_list); + configuration.setFirewall(firewall); + break; + } + case "ANTISPAM":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Antispam antispam=new Antispam(); + List<String> source=new ArrayList<String>(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + List<String> list=new ArrayList<String>(); + + try { + + list = mapper.readValue(nodes.toString(), ArrayList.class); + + for(String s : list){ + source.add(s); + } + + } catch (JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + else{ + vlogger.logger.info("Antispam " +node.getName()+" empty"); + + } + antispam.getSource().addAll(source); + configuration.setAntispam(antispam); + break; + } + case "CACHE":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Cache cache=new Cache(); + List<String> resource=new ArrayList<String>(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + + List<String> list=new ArrayList<String>(); + try { + + list = mapper.readValue(nodes.toString(), ArrayList.class); + + for(String s : list){ + resource.add(s); + } + + } catch (JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + else{ + vlogger.logger.info("Cache " +node.getName()+" empty"); + + } + cache.getResource().addAll(resource); + configuration.setCache(cache); + break; + + } + case "DPI":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Dpi dpi=new Dpi(); + List<String> notAllowed=new ArrayList<String>(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + + List<String> list=new ArrayList<String>(); + try { + + list = mapper.readValue(nodes.toString(), ArrayList.class); + + for(String s : list){ + notAllowed.add(s); + } + + } catch (JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + + } + else{ + vlogger.logger.info("Dpi " +node.getName()+" empty"); + + } + dpi.getNotAllowed().addAll(notAllowed); + configuration.setDpi(dpi); + break; + } + case "ENDHOST":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Endhost endhost=new Endhost(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + + try{ + map=mapper.readValue(input, java.util.LinkedHashMap.class); + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + switch(m.getKey()){ + case "body":{ + endhost.setBody(m.getValue()); + break; + } + case"sequence":{ + endhost.setSequence(new BigInteger(m.getValue())); + break; + } + case "protocol":{ + endhost.setProtocol(ProtocolTypes.fromValue(m.getValue())); + break; + } + case "email_from":{ + endhost.setEmailFrom(m.getValue()); + break; + } + case "url":{ + endhost.setUrl(m.getValue()); + break; + } + case "option":{ + endhost.setOptions(m.getValue()); + break; + } + case "destination":{ + endhost.setDestination(m.getValue()); + break; + } + } + } + + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + else{ + vlogger.logger.info("Endhost " +node.getName()+" empty"); + + } + configuration.setEndhost(endhost); + break; + } + case "ENDPOINT":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Endpoint endpoint=new Endpoint(); + configuration.setEndpoint(endpoint); + break; + } + case "FIELDMODIFIER":{ + + configuration.setName(node.getFunctional_type()); + Fieldmodifier fieldmodifier=new Fieldmodifier(); + configuration.setFieldmodifier(fieldmodifier); + break; + } + + case "MAILCLIENT":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Mailclient mailclient=new Mailclient(); + + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + + Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}"); + List<String> list = new ArrayList<String>(); + Matcher match= pattern.matcher(input); + while (match.find()) { + list.add(match.group()); + } + + try{ + for(String string : list){ + map.putAll(mapper.readValue(string, LinkedHashMap.class)); + if(map!=null || !map.isEmpty()){ + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + switch(m.getKey()){ + case "mailserver":{ + mailclient.setMailserver(m.getValue()); + break; + } + default: + vlogger.logger.info("\"mailserver\" object is required"); + break; + } + } + } + } + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + configuration.setMailclient(mailclient); + break; + } + case "MAILSERVER":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Mailserver mailserver=new Mailserver(); + configuration.setMailserver(mailserver); + break; + } + case "NAT":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Nat nat=new Nat(); + List<String> source=new ArrayList<String>(); + + if(!nodes.toString().equals(empty)){ + ObjectMapper mapper=new ObjectMapper(); + List<String> list=new ArrayList<String>(); + try { + + list = mapper.readValue(nodes.toString(), ArrayList.class); + + for(String s : list){ + source.add(s); + } + } catch (JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + } + else{ + vlogger.logger.info("Nat " +node.getName()+" empty"); + } + nat.getSource().addAll(source); + configuration.setNat(nat); + break; + } + case "VPNACCESS":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Vpnaccess vpnaccess=new Vpnaccess(); + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + + Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}"); + List<String> list = new ArrayList<String>(); + Matcher match= pattern.matcher(input); + while (match.find()) { + list.add(match.group()); + } + try{ + for(String string : list){ + map.putAll(mapper.readValue(string, LinkedHashMap.class)); + if(map!=null || !map.isEmpty()){ + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + switch(m.getKey()){ + case "vpnexit":{ + vpnaccess.setVpnexit(m.getValue()); + break; + } + default: + vlogger.logger.info("\"vpnexit\" is required"); + break; + } + } + } + } + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + configuration.setVpnaccess(vpnaccess); + break; + } + case "VPNEXIT":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Vpnexit vpnexit=new Vpnexit(); + + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + + Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}"); + List<String> list = new ArrayList<String>(); + Matcher match= pattern.matcher(input); + while (match.find()) { + list.add(match.group()); + } + + try{ + for(String string : list){ + /* there is only 1 string */ + map.putAll(mapper.readValue(string, LinkedHashMap.class)); + if(map!=null || !map.isEmpty()){ + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + switch(m.getKey()){ + case "vpnaccess":{ + vpnexit.setVpnaccess(m.getValue()); + break; + } + default:{ + vlogger.logger.info("\"vpnaccess\" is required"); + break; + } + } + } + } + } + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + configuration.setVpnexit(vpnexit); + break; + } + case "WEBCLIENT":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Webclient webclient=new Webclient(); + ObjectMapper mapper=new ObjectMapper(); + java.util.Map<String, String> map=new LinkedHashMap(); + String input; + Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(nodes.toString()); + if(matcher.find()){ + input=matcher.group(1); + }else + input=nodes.toString(); + + Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}"); + List<String> list = new ArrayList<String>(); + Matcher match= pattern.matcher(input); + while (match.find()) { + list.add(match.group()); + } + try{ + for(String string : list){ + map.putAll(mapper.readValue(string, LinkedHashMap.class)); + if(map!=null || !map.isEmpty()){ + for(java.util.Map.Entry<String, String> m : map.entrySet()){ + switch(m.getKey()){ + case "webserver":{ + webclient.setNameWebServer(m.getValue()); + break; + } + default:{ + vlogger.logger.info("\"webserver\" object is required"); + break; + } + } + } + } + } + }catch(JsonGenerationException e) { + e.printStackTrace(); + } catch (JsonMappingException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } + configuration.setWebclient(webclient); + break; + } + case "WEBSERVER":{ + configuration.setName(node.getFunctional_type().toLowerCase()); + Webserver webserver=new Webserver(); + configuration.setWebserver(webserver); + break; + } + } + } + + public static Neighbour NeighbourToNeo4j(it.polito.verigraph.model.Neighbour n){ + Neighbour neighbourRoot; + neighbourRoot=(new ObjectFactory()).createNeighbour(); + neighbourRoot.setId(n.getId()); + neighbourRoot.setName(n.getName()); + return neighbourRoot; + } + + public static Node NodeToNeo4j(it.polito.verigraph.model.Node n) throws JsonParseException, JsonMappingException, IOException{ + Node nodeRoot; + it.polito.neo4j.jaxb.Configuration configuration=(new ObjectFactory()).createConfiguration(); + nodeRoot=(new ObjectFactory()).createNode(); + nodeRoot.setId(n.getId()); + nodeRoot.setName(n.getName()); + nodeRoot.setFunctionalType(FunctionalTypes.fromValue(n.getFunctional_type().toUpperCase())); + for(Map.Entry<Long, it.polito.verigraph.model.Neighbour> neighbour : n.getNeighbours().entrySet()){ + it.polito.verigraph.model.Neighbour neighb=neighbour.getValue(); + nodeRoot.getNeighbour().add(NeighbourToNeo4j(neighb)); + } + JsonNode json=n.getConfiguration().getConfiguration(); + setConfiguration(configuration, n, json); + nodeRoot.setConfiguration(configuration); + return nodeRoot; + } +}
\ No newline at end of file diff --git a/verigraph/src/it/polito/neo4j/translator/Neo4jToGraph.java b/verigraph/src/it/polito/neo4j/translator/Neo4jToGraph.java new file mode 100644 index 0000000..36a30e4 --- /dev/null +++ b/verigraph/src/it/polito/neo4j/translator/Neo4jToGraph.java @@ -0,0 +1,354 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ +package it.polito.neo4j.translator; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; + +import it.polito.neo4j.jaxb.Elements; +import it.polito.verigraph.model.Configuration; +import it.polito.verigraph.model.Node; + +public class Neo4jToGraph { + public static it.polito.verigraph.model.Graph generateGraph(it.polito.neo4j.jaxb.Graph g) throws JsonProcessingException{ + + it.polito.verigraph.model.Graph graph=new it.polito.verigraph.model.Graph(); + graph.setId(g.getId()); + Map<Long, it.polito.verigraph.model.Node> nodes=new HashMap<Long, it.polito.verigraph.model.Node>(); + for(it.polito.neo4j.jaxb.Node n : g.getNode()){ + it.polito.verigraph.model.Node node=new it.polito.verigraph.model.Node(); + node.setId(n.getId()); + node.setName(n.getName()); + node.setFunctional_type(n.getFunctionalType().toString().toLowerCase()); + Map<Long, it.polito.verigraph.model.Neighbour> neighbours=new HashMap<Long, it.polito.verigraph.model.Neighbour>(); + List<it.polito.neo4j.jaxb.Neighbour> list=n.getNeighbour(); + for(it.polito.neo4j.jaxb.Neighbour neigh : list){ + it.polito.verigraph.model.Neighbour ngraph=new it.polito.verigraph.model.Neighbour(); + ngraph.setId(neigh.getId()); + ngraph.setName(neigh.getName()); + neighbours.put(ngraph.getId(), ngraph); + } + node.setNeighbours(neighbours); + + it.polito.verigraph.model.Configuration conf=new it.polito.verigraph.model.Configuration(); + //setConfiguration(n.getConfiguration(), conf); + node.setConfiguration(setConfiguration(n.getConfiguration(), conf)); + nodes.put(node.getId(), node); + } + graph.setNodes(nodes); + return graph; + } + + public static Map<Long, it.polito.verigraph.model.Node> NodesToVerigraph(Set<it.polito.neo4j.jaxb.Node> set) throws JsonProcessingException{ + + Map<Long, it.polito.verigraph.model.Node> nodes=new HashMap<Long, it.polito.verigraph.model.Node>(); + for(it.polito.neo4j.jaxb.Node n : set){ + it.polito.verigraph.model.Node node=new it.polito.verigraph.model.Node(); + node.setId(n.getId()); + node.setName(n.getName()); + node.setFunctional_type(n.getFunctionalType().toString().toLowerCase()); + Map<Long, it.polito.verigraph.model.Neighbour> neighbours=new HashMap<Long, it.polito.verigraph.model.Neighbour>(); + for(it.polito.neo4j.jaxb.Neighbour neigh : n.getNeighbour()){ + it.polito.verigraph.model.Neighbour ngraph=new it.polito.verigraph.model.Neighbour(); + ngraph.setId(neigh.getId()); + ngraph.setName(neigh.getName()); + neighbours.put(ngraph.getId(), ngraph); + } + node.setNeighbours(neighbours); + it.polito.verigraph.model.Configuration conf=new it.polito.verigraph.model.Configuration(); + //setConfiguration(n.getConfiguration(), conf); + node.setConfiguration(setConfiguration(n.getConfiguration(), conf)); + nodes.put(node.getId(), node); + } + + return nodes; + } + + private static Configuration setConfiguration(it.polito.neo4j.jaxb.Configuration configuration, Configuration conf) throws JsonProcessingException { + + conf.setId(configuration.getId().toString()); + if(configuration.getDescription()!=null) + conf.setDescription(configuration.getDescription()); + switch(configuration.getName().toUpperCase()){ + case "FIREWALL":{ + ObjectMapper mapper=new ObjectMapper(); + JsonNode root=mapper.createObjectNode(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getFirewall().getElements()!=null){ + for(Elements e : configuration.getFirewall().getElements()){ + JsonNode element=mapper.createObjectNode(); + ((ObjectNode)element).put(e.getDestination(), e.getSource()); + child.add(element); + } + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "ANTISPAM":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getAntispam().getSource()!=null){ + for(String e : configuration.getAntispam().getSource()){ + child.add(e); + } + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "CACHE":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getCache().getResource()!=null){ + for(String e : configuration.getCache().getResource()){ + child.add(e); + } + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + + case "DPI":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + + if(configuration.getDpi().getNotAllowed()!=null){ + for(String e : configuration.getDpi().getNotAllowed()){ + child.add(e); + } + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + + case "ENDHOST":{ + + ObjectMapper mapper=new ObjectMapper(); + JsonNode root=mapper.createObjectNode(); + ArrayNode child=mapper.createArrayNode(); + + Map<String, String> map=new HashMap<String, String>(); + + if(configuration.getEndhost().getBody()!=null) + map.put("body", configuration.getEndhost().getBody()); + + if(configuration.getEndhost().getDestination()!=null) + map.put("destination", configuration.getEndhost().getDestination()); + + if(configuration.getEndhost().getEmailFrom()!=null) + map.put("email_from", configuration.getEndhost().getEmailFrom()); + + if(configuration.getEndhost().getOptions()!=null) + map.put("options", configuration.getEndhost().getOptions()); + + if(configuration.getEndhost().getUrl()!=null) + map.put("url", configuration.getEndhost().getUrl()); + + if(configuration.getEndhost().getProtocol()!=null) + map.put("protocol", configuration.getEndhost().getProtocol().toString()); + + + if((configuration.getEndhost().getSequence()) != null && !(configuration.getEndhost().getSequence()).equals(BigInteger.ZERO)) + map.put("sequence", new String(configuration.getEndhost().getSequence().toByteArray())); + + + JsonNode element=mapper.createObjectNode(); + if(!map.isEmpty()){ + for(Map.Entry<String, String> s : map.entrySet()){ + if((s.getKey()).compareTo("sequence")==0) + ((ObjectNode)element).put(s.getKey(), s.getValue()); + if(!(s.getValue().compareTo("")==0)) + ((ObjectNode)element).put(s.getKey(), s.getValue()); + + } + child.add(element); + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "ENDPOINT":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + + case "FIELDMODIFIER":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + conf.setConfiguration(child); + break; + } + case "MAILCLIENT":{ + Map<String, String> map=new HashMap<String, String>(); + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getMailclient().getMailserver()!=null){ + map.put("mailserver", configuration.getMailclient().getMailserver()); + JsonNode element=mapper.createObjectNode(); + for(Map.Entry<String, String> s : map.entrySet()){ + ((ObjectNode)element).put(s.getKey(), s.getValue()); + } + child.add(element); + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "MAILSERVER":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + conf.setConfiguration(child); + break; + } + case "NAT":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getNat().getSource()!=null){ + for(String e : configuration.getNat().getSource()){ + child.add(e); + } + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "VPNACCESS":{ + Map<String, String> map=new HashMap<String, String>(); + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getVpnaccess().getVpnexit()!=null){ + map.put("vpnexit", configuration.getVpnaccess().getVpnexit()); + JsonNode element=mapper.createObjectNode(); + for(Map.Entry<String, String> s : map.entrySet()){ + ((ObjectNode)element).put(s.getKey(), s.getValue()); + } + child.add(element); + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "VPNEXIT":{ + Map<String, String> map=new HashMap<String, String>(); + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getVpnexit().getVpnaccess()!=null){ + map.put("vpnaccess", configuration.getVpnexit().getVpnaccess()); + JsonNode element=mapper.createObjectNode(); + for(Map.Entry<String, String> s : map.entrySet()){ + ((ObjectNode)element).put(s.getKey(), s.getValue()); + } + child.add(element); + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "WEBCLIENT":{ + Map<String, String> map=new HashMap<String, String>(); + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + if(configuration.getWebclient().getNameWebServer()!=null){ + map.put("webserver", configuration.getWebclient().getNameWebServer()); + JsonNode element=mapper.createObjectNode(); + for(Map.Entry<String, String> s : map.entrySet()){ + ((ObjectNode)element).put(s.getKey(), s.getValue()); + } + child.add(element); + } + //((ObjectNode)root).set("configuration", child); + //conf.setConfiguration(root); + conf.setConfiguration(child); + break; + } + case "WEBSERVER":{ + ObjectMapper mapper=new ObjectMapper(); + ArrayNode child=mapper.createArrayNode(); + conf.setConfiguration(child); + break; + } + } + return conf; + + } + + public static it.polito.verigraph.model.Node NodeToVerigraph(it.polito.neo4j.jaxb.Node n) throws JsonProcessingException { + it.polito.verigraph.model.Node node=new it.polito.verigraph.model.Node(); + node.setId(n.getId()); + node.setName(n.getName()); + node.setFunctional_type(n.getFunctionalType().toString().toLowerCase()); + Map<Long, it.polito.verigraph.model.Neighbour> neighbours=new HashMap<Long, it.polito.verigraph.model.Neighbour>(); + for(it.polito.neo4j.jaxb.Neighbour neigh : n.getNeighbour()){ + it.polito.verigraph.model.Neighbour ngraph=new it.polito.verigraph.model.Neighbour(); + ngraph.setId(neigh.getId()); + ngraph.setName(neigh.getName()); + neighbours.put(ngraph.getId(), ngraph); + + } + node.setNeighbours(neighbours); + it.polito.verigraph.model.Configuration conf=new it.polito.verigraph.model.Configuration(); + //setConfiguration(n.getConfiguration(), conf); + node.setConfiguration(setConfiguration(n.getConfiguration(), conf)); + return node; + } + + public static it.polito.verigraph.model.Neighbour NeighbourToVerigraph(it.polito.neo4j.jaxb.Neighbour n) throws JsonProcessingException { + it.polito.verigraph.model.Neighbour ngraph=new it.polito.verigraph.model.Neighbour(); + ngraph.setId(n.getId()); + ngraph.setName(n.getName()); + return ngraph; + } + public static Map<Long, it.polito.verigraph.model.Neighbour> NeighboursToVerigraph(Set<it.polito.neo4j.jaxb.Neighbour> set) throws JsonProcessingException{ + + Map<Long, it.polito.verigraph.model.Neighbour> neighbours=new HashMap<Long, it.polito.verigraph.model.Neighbour>(); + for(it.polito.neo4j.jaxb.Neighbour n : set){ + it.polito.verigraph.model.Neighbour ngraph=new it.polito.verigraph.model.Neighbour(); + ngraph.setId(n.getId()); + ngraph.setName(n.getName()); + neighbours.put(n.getId(), ngraph); + } + return neighbours; + } + + public static it.polito.verigraph.model.Configuration ConfToVerigraph(it.polito.neo4j.jaxb.Configuration c) throws JsonProcessingException { + it.polito.verigraph.model.Configuration conf=new it.polito.verigraph.model.Configuration(); + //setConfiguration(n.getConfiguration(), conf); + setConfiguration(c, conf); + return conf; + } +}
\ No newline at end of file diff --git a/verigraph/src/it/polito/neo4j/translator/package-info.java b/verigraph/src/it/polito/neo4j/translator/package-info.java new file mode 100644 index 0000000..9776c0a --- /dev/null +++ b/verigraph/src/it/polito/neo4j/translator/package-info.java @@ -0,0 +1,11 @@ +/******************************************************************************* + * Copyright (c) 2017 Politecnico di Torino and others. + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Apache License, Version 2.0 + * which accompanies this distribution, and is available at + * http://www.apache.org/licenses/LICENSE-2.0 + *******************************************************************************/ + +@javax.xml.bind.annotation.XmlSchema(namespace = "http://www.example.org/verigraph/", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED) +package it.polito.neo4j.translator; |