summaryrefslogtreecommitdiffstats
path: root/verigraph/src/it
diff options
context:
space:
mode:
authorjulien zhang <zhang.jun3g@zte.com.cn>2017-09-12 14:47:37 +0000
committerGerrit Code Review <gerrit@opnfv.org>2017-09-12 14:47:37 +0000
commit8153ff1bac0ec3664c777302396698e4fb5f34b9 (patch)
tree2b97892774e3ced5f0c10e400657d28f9222749b /verigraph/src/it
parent96de9387460091e7cf0dc5fde1afaa637a8b2b79 (diff)
parenta42de79292d9541db7865b54e93be2d0b6e6a094 (diff)
Merge "update verigraph"
Diffstat (limited to 'verigraph/src/it')
-rw-r--r--verigraph/src/it/polito/neo4j/exceptions/DuplicateNodeException.java18
-rw-r--r--verigraph/src/it/polito/neo4j/exceptions/MyInvalidDirectionException.java19
-rw-r--r--verigraph/src/it/polito/neo4j/exceptions/MyInvalidIdException.java19
-rw-r--r--verigraph/src/it/polito/neo4j/exceptions/MyInvalidObjectException.java18
-rw-r--r--verigraph/src/it/polito/neo4j/exceptions/MyNotFoundException.java19
-rw-r--r--verigraph/src/it/polito/neo4j/manager/Neo4jDBInteraction.java56
-rw-r--r--verigraph/src/it/polito/neo4j/manager/Neo4jDBManager.java381
-rw-r--r--verigraph/src/it/polito/neo4j/manager/Neo4jLibrary.java1585
-rw-r--r--verigraph/src/it/polito/neo4j/translator/GraphToNeo4j.java614
-rw-r--r--verigraph/src/it/polito/neo4j/translator/Neo4jToGraph.java354
-rw-r--r--verigraph/src/it/polito/neo4j/translator/package-info.java11
-rw-r--r--verigraph/src/it/polito/verigraph/client/VerifyClient.java435
-rw-r--r--verigraph/src/it/polito/verigraph/client/VerifyClientException.java19
-rw-r--r--verigraph/src/it/polito/verigraph/deserializer/ConfigurationCustomDeserializer.java38
-rw-r--r--verigraph/src/it/polito/verigraph/deserializer/GraphCustomDeserializer.java86
-rw-r--r--verigraph/src/it/polito/verigraph/deserializer/NodeCustomDeserializer.java89
-rw-r--r--verigraph/src/it/polito/verigraph/deserializer/PathsMessageBodyReader.java51
-rw-r--r--verigraph/src/it/polito/verigraph/exception/BadRequestException.java19
-rw-r--r--verigraph/src/it/polito/verigraph/exception/BadRequestExceptionMapper.java29
-rw-r--r--verigraph/src/it/polito/verigraph/exception/DataNotFoundException.java19
-rw-r--r--verigraph/src/it/polito/verigraph/exception/DataNotFoundExceptionMapper.java29
-rw-r--r--verigraph/src/it/polito/verigraph/exception/ForbiddenException.java19
-rw-r--r--verigraph/src/it/polito/verigraph/exception/ForbiddenExceptionMapper.java29
-rw-r--r--verigraph/src/it/polito/verigraph/exception/GenericExceptionMapper.java28
-rw-r--r--verigraph/src/it/polito/verigraph/exception/InternalServerErrorException.java19
-rw-r--r--verigraph/src/it/polito/verigraph/exception/InternalServerErrorExceptionMapper.java29
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/client/Client.java559
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/server/GrpcUtils.java153
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/server/Service.java466
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/test/GrpcServerTest.java392
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/test/GrpcTest.java422
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java220
-rw-r--r--verigraph/src/it/polito/verigraph/grpc/test/ReachabilityTest.java274
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/Checker.java377
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/Core.java43
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/DataIsolationResult.java40
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/IsolationResult.java42
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/NetContext.java365
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/Network.java314
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/NetworkObject.java59
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/Result.java42
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/components/Tuple.java34
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/AclFirewall.java123
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/DumbNode.java40
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/EndHost.java98
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PacketModel.java69
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoAntispam.java120
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoCache.java177
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoEndHost.java100
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoErrFunction.java96
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoFieldModifier.java89
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoIDS.java139
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailClient.java104
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailServer.java116
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNF.java100
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNat.java173
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnAccess.java141
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnExit.java141
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebClient.java106
-rw-r--r--verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebServer.java112
-rw-r--r--verigraph/src/it/polito/verigraph/model/Configuration.java72
-rw-r--r--verigraph/src/it/polito/verigraph/model/Entry.java36
-rw-r--r--verigraph/src/it/polito/verigraph/model/ErrorMessage.java60
-rw-r--r--verigraph/src/it/polito/verigraph/model/Graph.java101
-rw-r--r--verigraph/src/it/polito/verigraph/model/Link.java70
-rw-r--r--verigraph/src/it/polito/verigraph/model/Neighbour.java69
-rw-r--r--verigraph/src/it/polito/verigraph/model/Node.java151
-rw-r--r--verigraph/src/it/polito/verigraph/model/Test.java61
-rw-r--r--verigraph/src/it/polito/verigraph/model/Verification.java67
-rw-r--r--verigraph/src/it/polito/verigraph/resources/GraphResource.java194
-rw-r--r--verigraph/src/it/polito/verigraph/resources/NeighbourResource.java146
-rw-r--r--verigraph/src/it/polito/verigraph/resources/NodeResource.java206
-rw-r--r--verigraph/src/it/polito/verigraph/resources/beans/VerificationBean.java65
-rw-r--r--verigraph/src/it/polito/verigraph/serializer/CustomConfigurationSerializer.java31
-rw-r--r--verigraph/src/it/polito/verigraph/serializer/CustomMapSerializer.java27
-rw-r--r--verigraph/src/it/polito/verigraph/service/GraphService.java82
-rw-r--r--verigraph/src/it/polito/verigraph/service/JsonValidationService.java132
-rw-r--r--verigraph/src/it/polito/verigraph/service/NeighbourService.java143
-rw-r--r--verigraph/src/it/polito/verigraph/service/NodeService.java223
-rw-r--r--verigraph/src/it/polito/verigraph/service/ValidationUtils.java131
-rw-r--r--verigraph/src/it/polito/verigraph/service/VerificationService.java625
-rw-r--r--verigraph/src/it/polito/verigraph/service/VerigraphLogger.java71
-rw-r--r--verigraph/src/it/polito/verigraph/solver/GeneratorSolver.java441
-rw-r--r--verigraph/src/it/polito/verigraph/solver/Scenario.java557
-rw-r--r--verigraph/src/it/polito/verigraph/test/MultiThreadedTestCase.java201
-rw-r--r--verigraph/src/it/polito/verigraph/test/Scalability.java413
-rw-r--r--verigraph/src/it/polito/verigraph/test/TestCase.java178
-rw-r--r--verigraph/src/it/polito/verigraph/test/TestExecutionException.java22
-rw-r--r--verigraph/src/it/polito/verigraph/test/Tester.java230
-rw-r--r--verigraph/src/it/polito/verigraph/validation/DpiValidator.java44
-rw-r--r--verigraph/src/it/polito/verigraph/validation/EndhostValidator.java23
-rw-r--r--verigraph/src/it/polito/verigraph/validation/ValidationInterface.java20
-rw-r--r--verigraph/src/it/polito/verigraph/validation/VpnaccessValidator.java49
-rw-r--r--verigraph/src/it/polito/verigraph/validation/VpnexitValidator.java49
-rw-r--r--verigraph/src/it/polito/verigraph/validation/exception/ValidationException.java29
95 files changed, 14897 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;
diff --git a/verigraph/src/it/polito/verigraph/client/VerifyClient.java b/verigraph/src/it/polito/verigraph/client/VerifyClient.java
new file mode 100644
index 0000000..751e7b6
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/client/VerifyClient.java
@@ -0,0 +1,435 @@
+/*******************************************************************************
+ * 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.verigraph.client;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.ResponseProcessingException;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import it.polito.verigraph.model.ErrorMessage;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.model.Verification;
+
+public class VerifyClient {
+
+ private WebTarget baseTarget;
+ private WebTarget graphsTarget;
+ private WebTarget graphTarget;
+ private WebTarget nodesTarget;
+ private WebTarget nodeTarget;
+ private WebTarget neighboursTarget;
+ private WebTarget neighbourTarget;
+ private WebTarget reachabilityTarget;
+ private WebTarget isolationTarget;
+ private WebTarget traversalTarget;
+
+ public VerifyClient(String address) {
+
+ Client client = ClientBuilder.newClient();
+ this.baseTarget = client.target(address);
+ this.graphsTarget = baseTarget.path("graphs");
+ this.graphTarget = graphsTarget.path("/{graphId}");
+ this.nodesTarget = graphTarget.path("/nodes");
+ this.nodeTarget = nodesTarget.path("//{nodeId}");
+ this.neighboursTarget = nodeTarget.path("/neighbours");
+ this.neighbourTarget = neighboursTarget.path("/{neighbourId}");
+ this.reachabilityTarget = graphTarget.path("/policy");
+ this.isolationTarget = graphTarget.path("/policy");
+ this.traversalTarget = graphTarget.path("/policy");
+ }
+
+ public void checkResponse(Response response) throws VerifyClientException {
+ int status = response.getStatus();
+
+ // 400
+ if (status == Response.Status.BAD_REQUEST.getStatusCode()) {
+ try {
+ // String responseString = response.readEntity(String.class);
+ // System.out.println(responseString);
+ ErrorMessage errorMessage = response.readEntity(ErrorMessage.class);
+ String message = errorMessage.getErrorMessage();
+ throw new VerifyClientException("Bad request: " + message);
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'ErrorMessage': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+ // 403
+ if (status == Response.Status.FORBIDDEN.getStatusCode()) {
+ try {
+ ErrorMessage errorMessage = response.readEntity(ErrorMessage.class);
+ String message = errorMessage.getErrorMessage();
+ throw new VerifyClientException("Forbidden: " + message);
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'ErrorMessage': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+ // 404
+ if (status == Response.Status.NOT_FOUND.getStatusCode()) {
+ try {
+ ErrorMessage errorMessage = response.readEntity(ErrorMessage.class);
+ String message = errorMessage.getErrorMessage();
+ throw new VerifyClientException("Not found: " + message);
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'ErrorMessage': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the 'Response' entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+ // 500
+ if (status == Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()) {
+ try {
+ ErrorMessage errorMessage = response.readEntity(ErrorMessage.class);
+ String message = errorMessage.getErrorMessage();
+ throw new VerifyClientException("Internal server error: " + message);
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'ErrorMessage': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+ if (status != Response.Status.ACCEPTED.getStatusCode() && status != Response.Status.CREATED.getStatusCode()
+ && status != Response.Status.NO_CONTENT.getStatusCode() && status != Response.Status.OK.getStatusCode())
+ throw new VerifyClientException("Unknown error");
+ }
+
+ public Response createGraph(Graph graph) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = graphsTarget.request().post(Entity.json(graph));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response createGraph(String graph) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = graphsTarget.request().post(Entity.entity(graph, "application/json"));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response retrieveGraph(long graphId) throws VerifyClientException, ProcessingException {
+ Response response = graphTarget.resolveTemplate("graphId", graphId).request().get();
+ checkResponse(response);
+ return response;
+ }
+
+ public Response updateGraph(long graphId, Graph graph) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = graphTarget.resolveTemplate("graphId", graphId).request().put(Entity.json(graph));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response deleteGraph(long graphId) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = graphTarget.resolveTemplate("graphId", graphId).request().delete();
+ checkResponse(response);
+ return response;
+ }
+
+ public Response createNode(long graphId, Node node) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = nodesTarget.resolveTemplate("graphId", graphId).request().post(Entity.json(node));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response retrieveNode(long graphId, long nodeId) throws VerifyClientException, ProcessingException {
+ Response response = nodeTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .request()
+ .get();
+ checkResponse(response);
+ return response;
+ }
+
+ public Response updateNode(long graphId, long nodeId, Node node) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = nodeTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .request()
+ .put(Entity.json(node));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response deleteNode(long graphId, long nodeId) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = nodeTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .request()
+ .delete();
+ checkResponse(response);
+ return response;
+ }
+
+ public Response createNeighbour(long graphId, long nodeId, Neighbour neighbour) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = neighboursTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .request()
+ .post(Entity.json(neighbour));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response retrieveNeighbour(long graphId, long nodeId, long neighbourId) throws VerifyClientException, ProcessingException {
+ Response response = neighbourTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .resolveTemplate("neighbourId", neighbourId)
+ .request()
+ .get();
+ checkResponse(response);
+ return response;
+ }
+
+ public Response updateNeighbour(long graphId, long nodeId, long neighbourId,
+ Neighbour neighbour) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = neighbourTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .resolveTemplate("neighbourId", neighbourId)
+ .request()
+ .put(Entity.json(neighbour));
+ checkResponse(response);
+ return response;
+ }
+
+ public Response deleteNeighbour(long graphId, long nodeId, long neighbourId) throws VerifyClientException, ResponseProcessingException, ProcessingException {
+ Response response = neighbourTarget.resolveTemplate("graphId", graphId)
+ .resolveTemplate("nodeId", nodeId)
+ .resolveTemplate("neighbourId", neighbourId)
+ .request()
+ .delete();
+ checkResponse(response);
+ return response;
+ }
+
+ public Verification getReachability(long graphId, String source, String destination) throws VerifyClientException, ProcessingException{
+ Response response = reachabilityTarget.resolveTemplate("graphId", graphId)
+ .queryParam("source", source)
+ .queryParam("destination", destination)
+ .queryParam("type", "reachability")
+ .request()
+ .get();
+ checkResponse(response);
+ try{
+ Verification verification = response.readEntity(Verification.class);
+ return verification;
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'Verification': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the 'Verification' entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+
+ public Verification getIsolation(long graphId, String source, String destination, String middlebox) throws VerifyClientException, ProcessingException{
+ Response response = isolationTarget.resolveTemplate("graphId", graphId)
+ .queryParam("source", source)
+ .queryParam("destination", destination)
+ .queryParam("middlebox", middlebox)
+ .queryParam("type", "isolation")
+ .request()
+ .get();
+ checkResponse(response);
+ try{
+ Verification verification = response.readEntity(Verification.class);
+ return verification;
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'Verification': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the 'Verification' entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+
+ public Verification getTraversal(long graphId, String source, String destination, String middlebox) throws VerifyClientException, ProcessingException{
+ Response response = traversalTarget.resolveTemplate("graphId", graphId)
+ .queryParam("source", source)
+ .queryParam("destination", destination)
+ .queryParam("middlebox", middlebox)
+ .queryParam("type", "traversal")
+ .request()
+ .get();
+ checkResponse(response);
+ try{
+ Verification verification = response.readEntity(Verification.class);
+ return verification;
+ }
+ catch (ProcessingException e) {
+ throw new VerifyClientException("the content of the message cannot be mapped to an entity of the 'Verification': "
+ + e.getMessage());
+ }
+ catch (IllegalStateException e) {
+ throw new VerifyClientException("the 'Verification' entity is not backed by an input stream or the original entity input stream has already been consumed without buffering the entity data prior consuming: "
+ + e.getMessage());
+ }
+ }
+
+ @SuppressWarnings("unused")
+ private static String deserializeString(File file) throws IOException {
+ int len;
+ char[] chr = new char[4096];
+ final StringBuffer buffer = new StringBuffer();
+ final FileReader reader = new FileReader(file);
+ try {
+ while ((len = reader.read(chr)) > 0) {
+ buffer.append(chr, 0, len);
+ }
+ }
+ finally {
+ reader.close();
+ }
+ return buffer.toString();
+ }
+
+ public List<File> getFiles() {
+ List<File> filesList = new ArrayList<File>();
+
+ String folderString = System.getProperty("folder");
+ File folder;
+ if (folderString == null)
+ folder = new File(System.getProperty("user.dir") + "/examples");
+ else
+ folder = new File(folderString);
+
+ System.out.println("Folder set to " + folder.getAbsolutePath());
+
+ File[] files = folder.listFiles(new FilenameFilter() {
+
+ @Override
+ public boolean accept(File dir, String name) {
+ return name.endsWith(".json");
+ }
+ });
+
+ for (File f : files) {
+ filesList.add(f);
+ }
+
+ return filesList;
+ }
+
+ public Graph addGraphFromFile(File file) throws JsonParseException, JsonMappingException, IOException, Exception {
+ System.out.println("Parsing graph of file '" + file.getAbsolutePath() + "'...");
+ Graph graph = new ObjectMapper().readValue(file, Graph.class);
+ Response createGraphResponse = createGraph(graph);
+ if (createGraphResponse.getStatus() != Status.CREATED.getStatusCode()) {
+ throw new Exception("Creation of graph contained in file '"+ file.getAbsolutePath() + "' returned status "
+ + createGraphResponse.getStatus());
+ }
+ String responseString = createGraphResponse.readEntity(String.class);
+ System.out.println("Response:");
+ System.out.println(responseString);
+ Graph response = new ObjectMapper().readValue(responseString, Graph.class);
+ printGraph(response);
+ return response;
+ }
+
+ public void printGraph(Graph graph) {
+ System.out.println("Graph " + graph.getId());
+ for (Node n : graph.getNodes().values()) {
+ System.out.println("\tNode " + n.getId());
+ System.out.println("\tName " + n.getName());
+ System.out.println("\tFunctional type: " + n.getFunctional_type());
+ for (Neighbour neighbour : n.getNeighbours().values()) {
+ System.out.println("\t\tNeighbour " + neighbour.getId());
+ System.out.println("\t\tName: " + neighbour.getName());
+ }
+ }
+ }
+
+ public Map<String, Graph> addGraphsFromFiles(List<File> files)throws JsonParseException, JsonMappingException, IOException,
+ Exception {
+ Map<String, Graph> graphs = new HashMap<String, Graph>();
+
+ for (File f : files) {
+ Graph graph = addGraphFromFile(f);
+ graphs.put(f.getName(), graph);
+ }
+
+ for (Map.Entry<String, Graph> graph : graphs.entrySet()) {
+ System.out.println(graph.getKey() + " -> graph " + graph.getValue().getId());
+ }
+ System.out.println("Graphs added");
+
+ return graphs;
+ }
+
+ public static void main(String[] args) throws IOException, Exception {
+ System.out.println("Adding graphs");
+
+ VerifyClient verifyClient = new VerifyClient("http://localhost:8080/verigraph/api");
+
+ List<File> files = verifyClient.getFiles();
+ Map<String, Graph> graphs = verifyClient.addGraphsFromFiles(files);
+
+ for (Graph g : graphs.values()) {
+ Response response = verifyClient.retrieveGraph(g.getId());
+ String responseString = response.readEntity(String.class);
+
+ System.out.println("Response");
+ System.out.println(responseString);
+ Graph graph = new ObjectMapper().readValue(responseString, Graph.class);
+ System.out.println("Read graph " + graph.getId());
+ System.out.println(response.getStatus());
+ }
+
+ Graph graph = graphs.get("budapest_sat.json");
+ System.out.println("graphId set to " + graph.getId());
+ System.out.println("Getting reachability from 'user1' to 'websever' in 'budapest' graph (expecting SAT)...");
+ Verification verification = verifyClient.getReachability(graph.getId(), "user1", "webserver");
+ System.out.println(verification.getResult());
+
+ graph = graphs.get("budapest_unsat.json");
+ System.out.println("graphId set to " + graph.getId());
+ System.out.println("Getting reachability from 'user1' to 'websever' in 'budapest' graph (expecting UNSAT)...");
+ verification = verifyClient.getReachability(graph.getId(), "user1", "webserver");
+ System.out.println(verification.getResult());
+
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/client/VerifyClientException.java b/verigraph/src/it/polito/verigraph/client/VerifyClientException.java
new file mode 100644
index 0000000..a0956f8
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/client/VerifyClientException.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.verigraph.client;
+
+public class VerifyClientException extends Exception{
+
+ private static final long serialVersionUID = 4794956747093682854L;
+
+ public VerifyClientException(String message){
+ super(message);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/deserializer/ConfigurationCustomDeserializer.java b/verigraph/src/it/polito/verigraph/deserializer/ConfigurationCustomDeserializer.java
new file mode 100644
index 0000000..e91a53b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/deserializer/ConfigurationCustomDeserializer.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * 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.verigraph.deserializer;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonNode;
+
+import it.polito.verigraph.exception.InternalServerErrorException;
+import it.polito.verigraph.model.Configuration;
+
+public class ConfigurationCustomDeserializer extends JsonDeserializer<Configuration> {
+
+ @Override
+ public Configuration deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException,
+ JsonProcessingException {
+ try {
+ JsonNode root = jp.getCodec().readTree(jp);
+ return new Configuration("", "", root);
+ }
+ catch (JsonProcessingException e) {
+ throw new InternalServerErrorException("Error parsing configuration: " + e.getMessage());
+ }
+ catch (IOException e) {
+ throw new InternalServerErrorException("I/O error parsing configuration: " + e.getMessage());
+ }
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/deserializer/GraphCustomDeserializer.java b/verigraph/src/it/polito/verigraph/deserializer/GraphCustomDeserializer.java
new file mode 100644
index 0000000..19245c2
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/deserializer/GraphCustomDeserializer.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * 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.verigraph.deserializer;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.InternalServerErrorException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+
+
+/**
+ * The Class GraphCustomDeserializer is a custom deserializer for a Graph object
+ */
+public class GraphCustomDeserializer extends JsonDeserializer<Graph>{
+
+ /* (non-Javadoc)
+ * @see com.fasterxml.jackson.databind.JsonDeserializer#deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
+ */
+ @Override
+ public Graph deserialize(JsonParser jp, DeserializationContext context){
+ JsonNode root = null;
+ try {
+ root = jp.getCodec().readTree(jp);
+ }
+ catch (JsonProcessingException e) {
+ throw new InternalServerErrorException("Error parsing a graph: " + e.getMessage());
+ }
+ catch (IOException e) {
+ throw new InternalServerErrorException("I/O error parsing a graph: " + e.getMessage());
+ }
+
+ JsonNode nodesJson = root.get("nodes");
+
+ if(nodesJson == null)
+ throw new BadRequestException("Invalid graph");
+
+ List<Node> nodeList = null;
+ try {
+ nodeList = new ObjectMapper().readValue(nodesJson.toString(), TypeFactory.defaultInstance().constructCollectionType(List.class, Node.class));
+ }
+ catch (JsonParseException e) {
+ throw new BadRequestException("Invalid content for a graph: " + e.getMessage());
+ }
+ catch (JsonMappingException e) {
+ throw new BadRequestException("Invalid input json structure for a graph: " + e.getMessage());
+ }
+ catch (IOException e) {
+ throw new InternalServerErrorException("I/O error parsing a graph: " + e.getMessage());
+ }
+
+ Graph graph = new Graph();
+ if(root.get("id") != null){
+ long graphId = root.get("id").asLong();
+ graph.setId(graphId);
+ }
+ Map<Long, Node> nodes = graph.getNodes();
+
+ long numberOfNodes = 0;
+ for (Node node : nodeList){
+ nodes.put(++numberOfNodes, node);
+ }
+ return graph;
+
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/deserializer/NodeCustomDeserializer.java b/verigraph/src/it/polito/verigraph/deserializer/NodeCustomDeserializer.java
new file mode 100644
index 0000000..22ec44a
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/deserializer/NodeCustomDeserializer.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * 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.verigraph.deserializer;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.InternalServerErrorException;
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+
+public class NodeCustomDeserializer extends JsonDeserializer<Node> {
+
+ @Override
+ public Node deserialize(JsonParser jp, DeserializationContext context) {
+
+ try {
+ JsonNode root = jp.getCodec().readTree(jp);
+ JsonNode neighboursJson = root.get("neighbours");
+ JsonNode configurationJson = root.get("configuration");
+ String nodeName = root.get("name").asText();
+ String functionalType = root.get("functional_type").asText();
+ Node node = new Node();
+
+ if(root.get("id") != null){
+ long nodeId = root.get("id").asLong();
+ node.setId(nodeId);
+ }
+ node.setName(nodeName);
+ node.setFunctional_type(functionalType);
+
+ if (configurationJson == null)
+ node.setConfiguration(new Configuration(node.getName(), "", new ObjectMapper().createArrayNode()));
+ else {
+ Configuration conf = node.getConfiguration();
+ conf.setId(node.getName());
+ conf.setDescription("");
+ conf.setConfiguration(configurationJson);
+ }
+
+ try {
+ List<Neighbour> neighbourList = new ObjectMapper().readValue( neighboursJson.toString(),
+ TypeFactory.defaultInstance()
+ .constructCollectionType(List.class,
+ Neighbour.class));
+ Map<Long, Neighbour> neighbours = node.getNeighbours();
+ long numberOfNeighbours = 0;
+ for (Neighbour neighbour : neighbourList) {
+ neighbours.put(++numberOfNeighbours, neighbour);
+ }
+
+ return node;
+ }
+ catch (JsonParseException e) {
+ throw new BadRequestException("Invalid content for a node: " + e.getMessage());
+ }
+ catch (JsonMappingException e) {
+ throw new BadRequestException("Invalid input json structure for a node: " + e.getMessage());
+ }
+ }
+ catch (JsonProcessingException e) {
+ throw new InternalServerErrorException("Error parsing a node: " + e.getMessage());
+ }
+ catch (IOException e) {
+ throw new InternalServerErrorException("I/O error parsing a node: " + e.getMessage());
+ }
+
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/deserializer/PathsMessageBodyReader.java b/verigraph/src/it/polito/verigraph/deserializer/PathsMessageBodyReader.java
new file mode 100644
index 0000000..e243fee
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/deserializer/PathsMessageBodyReader.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * 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.verigraph.deserializer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.Provider;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+
+import it.polito.neo4j.jaxb.Paths;
+
+@Provider
+@Consumes(MediaType.APPLICATION_XML)
+public class PathsMessageBodyReader implements MessageBodyReader<Paths>{
+
+ @Override
+ public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+ return type == Paths.class;
+ }
+
+ @Override
+ public Paths readFrom(Class<Paths> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+ MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
+ throws IOException, WebApplicationException {
+ try {
+ JAXBContext jaxbContext = JAXBContext.newInstance(Paths.class);
+ Paths paths = (Paths) jaxbContext.createUnmarshaller()
+ .unmarshal(entityStream);
+ return paths;
+ } catch (JAXBException jaxbException) {
+ throw new ProcessingException("Error deserializing a Paths object.",
+ jaxbException);
+ }
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/BadRequestException.java b/verigraph/src/it/polito/verigraph/exception/BadRequestException.java
new file mode 100644
index 0000000..254a035
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/BadRequestException.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.verigraph.exception;
+
+public class BadRequestException extends RuntimeException {
+
+ private static final long serialVersionUID = -548472179073745084L;
+
+ public BadRequestException(String message) {
+ super(message);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/BadRequestExceptionMapper.java b/verigraph/src/it/polito/verigraph/exception/BadRequestExceptionMapper.java
new file mode 100644
index 0000000..0eea67a
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/BadRequestExceptionMapper.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.verigraph.exception;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import it.polito.verigraph.model.ErrorMessage;
+
+@Provider
+public class BadRequestExceptionMapper implements ExceptionMapper<BadRequestException> {
+
+ @Override
+ public Response toResponse(BadRequestException exception) {
+ ErrorMessage errorMessage = new ErrorMessage( exception.getMessage(),
+ 400,
+ "http://localhost:8080/verigraph/api-docs/");
+ return Response.status(Status.BAD_REQUEST).entity(errorMessage).build();
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/DataNotFoundException.java b/verigraph/src/it/polito/verigraph/exception/DataNotFoundException.java
new file mode 100644
index 0000000..5c0a96c
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/DataNotFoundException.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.verigraph.exception;
+
+public class DataNotFoundException extends RuntimeException {
+
+ private static final long serialVersionUID = -6012364193903183208L;
+
+ public DataNotFoundException(String message) {
+ super(message);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/DataNotFoundExceptionMapper.java b/verigraph/src/it/polito/verigraph/exception/DataNotFoundExceptionMapper.java
new file mode 100644
index 0000000..e4b9071
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/DataNotFoundExceptionMapper.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.verigraph.exception;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import it.polito.verigraph.model.ErrorMessage;
+
+@Provider
+public class DataNotFoundExceptionMapper implements ExceptionMapper<DataNotFoundException> {
+
+ @Override
+ public Response toResponse(DataNotFoundException exception) {
+ ErrorMessage errorMessage = new ErrorMessage( exception.getMessage(),
+ 404,
+ "http://localhost:8080/verigraph/api-docs/");
+ return Response.status(Status.NOT_FOUND).entity(errorMessage).build();
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/ForbiddenException.java b/verigraph/src/it/polito/verigraph/exception/ForbiddenException.java
new file mode 100644
index 0000000..2e39667
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/ForbiddenException.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.verigraph.exception;
+
+public class ForbiddenException extends RuntimeException {
+
+ private static final long serialVersionUID = -4658914972167044321L;
+
+ public ForbiddenException(String message) {
+ super(message);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/ForbiddenExceptionMapper.java b/verigraph/src/it/polito/verigraph/exception/ForbiddenExceptionMapper.java
new file mode 100644
index 0000000..dc63898
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/ForbiddenExceptionMapper.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.verigraph.exception;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import it.polito.verigraph.model.ErrorMessage;
+
+@Provider
+public class ForbiddenExceptionMapper implements ExceptionMapper<ForbiddenException> {
+
+ @Override
+ public Response toResponse(ForbiddenException exception) {
+ ErrorMessage errorMessage = new ErrorMessage( exception.getMessage(),
+ 403,
+ "http://localhost:8080/verigraph/api-docs/");
+ return Response.status(Status.FORBIDDEN).entity(errorMessage).build();
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/GenericExceptionMapper.java b/verigraph/src/it/polito/verigraph/exception/GenericExceptionMapper.java
new file mode 100644
index 0000000..dcf3707
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/GenericExceptionMapper.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * 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.verigraph.exception;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+
+import it.polito.verigraph.model.ErrorMessage;
+
+// @Provider
+public class GenericExceptionMapper implements ExceptionMapper<Throwable> {
+
+ @Override
+ public Response toResponse(Throwable exception) {
+ ErrorMessage errorMessage = new ErrorMessage("Generic exception: " + exception.getMessage(),
+ 500,
+ "http://localhost:8080/verigraph/api-docs/");
+ return Response.status(Status.INTERNAL_SERVER_ERROR).entity(errorMessage).build();
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/InternalServerErrorException.java b/verigraph/src/it/polito/verigraph/exception/InternalServerErrorException.java
new file mode 100644
index 0000000..ecbde7e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/InternalServerErrorException.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.verigraph.exception;
+
+public class InternalServerErrorException extends RuntimeException {
+
+ private static final long serialVersionUID = 156815197709461502L;
+
+ public InternalServerErrorException(String message) {
+ super(message);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/exception/InternalServerErrorExceptionMapper.java b/verigraph/src/it/polito/verigraph/exception/InternalServerErrorExceptionMapper.java
new file mode 100644
index 0000000..3706d31
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/exception/InternalServerErrorExceptionMapper.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.verigraph.exception;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import it.polito.verigraph.model.ErrorMessage;
+
+@Provider
+public class InternalServerErrorExceptionMapper implements ExceptionMapper<InternalServerErrorException> {
+
+ @Override
+ public Response toResponse(InternalServerErrorException exception) {
+ ErrorMessage errorMessage = new ErrorMessage( exception.getMessage(),
+ 500,
+ "http://localhost:8080/verigraph/api-docs/");
+ return Response.status(Status.INTERNAL_SERVER_ERROR).entity(errorMessage).build();
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/grpc/client/Client.java b/verigraph/src/it/polito/verigraph/grpc/client/Client.java
new file mode 100644
index 0000000..0fc76ef
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/client/Client.java
@@ -0,0 +1,559 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.client;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import com.google.protobuf.Message;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import it.polito.verigraph.grpc.ConfigurationGrpc;
+import it.polito.verigraph.grpc.GetRequest;
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NeighbourGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NewNeighbour;
+import it.polito.verigraph.grpc.NewNode;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.grpc.NodeGrpc.FunctionalType;
+import it.polito.verigraph.grpc.Policy;
+import it.polito.verigraph.grpc.Policy.PolicyType;
+import it.polito.verigraph.grpc.RequestID;
+import it.polito.verigraph.grpc.Status;
+import it.polito.verigraph.grpc.VerificationGrpc;
+import it.polito.verigraph.grpc.VerigraphGrpc;
+
+public class Client {
+
+ private final ManagedChannel channel;
+ private final VerigraphGrpc.VerigraphBlockingStub blockingStub;
+
+ public Client(String host, int port) {
+ this(ManagedChannelBuilder.forAddress(host, port).usePlaintext(true));
+ }
+
+ /** Construct client for accessing RouteGuide server using the existing channel. */
+ public Client(ManagedChannelBuilder<?> channelBuilder) {
+ channel = channelBuilder.build();
+ blockingStub = VerigraphGrpc.newBlockingStub(channel);
+ }
+
+ /** Get array of graphs */
+ public List<GraphGrpc> getGraphs() {
+ List<GraphGrpc> graphsRecveived = new ArrayList<GraphGrpc>();
+ GetRequest request = GetRequest.newBuilder().build();
+ Iterator<GraphGrpc> graphs;
+ try {
+ graphs = blockingStub.getGraphs(request);
+ while (graphs.hasNext()) {
+ GraphGrpc graph = graphs.next();
+ System.out.println("[getGraphs] Graph id : "+graph.getId());
+ if(graph.getErrorMessage().equals("")){
+ System.out.println("[getGraphs] Node id : "+graph.getId());
+ graphsRecveived.add(graph);
+ }else{
+ System.out.println("[getGraphs] Error : " + graph.getErrorMessage());
+ return graphsRecveived;
+ }
+ }
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getGraphs] RPC failed: " + ex.getStatus());
+ }
+ return graphsRecveived;
+ }
+
+ /** Create new Graph */
+ public NewGraph createGraph(GraphGrpc gr) {
+ NewGraph response;
+ try {
+ response = blockingStub.createGraph(gr);
+ if(response.getSuccess()){
+ System.out.println("[createGraph] Successful operation ");
+ }else{
+ System.out.println("[createGraph] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[createGraph] RPC failed: " + e.getStatus());
+ return NewGraph.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Delete a Graph */
+ public boolean deleteGraph(long idGraph) {
+
+ RequestID id = RequestID.newBuilder().setIdGraph(idGraph).build();
+ Status response;
+ try {
+ response = blockingStub.deleteGraph(id);
+ if(response.getSuccess()){
+ System.out.println("[deleteGraph] Successful operation ");
+ return true;
+ }else{
+ System.out.println("[deleteGraph] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[deleteGraph] RPC failed: " + e.getStatus());
+ }
+ return false;
+ }
+
+ /** Edits a single graph */
+ public NewGraph updateGraph(long idGraph, GraphGrpc newGraph) {
+
+ GraphGrpc gr = GraphGrpc.newBuilder(newGraph).setId(idGraph).build();
+ NewGraph response;
+ try {
+ response = blockingStub.updateGraph(gr);
+ if(response.getSuccess()){
+ System.out.println("[updateGraph] Successful operation ");
+ }else{
+ System.out.println("[updateGraph] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[updateGraph] RPC failed: " + e.getStatus());
+ return NewGraph.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Get a single graph*/
+ public GraphGrpc getGraph(long idGraph) {
+
+ RequestID request = RequestID.newBuilder().setIdGraph(idGraph).build() ;
+ try {
+ GraphGrpc graph = blockingStub.getGraph(request);
+ if(!graph.getErrorMessage().equals("")){
+ System.out.println("[getGraph] Error in operation: " + graph.getErrorMessage());
+ }
+ return graph;
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getGraph] RPC failed: " + ex.getStatus());
+ return null;
+ }
+ }
+
+ /** Verify a given policy*/
+ public VerificationGrpc verify(Policy policy) {
+
+ VerificationGrpc response;
+ try {
+ response = blockingStub.verifyPolicy(policy);
+ if(!response.getErrorMessage().equals("")){
+ System.out.println("[verify] Error in operation: " + response.getErrorMessage());
+ }
+ System.out.println("[verify] Result : "+response.getResult());
+ System.out.println("[verify] Comment : "+response.getComment());
+ //uncomment if you want to print the paths
+ /*for(TestGrpc test:response.getTestList()){
+ System.out.println("Test : "+test.getResult()+". Traversed nodes:");
+ for(NodeGrpc node:test.getNodeList()){
+ //prints only the name
+ System.out.println("Node "+node.getName());
+ }
+ }*/
+ return response;
+ } catch (StatusRuntimeException e) {
+ System.err.println("[verify] RPC failed: " + e.getStatus());
+ return null;
+ }
+ }
+
+ /*Node part*/
+
+ /** Get array of nodes */
+ public List<NodeGrpc> getNodes(long idGraph) {
+ List<NodeGrpc> nodesReceived = new ArrayList<NodeGrpc>();
+ RequestID request = RequestID.newBuilder().setIdGraph(idGraph).build();
+ Iterator<NodeGrpc> nodes;
+ try {
+ nodes = blockingStub.getNodes(request);
+ while (nodes.hasNext()) {
+ NodeGrpc node = nodes.next();
+ if(node.getErrorMessage().equals("")){
+ System.out.println("[getNodes] Node id : "+node.getId());
+ nodesReceived.add(node);
+ }else{
+ System.out.println("[getNodes] Error : " + node.getErrorMessage());
+ return nodesReceived;
+ }
+ }
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getNodes] RPC failed: " + ex.getStatus());
+ }
+ return nodesReceived;
+ }
+
+ /** Create new Node */
+ public NewNode createNode(NodeGrpc node, long idGraph) {
+
+ NewNode response;
+ try {
+ NodeGrpc n = NodeGrpc.newBuilder(node).setIdGraph(idGraph).build();
+ response = blockingStub.createNode(n);
+ if(response.getSuccess()){
+ System.out.println("[createNode] Successful operation ");
+ }else{
+ System.out.println("[createNode] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[createNode] RPC failed: " + e.getStatus());
+ return NewNode.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Delete a Node */
+ public boolean deleteNode(long idGraph, long idNode) {
+
+ RequestID id = RequestID.newBuilder().setIdGraph(idGraph).setIdNode(idNode).build();
+ Status response;
+ try {
+ response = blockingStub.deleteNode(id);
+ if(response.getSuccess()){
+ System.out.println("[deleteNode] Successful operation ");
+ return true;
+ }else{
+ System.out.println("[deleteNode] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[deleteNode] RPC failed: " + e.getStatus());
+ }
+ return false;
+ }
+
+ /** Edits a single Node */
+ public NewNode updateNode(long idGraph, long idNode, NodeGrpc node) {
+
+ NodeGrpc nu = NodeGrpc.newBuilder(node).setIdGraph(idGraph).setId(idNode).build();
+ NewNode response;
+ try {
+ response = blockingStub.updateNode(nu);
+ if(response.getSuccess()){
+ System.out.println("[updateNode] Successful operation ");
+ }else{
+ System.out.println("[updateNode] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[updateNode] RPC failed: " + e.getStatus());
+ return NewNode.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Get a single Node*/
+ public NodeGrpc getNode(long idGraph, long idNode) {
+
+ RequestID request = RequestID.newBuilder().setIdGraph(idGraph).setIdNode(idNode).build() ;
+ try {
+ NodeGrpc node = blockingStub.getNode(request);
+ if(!node.getErrorMessage().equals("")){
+ System.out.println("[getNode] Error in operation: " + node.getErrorMessage());
+ }
+ return node;
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getNode] RPC failed: " + ex.getStatus());
+ return null;
+ }
+ }
+
+ /** Configure a single Node*/
+ public boolean configureNode(long idGraph, long idNode, ConfigurationGrpc configuration) {
+
+ try {
+ ConfigurationGrpc request = ConfigurationGrpc.newBuilder(configuration)
+ .setIdGraph(idGraph).setIdNode(idNode).build() ;
+
+ Status response = blockingStub.configureNode(request);
+ if(response.getSuccess()){
+ System.out.println("[configureNode] Successful operation ");
+ return true;
+ }else{
+ System.out.println("[configureNode] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[configureNode] RPC failed: " + e.getStatus());
+ }
+ return false;
+ }
+
+ /*Neighbour part*/
+
+ /** Get array of neighbours */
+ public List<NeighbourGrpc> getNeighbours(long idGraph, long idNode) {
+
+ List<NeighbourGrpc> neighboursReceived = new ArrayList<NeighbourGrpc>();
+ RequestID request = RequestID.newBuilder().setIdGraph(idGraph).setIdNode(idNode).build() ;
+ Iterator<NeighbourGrpc> neighbours;
+ try {
+ neighbours = blockingStub.getNeighbours(request);
+ while (neighbours.hasNext()) {
+ NeighbourGrpc neighbour = neighbours.next();
+ if(neighbour.getErrorMessage().equals("")){
+ System.out.println("[getNeighbours] Neighbour id : "+neighbour.getId());
+ neighboursReceived.add(neighbour);
+ }else{
+ System.out.println("[getNeighbours] Error : " + neighbour.getErrorMessage());
+ return neighboursReceived;
+ }
+ }
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getNeighbours] RPC failed: " + ex.getStatus());
+ }
+ return neighboursReceived;
+ }
+
+ /** Create new Neighbour */
+ public NewNeighbour createNeighbour(NeighbourGrpc neighbour, long idGraph, long idNode) {
+
+ NewNeighbour response;
+ try {
+ NeighbourGrpc n = NeighbourGrpc.newBuilder(neighbour).setIdGraph(idGraph)
+ .setIdNode(idNode).build();
+ response = blockingStub.createNeighbour(n);
+ if(response.getSuccess()){
+ System.out.println("[createNeighbour] Successful operation ");
+ }else{
+ System.out.println("[createNeighbour] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[createNeighbour] RPC failed: " + e.getStatus());
+ return NewNeighbour.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Delete a Neighbour */
+ public boolean deleteNeighbour(long idGraph, long idNode, long idNeighbour) {
+
+ RequestID id = RequestID.newBuilder().setIdGraph(idGraph).setIdNode(idNode).setIdNeighbour(idNeighbour).build();
+ Status response;
+ try {
+ response = blockingStub.deleteNeighbour(id);
+ if(response.getSuccess()){
+ System.out.println("[deleteNeighbour] Successful operation ");
+ return true;
+ }else{
+ System.out.println("[deleteNeighbour] Unsuccesful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[deleteNeighbour] RPC failed: " + e.getStatus());
+ }
+ return false;
+ }
+
+ /** Edits a single Neighbour */
+ public NewNeighbour updateNeighbour(long idGraph, long idNode, long idNeighbour, NeighbourGrpc neighbour) {
+
+ NeighbourGrpc nu = NeighbourGrpc.newBuilder(neighbour).setIdGraph(idGraph).setIdNode(idNode)
+ .setId(idNeighbour).build();
+ NewNeighbour response;
+ try {
+ response = blockingStub.updateNeighbour(nu);
+ if(response.getSuccess()){
+ System.out.println("[updateNeighbour] Successful operation ");
+ }else{
+ System.out.println("[updateNeighbour] Unsuccessful operation: " + response.getErrorMessage());
+ }
+ } catch (StatusRuntimeException e) {
+ System.err.println("[updateNeighbour] RPC failed: " + e.getStatus());
+ return NewNeighbour.newBuilder().setSuccess(false).build();
+ }
+ return response;
+ }
+
+ /** Get a single Neighbour*/
+ public NeighbourGrpc getNeighbour(long idGraph, long idNode, long idNeighbour) {
+
+ RequestID request = RequestID.newBuilder().setIdGraph(idGraph).setIdNode(idNode).setIdNeighbour(idNeighbour).build() ;
+ try {
+ NeighbourGrpc neighbour = blockingStub.getNeighbour(request);
+ if(!neighbour.getErrorMessage().equals("")){
+ System.out.println("[getNeighbour] Error in operation: " + neighbour.getErrorMessage());
+ }
+ return neighbour;
+ } catch (StatusRuntimeException ex) {
+ System.err.println("[getNeighbour] RPC failed: " + ex.getStatus());
+ return null;
+ }
+ }
+
+ public void shutdown() throws InterruptedException {
+ channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+ }
+
+ /** Test on the Server. */
+ public static void main(String[] args) throws Exception {
+
+ List<Long> listGraph = new ArrayList<Long>();//list of ID
+
+ Client client = new Client("localhost" , 50051);
+ try {
+ NodeGrpc node1 = createNodeGrpc("Node1", "endhost", null, null);
+ List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
+ NeighbourGrpc nb = createNeighbourGrpc("Node1");
+ neighbours.add(nb);
+ NodeGrpc node2 = createNodeGrpc("Node2", "endpoint", neighbours, null);
+ List<NodeGrpc> nodes = new ArrayList<NodeGrpc>();
+ nodes.add(node1);
+ nodes.add(node2);
+
+ GraphGrpc graph = createGraphGrpc(nodes);
+
+ NewGraph createdGraph = client.createGraph(graph);
+ if(createdGraph.getSuccess() == true){
+ listGraph.add(createdGraph.getGraph().getId());
+ System.out.println("Created graph with id :"+ createdGraph.getGraph().getId());
+ }
+
+ for(GraphGrpc g : client.getGraphs()){
+ long graph_id = g.getId();
+ System.out.println("graph id: "+graph_id);
+ for (NodeGrpc n: g.getNodeList()){
+ long node_id = n.getId();
+ System.out.println("node id: "+node_id);
+ NodeGrpc nodenew = createNodeGrpc("Newnode","endhost",null,null);
+ //NewNode node = client.updateNode(graph_id, node_id, nodenew);
+ //System.out.println("Client updates node: "+node.getSuccess());
+ System.out.println("end");
+ }
+ }
+
+
+ } catch(Exception ex){
+ System.out.println("Error: " + ex.getMessage());
+ ex.printStackTrace();
+ }finally {
+ client.shutdown();
+ }
+ }
+
+ public static NeighbourGrpc createNeighbourGrpc(String name){
+ return NeighbourGrpc.newBuilder().setName(name).build();
+ }
+
+ public static NodeGrpc createNodeGrpc(String name, String functionalType, List<NeighbourGrpc> neighbours, ConfigurationGrpc conf) throws Exception{
+ NodeGrpc.Builder nb = NodeGrpc.newBuilder();
+
+ if(name != null)
+ nb.setName(name);
+ else
+ throw new Exception("Node must have a name");
+
+ if(functionalType != null)
+ nb.setFunctionalType(FunctionalType.valueOf(functionalType));
+ else
+ throw new Exception("Node must have a functional type");
+
+ if( neighbours!= null){
+ for(NeighbourGrpc value:neighbours)
+ nb.addNeighbour(value);
+ }
+ if(conf == null){
+ try{
+ conf = createConfigurationGrpc(null, null, null, null);
+ }catch(Exception e){
+ throw new Exception(e.getMessage());
+ }
+ }
+ nb.setConfiguration(conf);
+ return nb.build();
+ }
+
+ public static GraphGrpc createGraphGrpc(List<NodeGrpc> nodes){
+ GraphGrpc.Builder gb = GraphGrpc.newBuilder();
+ if(nodes != null){
+ for(NodeGrpc value:nodes)
+ gb.addNode(value);
+ }
+ return gb.build();
+ }
+
+ public static Policy createPolicy(String src, String dst, String type, String middlebox, long idGraph) throws IllegalArgumentException{
+ if(!validMiddlebox(type, middlebox))
+ throw new IllegalArgumentException("Not valid middlebox valid with this type");
+ Policy.Builder policy = Policy.newBuilder();
+ policy.setIdGraph(idGraph);
+ if(src != null)
+ policy.setSource(src);
+ else{
+ throw new IllegalArgumentException("Please insert source field");
+ }
+ if(dst != null)
+ policy.setDestination(dst);
+ else{
+ throw new IllegalArgumentException("Please insert destination field");
+ }
+ if(type != null)
+ policy.setType(PolicyType.valueOf(type));
+ if(middlebox != null)
+ policy.setMiddlebox(middlebox);
+ return policy.build();
+ }
+
+ public static ConfigurationGrpc createConfigurationGrpc(Map<String,String> parameters, List<String> lists, String id, String description) throws Exception{
+ ConfigurationGrpc.Builder cb = ConfigurationGrpc.newBuilder();
+ StringBuilder sb = new StringBuilder("[");
+ if(parameters != null && lists == null){
+ int i = 0;
+ sb.append("{");
+ for (String key: parameters.keySet()) {
+ sb.append("\"");
+ sb.append(key);
+ sb.append("\":\"");
+ sb.append(parameters.get(key));
+ sb.append("\"");
+ if((i+1)<parameters.keySet().size()){
+ sb.append(", ");
+ }
+ i++;
+ }
+ sb.append("}");
+ }
+ else if(parameters == null && lists != null){
+ int i = 0;
+ for (String value: lists) {
+ sb.append("\"");
+ sb.append(value);
+ sb.append("\"");
+ if((i+1)<lists.size()){
+ sb.append(", ");
+ }
+ i++;
+ }
+ }
+ else if(parameters != null && lists != null){
+ throw new Exception("Error, configuration must contains or a sequence name:value or sequence"
+ + "of string, but not both");
+ }
+ sb.append("]");
+ cb.setConfiguration(sb.toString());
+ if(id != null)
+ cb.setId(id);
+ if(description != null)
+ cb.setDescription(description);
+ return cb.build();
+ }
+
+ private static boolean validMiddlebox(String type, String middlebox) {
+ if(type == null)
+ return false;
+ if(type.equals("reachability") && (middlebox == null || middlebox.equals("")))
+ return true;
+ if(type.equals("isolation") && !(middlebox == null || middlebox.equals("")))
+ return true;
+ if(type.equals("traversal") && !(middlebox == null || middlebox.equals("")))
+ return true;
+ return false;
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/grpc/server/GrpcUtils.java b/verigraph/src/it/polito/verigraph/grpc/server/GrpcUtils.java
new file mode 100644
index 0000000..43859db
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/server/GrpcUtils.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.server;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Splitter;
+import it.polito.verigraph.grpc.ConfigurationGrpc;
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NeighbourGrpc;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.grpc.TestGrpc;
+import it.polito.verigraph.grpc.VerificationGrpc;
+import it.polito.verigraph.grpc.NodeGrpc.FunctionalType;
+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.model.Test;
+import it.polito.verigraph.model.Verification;
+
+public class GrpcUtils {
+ private static final Logger logger = Logger.getLogger(GrpcUtils.class.getName());
+
+ public static NeighbourGrpc obtainNeighbour(Neighbour ne){
+ return NeighbourGrpc.newBuilder()
+ .setId(ne.getId())
+ .setName(ne.getName())
+ .build();
+ }
+
+ public static Neighbour deriveNeighbour(NeighbourGrpc request) {
+ //id is not present
+ Neighbour ne = new Neighbour();
+ ne.setName(request.getName());
+ return ne;
+ }
+
+ public static ConfigurationGrpc obtainConfiguration(Configuration conf){
+ return ConfigurationGrpc.newBuilder()
+ .setId(conf.getId())
+ .setDescription(conf.getDescription())
+ .setConfiguration(conf.getConfiguration().toString())
+ .build();
+ }
+
+ public static Configuration deriveConfiguration(ConfigurationGrpc request) {
+ Configuration conf = new Configuration();
+ conf.setId(request.getId());
+ conf.setDescription(request.getDescription());
+ ObjectMapper mapper = new ObjectMapper();
+ JsonNode rootNode = null;
+ try {
+ if ("".equals(request.getConfiguration()))
+ rootNode=mapper.readTree("[]");
+ else
+ rootNode = mapper.readTree(request.getConfiguration());
+ } catch (IOException e) {
+ logger.log(Level.WARNING, e.getMessage());
+ }
+ conf.setConfiguration(rootNode);
+ return conf;
+ }
+
+ public static NodeGrpc obtainNode(Node node) {
+ NodeGrpc.Builder nr = NodeGrpc.newBuilder();
+ nr.setId(node.getId());
+ nr.setName(node.getName());
+ nr.setFunctionalType(FunctionalType.valueOf(node.getFunctional_type()));
+ for(Neighbour neighbour:node.getNeighbours().values()){
+ NeighbourGrpc ng = obtainNeighbour(neighbour);
+ nr.addNeighbour(ng);
+ }
+ nr.setConfiguration(obtainConfiguration(node.getConfiguration()));
+ return nr.build();
+ }
+
+ public static Node deriveNode(NodeGrpc request) {
+ //id is not present
+ Node node = new Node();
+ node.setName(request.getName());
+ node.setFunctional_type(request.getFunctionalType().toString());
+ Configuration conf = deriveConfiguration(request.getConfiguration());
+ node.setConfiguration(conf);
+
+ Map<Long,Neighbour> neighours = node.getNeighbours();
+ long i = 1;
+ for(NeighbourGrpc neighbour:request.getNeighbourList()){
+ Neighbour ng = deriveNeighbour(neighbour);
+ neighours.put(i++, ng);
+ }
+
+ return node;
+ }
+
+ public static GraphGrpc obtainGraph(Graph graph){
+ GraphGrpc.Builder gr = GraphGrpc.newBuilder();
+ gr.setId(graph.getId());
+ for(Node node:graph.getNodes().values()){
+ NodeGrpc ng = obtainNode(node);
+ gr.addNode(ng);
+ }
+ return gr.build();
+ }
+
+ public static Graph deriveGraph(GraphGrpc request) {
+ //id is not present
+ Graph graph = new Graph();
+
+ long i=1;
+ Map<Long, Node> nodes= graph.getNodes();
+ for(NodeGrpc node:request.getNodeList()){
+ Node ng = deriveNode(node);
+ nodes.put(i++, ng);
+ }
+
+ return graph;
+ }
+
+ public static VerificationGrpc obtainVerification(Verification verify){
+ VerificationGrpc.Builder ver = VerificationGrpc.newBuilder();
+ ver.setComment(verify.getComment());
+ ver.setResult(verify.getResult());
+ for(Test test:verify.getTests()){
+ TestGrpc.Builder tst = TestGrpc.newBuilder().setResult(test.getResult());
+ for(Node node:test.getPath()){
+ NodeGrpc ng = obtainNode(node);
+ tst.addNode(ng);
+ }
+ ver.addTest(tst);
+ }
+ return ver.build();
+ }
+
+ /**Intended for string that begins with "?"
+ * */
+ public static Map<String,String> getParamGivenString(String str){
+ String string = str.substring(1);
+ final Map<String, String> map = Splitter.on('&').trimResults().withKeyValueSeparator("=").
+ split(string);
+ return map;
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/grpc/server/Service.java b/verigraph/src/it/polito/verigraph/grpc/server/Service.java
new file mode 100644
index 0000000..1839b7e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/server/Service.java
@@ -0,0 +1,466 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.server;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.FileHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import it.polito.verigraph.grpc.ConfigurationGrpc;
+import it.polito.verigraph.grpc.GetRequest;
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NeighbourGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NewNeighbour;
+import it.polito.verigraph.grpc.NewNode;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.grpc.Policy;
+import it.polito.verigraph.grpc.RequestID;
+import it.polito.verigraph.grpc.Status;
+import it.polito.verigraph.grpc.VerificationGrpc;
+import it.polito.verigraph.grpc.VerigraphGrpc;
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.exception.ForbiddenException;
+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.model.Verification;
+import it.polito.verigraph.resources.beans.VerificationBean;
+import it.polito.verigraph.service.GraphService;
+import it.polito.verigraph.service.NeighbourService;
+import it.polito.verigraph.service.NodeService;
+import it.polito.verigraph.service.VerificationService;
+
+public class Service {
+ /** Port on which the server should run. */
+ private static final Logger logger = Logger.getLogger(Service.class.getName());
+ private static final int port = 50051;
+ private static final String internalError = "Internal Server Error";
+ private Server server;
+ private GraphService graphService= new GraphService();
+ private VerificationService verificationService = new VerificationService();
+ private NodeService nodeService = new NodeService();
+ private NeighbourService neighboursService = new NeighbourService();
+
+ public Service(int port) {
+ this(ServerBuilder.forPort(port), port);
+ }
+
+ /** Create a RouteGuide server using serverBuilder as a base and features as data. */
+ public Service(ServerBuilder<?> serverBuilder, int port) {
+ server = serverBuilder.addService(new VerigraphImpl())
+ .build();
+ }
+
+ public void start() throws IOException {
+ FileHandler fileTxt = new FileHandler("grpc_server_log.txt");
+ SimpleFormatter formatterTxt = new SimpleFormatter();
+ fileTxt.setFormatter(formatterTxt);
+ logger.addHandler(fileTxt);
+ server.start();
+ logger.info("Server started, listening on "+ port);
+ Runtime.getRuntime().addShutdownHook(new Thread() {
+ @Override
+ public void run() {
+ logger.info("*** Shutting down gRPC server since JVM is shutting down");
+ Service.this.stop();
+ logger.info("*** Server shut down");
+ }
+ });
+ }
+
+ public void stop() {
+ if (server != null) {
+ server.shutdown();
+ }
+ }
+
+ private void blockUntilShutdown() throws InterruptedException {
+ if (server != null) {
+ server.awaitTermination();
+ }
+ }
+
+ /** Main function to launch server from cmd. */
+ public static void main(String[] args) throws IOException, InterruptedException {
+ try{
+ Service server = new Service(port);
+ server.start();
+ server.blockUntilShutdown();
+ }
+ catch(Exception ex){
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ }
+
+ /**Here start method of my implementation*/
+ private class VerigraphImpl extends VerigraphGrpc.VerigraphImplBase{
+
+ /** Here start methods of GraphResource*/
+ @Override
+ public void getGraphs(GetRequest request, StreamObserver<GraphGrpc> responseObserver) {
+ try{
+ for(Graph item : graphService.getAllGraphs()) {
+ GraphGrpc gr = GrpcUtils.obtainGraph(item);
+ responseObserver.onNext(gr);
+ }
+ }catch(Exception ex){
+ GraphGrpc nr = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
+ NewGraph.Builder response = NewGraph.newBuilder();
+ try{
+ Graph graph = GrpcUtils.deriveGraph(request);
+ Graph newGraph = graphService.addGraph(graph);
+ response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
+ }catch(BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getClass().toString());
+ logger.log(Level.WARNING, ex.getMessage());
+
+ }
+ catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getClass().toString());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteGraph(RequestID request, StreamObserver<Status> responseObserver) {
+
+ Status.Builder response = Status.newBuilder();
+ try{
+ graphService.removeGraph(request.getIdGraph());
+ response.setSuccess(true);
+ }catch(ForbiddenException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getGraph(RequestID request, StreamObserver<GraphGrpc> responseObserver) {
+ try{
+ Graph graph = graphService.getGraph(request.getIdGraph());
+ GraphGrpc gr = GrpcUtils.obtainGraph(graph);
+ responseObserver.onNext(gr);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(grError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(grError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
+ NewGraph.Builder response = NewGraph.newBuilder();
+ try{
+ Graph graph = GrpcUtils.deriveGraph(request);
+ graph.setId(request.getId());
+ Graph newGraph = graphService.updateGraph(graph);
+ response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void verifyPolicy(Policy request, StreamObserver<VerificationGrpc> responseObserver) {
+
+ VerificationGrpc.Builder verification;
+ try{
+ //Convert request
+ VerificationBean verify = new VerificationBean();
+ verify.setDestination(request.getDestination());
+ verify.setSource(request.getSource());
+ verify.setType(request.getType().toString());
+ verify.setMiddlebox(request.getMiddlebox());
+
+ //Convert Response
+ Verification ver = verificationService.verify(request.getIdGraph(), verify);
+ verification = VerificationGrpc.newBuilder(GrpcUtils.obtainVerification(ver))
+ .setSuccessOfOperation(true);
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
+ .setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
+ .setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(verification.build());
+ responseObserver.onCompleted();
+ }
+
+ /** Here start methods of NodeResource*/
+
+ @Override
+ public void getNodes(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
+ try{
+ for (Node item : nodeService.getAllNodes(request.getIdGraph())) {
+ NodeGrpc nr = GrpcUtils.obtainNode(item);
+ responseObserver.onNext(nr);
+ }
+ }catch(ForbiddenException | DataNotFoundException ex){
+ NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
+ NewNode.Builder response = NewNode.newBuilder();
+ try{
+ Node node = GrpcUtils.deriveNode(request);
+ Node newNode = nodeService.addNode(request.getIdGraph(), node);
+ response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteNode(RequestID request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ nodeService.removeNode(request.getIdGraph(), request.getIdNode());
+ response.setSuccess(true);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getNode(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
+ NodeGrpc nr;
+ try{
+ Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
+ nr= GrpcUtils.obtainNode(node);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(nr);
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
+ NewNode.Builder response = NewNode.newBuilder();
+ try{
+ Node node = GrpcUtils.deriveNode(request);
+ node.setId(request.getId());
+ Node newNode = nodeService.updateNode(request.getIdGraph(), node);
+ response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void configureNode(ConfigurationGrpc request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ if (request.getIdGraph() <= 0) {
+ throw new ForbiddenException("Illegal graph id: " + request.getIdGraph());
+ }
+ if (request.getIdNode() <= 0) {
+ throw new ForbiddenException("Illegal node id: " + request.getIdNode());
+ }
+ Graph graph = new GraphService().getGraph(request.getIdGraph());
+ if (graph == null){
+ throw new BadRequestException("Graph with id " + request.getIdGraph() + " not found");
+ }
+ Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
+ if (node == null){
+ throw new BadRequestException("Node with id " + request.getIdNode() + " not found in graph with id " + request.getIdGraph());
+ }
+ Configuration nodeConfiguration = GrpcUtils.deriveConfiguration(request);
+ Node nodeCopy = new Node();
+ nodeCopy.setId(node.getId());
+ nodeCopy.setName(node.getName());
+ nodeCopy.setFunctional_type(node.getFunctional_type());
+ Map<Long,Neighbour> nodes = new HashMap<Long,Neighbour>();
+ nodes.putAll(node.getNeighbours());
+ nodeCopy.setNeighbours(nodes);
+ nodeConfiguration.setId(nodeCopy.getName());
+ nodeCopy.setConfiguration(nodeConfiguration);
+ Graph graphCopy = new Graph();
+ graphCopy.setId(graph.getId());
+ graphCopy.setNodes(new HashMap<Long, Node>(graph.getNodes()));
+ graphCopy.getNodes().remove(node.getId());
+ NodeService.validateNode(graphCopy, nodeCopy);
+ graph.getNodes().put(request.getIdNode(), nodeCopy);
+ response.setSuccess(true);
+ }catch(ForbiddenException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ /** Here start methods of NeighbourResource*/
+ @Override
+ public void getNeighbours(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
+ try{
+ for(Neighbour item : neighboursService.getAllNeighbours(request.getIdGraph(), request.getIdNode())) {
+ NeighbourGrpc nr = GrpcUtils.obtainNeighbour(item);
+ responseObserver.onNext(nr);
+ }
+ }catch(ForbiddenException | DataNotFoundException ex){
+ NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
+ NewNeighbour.Builder response = NewNeighbour.newBuilder();
+ try{
+ Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
+ Neighbour newNeighbour = neighboursService.addNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
+ response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteNeighbour(RequestID request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ neighboursService.removeNeighbour(request.getIdGraph(), request.getIdNode(), request.getIdNeighbour());
+ response.setSuccess(true);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getNeighbour(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
+ NeighbourGrpc nr;
+ try{
+ Neighbour neighbour = neighboursService.getNeighbour(request.getIdGraph(),
+ request.getIdNode(), request.getIdNeighbour());
+ nr = GrpcUtils.obtainNeighbour(neighbour);
+
+ }catch(ForbiddenException | DataNotFoundException ex){
+ nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(nr);
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
+ NewNeighbour.Builder response = NewNeighbour.newBuilder();
+ try{
+ Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
+ neighbour.setId(request.getId());
+ Neighbour newNeighbour = neighboursService.updateNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
+ response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/grpc/test/GrpcServerTest.java b/verigraph/src/it/polito/verigraph/grpc/test/GrpcServerTest.java
new file mode 100644
index 0000000..e677bdd
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/test/GrpcServerTest.java
@@ -0,0 +1,392 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.test;
+
+import static org.junit.Assert.assertEquals;
+import io.grpc.ManagedChannel;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import it.polito.verigraph.grpc.ConfigurationGrpc;
+import it.polito.verigraph.grpc.GetRequest;
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NeighbourGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NewNeighbour;
+import it.polito.verigraph.grpc.NewNode;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.grpc.NodeGrpc.FunctionalType;
+import it.polito.verigraph.grpc.client.Client;
+import it.polito.verigraph.grpc.server.Service;
+import it.polito.verigraph.grpc.RequestID;
+import it.polito.verigraph.grpc.Status;
+import it.polito.verigraph.grpc.VerigraphGrpc;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Unit tests for {@link Service}.
+ * For testing basic gRPC unit test only.
+ * Not intended to provide a high code coverage or to test every major usecase.
+ */
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GrpcServerTest {
+ private Service server;
+ private ManagedChannel inProcessChannel;
+
+ @Before
+ public void setUp() throws Exception {
+ String uniqueServerName = "in-process server for " + getClass();
+ // use directExecutor for both InProcessServerBuilder and InProcessChannelBuilder can reduce the
+ // usage timeouts and latches in test. But we still add timeout and latches where they would be
+ // needed if no directExecutor were used, just for demo purpose.
+ server = new Service(InProcessServerBuilder.forName(uniqueServerName).directExecutor(),0);
+ server.start();
+ inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName).directExecutor().build();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ inProcessChannel.shutdownNow();
+ server.stop();
+ }
+
+ public void deleteGraphs() {
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+ Iterator<GraphGrpc> iter = stub.getGraphs(GetRequest.newBuilder().build());
+ while(iter.hasNext()){
+ stub.deleteGraph(RequestID.newBuilder().setIdGraph(iter.next().getId()).build());
+ }
+ }
+
+ @Test
+ public void test1Graph() throws Exception {
+ System.out.println("[DEBUG] test1Graphs starts");
+ deleteGraphs();
+ RequestID request = RequestID.newBuilder().setIdGraph(1).build() ;//id not present
+ GraphGrpc ufoundedGraph = GraphGrpc.newBuilder()
+ //.setErrorMessage("Graph with id 1 not found").build();
+ .setErrorMessage("There is no Graph whose Id is '1'").build();
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+
+ // graph not found in the server
+ GraphGrpc graph = stub.getGraph(request);
+ assertEquals(ufoundedGraph, graph);
+
+ // getGraph in the server, but first add it
+ GraphGrpc addedGraph = GraphGrpc.newBuilder().build();
+ NewGraph response = stub.createGraph(addedGraph);
+ addedGraph = response.getGraph();
+ //request = RequestID.newBuilder().setIdGraph(1).build() ;
+ request = RequestID.newBuilder().setIdGraph(response.getGraph().getId()).build() ;
+ graph = stub.getGraph(request);
+
+ assertEquals(addedGraph.getId(), graph.getId());
+
+ //updateGraph
+ GraphGrpc updatedGraph = GraphGrpc.newBuilder().setId(response.getGraph().getId()).build();
+ response = stub.updateGraph(updatedGraph);
+
+ assertEquals(response.getSuccess(),true);
+ }
+
+ @Test
+ public void test2Graphs() throws Exception {
+ System.out.println("[DEBUG] test2Graphs starts");
+ deleteGraphs();
+ // setup
+ GetRequest request = GetRequest.newBuilder().build();
+ GraphGrpc g1 = GraphGrpc.newBuilder().build();
+ GraphGrpc g2 = GraphGrpc.newBuilder().build();
+ GraphGrpc g3 = GraphGrpc.newBuilder().build();
+ GraphGrpc g4 = GraphGrpc.newBuilder().build();
+
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+
+ NewGraph g1_new = stub.createGraph(g1);
+ NewGraph g2_new = stub.createGraph(g2);
+ NewGraph g3_new = stub.createGraph(g3);
+ NewGraph g4_new = stub.createGraph(g4);
+
+ long g1_id = g1_new.getGraph().getId();
+ long g2_id = g2_new.getGraph().getId();
+ long g3_id = g3_new.getGraph().getId();
+ long g4_id = g4_new.getGraph().getId();
+ g1 = GraphGrpc.newBuilder(g1).setId(g1_id).build();
+ g2 = GraphGrpc.newBuilder(g2).setId(g2_id).build();
+ g3 = GraphGrpc.newBuilder(g3).setId(g3_id).build();
+ g4 = GraphGrpc.newBuilder(g4).setId(g4_id).build();
+ // run
+ Iterator<GraphGrpc> graphs = stub.getGraphs(request);
+
+ while(graphs.hasNext()){
+ graphs.next();
+ }
+
+ if(graphs.hasNext()){
+ graphs.next();
+ assertEquals(graphs.next(), g1);
+ assertEquals(graphs.next(), g2);
+ assertEquals(graphs.next(), g3);
+ assertEquals(graphs.next(), g4);
+
+ //deleteGraph
+ RequestID req = RequestID.newBuilder().setIdGraph(g1.getId()).build();
+ stub.deleteGraph(req);
+ // run
+ graphs = stub.getGraphs(request);
+
+ assertEquals(graphs.next(), g2);
+ assertEquals(graphs.next(), g3);
+ assertEquals(graphs.next(), g4);
+ }
+ }
+
+ @Test
+ public void test3Node() throws Exception {
+ System.out.println("[DEBUG] test3Graphs starts");
+ deleteGraphs();
+
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+ GraphGrpc g2 = GraphGrpc.newBuilder().build();
+ NewGraph g2_new = stub.createGraph(g2);
+ long g2_id = g2_new.getGraph().getId();
+
+ RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(1).build() ;//id not present
+ // graph not found in the server
+ NodeGrpc node = stub.getNode(request);
+
+ NodeGrpc unfoundedGraph = NodeGrpc.newBuilder()
+ //.setErrorMessage("Node with id 1 not found in graph with id 2").build();
+ //.setErrorMessage("There is no Graph whose Id is '2'").build();
+ .setErrorMessage("There is no Node whose Id is '1'").build();
+
+ assertEquals(unfoundedGraph, node);
+
+ // graph found in the server, but first add it
+ NodeGrpc addedNode = NodeGrpc.newBuilder().setName("client").setIdGraph(g2_id)
+ .setFunctionalType(FunctionalType.endhost).build();
+ NewNode response = stub.createNode(addedNode);
+ long node_id = response.getNode().getId();
+ //addedNode = response.getNode();
+
+ request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(addedNode.getId()).build() ;
+ node = stub.getNode(request);
+
+ assertEquals(addedNode.getId(), node.getId());
+ assertEquals(addedNode.getName(),"client");
+
+ //updateNode
+ NodeGrpc updatedNode = NodeGrpc.newBuilder().setName("Nodo2").setIdGraph(g2_id).setId(node_id)
+ .setFunctionalType(FunctionalType.endhost).build();
+
+ response = stub.updateNode(updatedNode);
+
+ assertEquals(response.getSuccess(),true);
+ assertEquals(response.getNode().getName(),"Nodo2");
+
+ //configureNode
+ Map<String,String> params = new HashMap<String,String>();
+ params.put("url", "www.facebook.com");
+ params.put("body", "word");
+ params.put("destination","server");
+ params.put("protocol", "HTTP_REQUEST");
+ ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null);
+ ConfigurationGrpc config = ConfigurationGrpc.newBuilder(configuration).setIdGraph(g2_id)
+ .setIdNode(node_id).build();
+
+ Status status = stub.configureNode(config);
+ assertEquals(status.getSuccess(),true);
+ }
+
+ @Test
+ public void test4Nodes() throws Exception {
+ System.out.println("[DEBUG] test4Graphs starts");
+ deleteGraphs();
+
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+ GraphGrpc g2 = GraphGrpc.newBuilder().build();
+ NewGraph g2_new = stub.createGraph(g2);
+ long g2_id = g2_new.getGraph().getId();
+
+ // setup
+ RequestID request = RequestID.newBuilder().setIdGraph(g2_id).build();
+ NodeGrpc n1 = NodeGrpc.newBuilder(Client.createNodeGrpc("Node5", "endhost", null, null))
+ .setIdGraph(g2_id).build();
+ NodeGrpc n2 = NodeGrpc.newBuilder(Client.createNodeGrpc("Node3", "endhost", null, null))
+ .setIdGraph(g2_id).build();
+ NodeGrpc n3 = NodeGrpc.newBuilder(Client.createNodeGrpc("Node4", "endhost", null, null))
+ .setIdGraph(g2_id).build();
+ NodeGrpc n4 = NodeGrpc.newBuilder(Client.createNodeGrpc("client", "endhost", null, null))
+ .setIdGraph(g2_id).build();
+
+ NewNode nn1= stub.createNode(n1);
+ NewNode nn2= stub.createNode(n2);
+ NewNode nn3= stub.createNode(n3);
+ NewNode nn4= stub.createNode(n4);
+
+ n1 = NodeGrpc.newBuilder(n1).setId(nn1.getNode().getId()).setIdGraph(g2_id).build();
+ n2 = NodeGrpc.newBuilder(n2).setId(nn2.getNode().getId()).setIdGraph(g2_id).build();
+ n3 = NodeGrpc.newBuilder(n3).setId(nn3.getNode().getId()).setIdGraph(g2_id).build();
+ n4 = NodeGrpc.newBuilder(n4).setId(nn4.getNode().getId()).setIdGraph(g2_id).build();
+
+ // run
+ Iterator<NodeGrpc> nodes = stub.getNodes(request);
+
+ while(nodes.hasNext()){
+ nodes.next();
+ //System.out.println("[DEBUG - TEST4] graph loaded: " + nodes.next());
+ }
+
+ if(nodes.hasNext()){
+ assertEquals(nodes.next(), n1);
+ assertEquals(nodes.next(), n2);
+ assertEquals(nodes.next(), n3);
+ assertEquals(nodes.next(), n4);
+ }
+
+ //deleteNode
+ RequestID req = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1.getId()).build();
+ stub.deleteNode(req);
+ // run
+ nodes = stub.getNodes(request);
+
+ while(nodes.hasNext()){
+ nodes.next();
+ //System.out.println("[DEBUG - TEST4] graph loaded: " + nodes.next());
+ }
+
+ if(nodes.hasNext()){
+ //assertEquals(nodes.next(), n1);
+ assertEquals(nodes.next(), n2);
+ assertEquals(nodes.next(), n3);
+ assertEquals(nodes.next(), n4);
+ }
+ }
+
+ @Test
+ public void test5Neighbours() throws Exception {
+ System.out.println("[DEBUG] test5Graphs starts");
+ deleteGraphs();
+
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+
+ GraphGrpc g2 = GraphGrpc.newBuilder().build();
+ NewGraph g2_new = stub.createGraph(g2);
+ long g2_id = g2_new.getGraph().getId();
+
+ NodeGrpc n1 = NodeGrpc.newBuilder().setName("Node1").setIdGraph(g2_id).setFunctionalType(FunctionalType.endhost).build();
+ NewNode new_n1 = stub.createNode(n1);
+ long n1_id = new_n1.getNode().getId();
+
+ NodeGrpc n2 = NodeGrpc.newBuilder().setName("client").setIdGraph(g2_id).setFunctionalType(FunctionalType.endhost).build();
+ NewNode new_n2 = stub.createNode(n2);
+ long n2_id = new_n2.getNode().getId();
+
+ RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setIdNeighbour(1).build() ;//id not present
+ NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder()
+ .setErrorMessage("Neighbour with id 1 not found for node with id "+n1_id+" in graph with id "+g2_id).build();
+
+ // Neighbour not found in the server
+ NeighbourGrpc neighbour = stub.getNeighbour(request);
+
+ assertEquals(ufoundedNeighbour, neighbour);
+
+ // getNeighbour, but first add it
+ NeighbourGrpc addedNeighbour = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setName("client").build();
+ NewNeighbour response = stub.createNeighbour(addedNeighbour);
+ addedNeighbour = response.getNeighbour();
+ request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
+ .setIdNeighbour(addedNeighbour.getId()).build();
+ neighbour = stub.getNeighbour(request);
+
+ assertEquals(addedNeighbour.getId(), neighbour.getId());
+
+ NodeGrpc updatedNode = NodeGrpc.newBuilder().setName("Node4").setIdGraph(g2_id).setId(n2_id)
+ .setFunctionalType(FunctionalType.endhost).build();
+
+ //updateNeighbour
+ NewNode response_node = stub.updateNode(updatedNode);
+ assertEquals(response_node.getSuccess(),true);
+
+ //NeighbourGrpc nu = NeighbourGrpc.newBuilder().setName("Node4")
+ //.setId(addedNeighbour.getId()).setIdGraph(g2_id).setIdNode(n1_id).build();
+ //response = stub.updateNeighbour(nu);
+ //System.out.println(response);
+
+ request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
+ .setIdNeighbour(addedNeighbour.getId()).build();
+ neighbour = stub.getNeighbour(request);
+ assertEquals(neighbour.getName(),"Node4");
+ }
+
+ @Test
+ public void test6Neighbours() throws Exception {
+ System.out.println("[DEBUG] test6Graphs starts");
+ deleteGraphs();
+
+ VerigraphGrpc.VerigraphBlockingStub stub = VerigraphGrpc.newBlockingStub(inProcessChannel);
+ // setup
+ GraphGrpc g2 = GraphGrpc.newBuilder().build();
+ NewGraph g2_new = stub.createGraph(g2);
+ long g2_id = g2_new.getGraph().getId();
+
+ NodeGrpc node1 = NodeGrpc.newBuilder().setName("Node1").setFunctionalType(FunctionalType.endhost).build();
+ NewNode new_n1 = stub.createNode(node1);
+ long n1_id = new_n1.getNode().getId();
+
+
+
+ NeighbourGrpc n1 = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
+ .setName("Node3").build();
+ NeighbourGrpc n2 = NeighbourGrpc.newBuilder().setIdGraph(g2_id).setIdNode(n1_id)
+ .setName("client").build();
+
+
+ stub.createNeighbour(n1);
+ stub.createNeighbour(n2);
+ n1 = NeighbourGrpc.newBuilder(n1).setId(2).setIdGraph(g2_id).setIdNode(n1_id).build();
+ n2 = NeighbourGrpc.newBuilder(n2).setId(3).setIdGraph(g2_id).setIdNode(n1_id).build();
+ // run
+ RequestID request = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).build();
+ Iterator<NeighbourGrpc> neighbours = stub.getNeighbours(request);
+
+ while(neighbours.hasNext()){
+ neighbours.next();
+ }
+
+ if(neighbours.hasNext()){
+ assertEquals(neighbours.next(), n1);
+ assertEquals(neighbours.next(), n2);
+ }
+
+ //deleteNeighbour
+ RequestID req = RequestID.newBuilder().setIdGraph(g2_id).setIdNode(n1_id).setIdNeighbour(n1.getId()).build();
+ stub.deleteNeighbour(req);
+ // run
+ neighbours = stub.getNeighbours(request);
+
+ while(neighbours.hasNext()){
+ neighbours.next();
+ }
+
+ if(neighbours.hasNext()){
+ assertEquals(neighbours.next(), n1);
+ assertEquals(neighbours.next(), n2);
+ }
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/grpc/test/GrpcTest.java b/verigraph/src/it/polito/verigraph/grpc/test/GrpcTest.java
new file mode 100644
index 0000000..a1830cf
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/test/GrpcTest.java
@@ -0,0 +1,422 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.MethodSorters;
+import it.polito.verigraph.grpc.ConfigurationGrpc;
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NeighbourGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NewNeighbour;
+import it.polito.verigraph.grpc.NewNode;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.grpc.client.Client;
+import it.polito.verigraph.grpc.server.Service;
+
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class GrpcTest {
+ private Service server;
+ private Client client;
+
+ @Before
+ public void setUpBeforeClass() throws Exception {
+ client = new Client("localhost" , 50051);
+ server = new Service(50051);
+
+ server.start();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ server.stop();
+ client.shutdown();
+ }
+
+ // method for comparing two non-null strings
+ private void compareString(String rs, String ts, String meaning) {
+ assertNotNull("NULL "+meaning, ts);
+ assertEquals("Wrong "+meaning, rs, ts);
+ }
+
+ public void deleteGraphs() {
+ for(GraphGrpc graph : client.getGraphs()){
+ client.deleteGraph(graph.getId());
+ }
+
+ }
+
+ @Test
+ public final void test1Load() throws Exception{
+ System.out.println("[DEBUG] test1Load starts");
+ deleteGraphs();
+ String funcType1 = "vpnaccess";
+ String funcType2 = "vpnexit";
+
+ // load an existing graph with 2 nodes
+ Map<String,String> map = new HashMap<String,String>();
+ map.put("vpnexit", "Node2");
+ ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
+ NodeGrpc node1 = Client.createNodeGrpc("Node1", funcType1, null, conf);
+ List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
+ NeighbourGrpc nb = Client.createNeighbourGrpc("Node1");
+ neighbours.add(nb);
+ map.clear();
+ map.put("vpnaccess", "Node1");
+ conf = Client.createConfigurationGrpc(map, null, null, null);
+ NodeGrpc node2 = Client.createNodeGrpc("Node2", funcType2, neighbours, conf);
+ List<NodeGrpc> nodes = new ArrayList<NodeGrpc>();
+ nodes.add(node1);
+ nodes.add(node2);
+ GraphGrpc graph = Client.createGraphGrpc(nodes);
+ //createGraph
+ graph = client.createGraph(graph).getGraph();
+
+ //getGraph
+ GraphGrpc retreivedGraph = client.getGraph(graph.getId());
+
+ assertNotNull("NULL Graph ",retreivedGraph);
+ assertEquals(graph.getId(), retreivedGraph.getId());
+
+ // check the name of first node and the id
+ compareString(retreivedGraph.getNodeList().get(0).getName(), graph.getNodeList().get(0).getName(), "node name");
+ assertEquals(retreivedGraph.getNodeList().get(0).getId(), graph.getNodeList().get(0).getId());
+
+ // check the name of second node and the id
+ compareString(retreivedGraph.getNodeList().get(1).getName(), graph.getNodeList().get(1).getName(), "node name");
+ assertEquals(retreivedGraph.getNodeList().get(1).getId(), graph.getNodeList().get(1).getId());
+
+ //updateGraph
+ GraphGrpc updatedGraph = GraphGrpc.newBuilder().build();
+ NewGraph response = client.updateGraph(graph.getId(),updatedGraph);
+
+ assertEquals(response.getSuccess(),true);
+ }
+
+ @Test
+ public final void test2LoadWithError() throws Exception{
+ System.out.println("[DEBUG] test2Load starts");
+ deleteGraphs();
+ // try to load a graph with node without functionalType
+ NodeGrpc node = null;
+ try{
+ node = Client.createNodeGrpc("Node1", null, null, null);
+ fail( "createNodeGrpc didn't throw when I expected it to" );
+ }
+ catch(Exception ex){
+ }
+ List<NodeGrpc> nodes = new ArrayList<NodeGrpc>();
+ if(node != null)
+ nodes.add(node);
+
+ GraphGrpc graph = Client.createGraphGrpc(nodes);
+ GraphGrpc g = client.createGraph(graph).getGraph();
+
+ GraphGrpc get_graph= client.getGraph(g.getId());
+ assertEquals(g.getErrorMessage(), get_graph.getErrorMessage());
+
+ //getGraphs
+ List<GraphGrpc> graph_list = client.getGraphs();
+ TreeSet<GraphGrpc> pts = new TreeSet<GraphGrpc>(new GraphGrpcComparator());
+ pts.addAll(graph_list);
+ Iterator<GraphGrpc> graphs = pts.iterator();
+
+ //assertEquals(graphs.next().getId(), g.getId());
+ if(graphs.hasNext())
+ assertEquals(graphs.next(), g);
+
+ //deleteGraph
+ boolean resp= client.deleteGraph(g.getId());
+ assertEquals(resp, true);
+
+ List<GraphGrpc> listGraphs = client.getGraphs();
+
+ assertEquals(listGraphs.size(), 0);
+ //assertEquals(listGraphs.get(0).getId(), 1);
+ }
+
+ @Test
+ public void test3Node() throws Exception {
+ System.out.println("[DEBUG] test3Load starts");
+ deleteGraphs();
+
+ NodeGrpc ufoundedGraph = NodeGrpc.newBuilder()
+ .setErrorMessage("There is no Graph whose Id is '1'").build();
+
+ // graph not found in the server
+ NodeGrpc node = client.getNode(1, 1);//id not present
+
+ assertEquals(ufoundedGraph, node);
+
+ // graph found in the server, but first add it
+ NodeGrpc addedNode = Client.createNodeGrpc("Node4", "firewall", null, null);
+ GraphGrpc addedgraph = Client.createGraphGrpc(null);
+ NewGraph response_graph = client.createGraph(addedgraph);
+ NewNode response = client.createNode(addedNode, response_graph.getGraph().getId());
+ addedNode = response.getNode();
+ node = client.getNode(response_graph.getGraph().getId(), addedNode.getId());
+
+ assertEquals(addedNode.getId(), node.getId());
+
+ //updateNode
+ NodeGrpc updatedNode = Client.createNodeGrpc("Node9", "endhost", null, null);
+ response = client.updateNode(response_graph.getGraph().getId(), addedNode.getId(), updatedNode);
+
+ assertEquals(response.getSuccess(),true);
+
+ //configureNode
+ //this configuration is valid only on endhost!
+ Map<String,String> params = new HashMap<String,String>();
+ params.put("url", "www.facebook.com");
+ params.put("body", "word");
+ params.put("destination","server");
+ params.put("protocol", "HTTP_REQUEST");
+ ConfigurationGrpc configuration = Client.createConfigurationGrpc(params, null, null, null);
+
+ boolean status = client.configureNode(response_graph.getGraph().getId(), addedNode.getId(), configuration);
+
+ assertEquals(status,true);
+ }
+
+ @Test
+ public void test4Nodes() throws Exception {
+ System.out.println("[DEBUG] test4Load starts");
+ // setup
+ GraphGrpc graph = Client.createGraphGrpc(null);
+ //createGraph
+ graph = client.createGraph(graph).getGraph();
+
+ List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
+ NeighbourGrpc nb = Client.createNeighbourGrpc("Node6");
+ neighbours.add(nb);
+ NodeGrpc n1 = Client.createNodeGrpc("Node6", "mailserver", null, null);
+ NodeGrpc n2 = Client.createNodeGrpc("Node9", "endhost", neighbours, null);
+ Map<String,String> map = new HashMap<String,String>();
+ map.put("mailserver", "Node6");
+ ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
+ NodeGrpc n3 = Client.createNodeGrpc("Node10", "mailclient", null, conf);
+ NodeGrpc n4 = Client.createNodeGrpc("Node11", "nat", null, null);
+
+ NewNode nw1 = client.createNode(n1, graph.getId());
+ NewNode nw2 = client.createNode(n2, graph.getId());
+ NewNode nw3 = client.createNode(n3, graph.getId());
+ NewNode nw4 = client.createNode(n4, graph.getId());
+ assertEquals(nw1.getSuccess(),true);
+ assertEquals(nw2.getSuccess(),true);
+ assertEquals(nw3.getSuccess(),true);
+ assertEquals(nw4.getSuccess(),true);
+ n1 = NodeGrpc.newBuilder(n1).setId(nw1.getNode().getId()).build();
+ n2 = NodeGrpc.newBuilder(n2).setId(nw2.getNode().getId()).build();
+ n3 = NodeGrpc.newBuilder(n3).setId(nw3.getNode().getId()).build();
+ n4 = NodeGrpc.newBuilder(n4).setId(nw4.getNode().getId()).build();
+
+ // getNodes
+ List<NodeGrpc> node_list = client.getNodes(graph.getId());
+ TreeSet<NodeGrpc> pts = new TreeSet<NodeGrpc>(new NodeGrpcComparator());
+ pts.addAll(node_list);
+ Iterator<NodeGrpc> nodes = pts.iterator();
+ //sorted by name
+ if(nodes.hasNext()){
+ assertEquals(nodes.next().getName(), n3.getName());
+ assertEquals(nodes.next().getName(), n4.getName());
+ assertEquals(nodes.next().getName(), n1.getName());
+ assertEquals(nodes.next().getName(), n2.getName());
+ }
+
+ //deleteNode
+ client.deleteNode(graph.getId(), n1.getId());
+ // run
+ node_list = client.getNodes(graph.getId());
+ pts = new TreeSet<NodeGrpc>(new NodeGrpcComparator());
+ pts.addAll(node_list);
+ nodes = pts.iterator();
+
+ assertEquals(nodes.next().getName(), n3.getName());
+ assertEquals(nodes.next().getName(), n4.getName());
+ assertEquals(nodes.next().getName(), n2.getName());
+ }
+
+ @Test
+ public void test5Neighbours() throws Exception {
+ System.out.println("[DEBUG] test5Load starts");
+ NeighbourGrpc ufoundedNeighbour = NeighbourGrpc.newBuilder()
+ .setErrorMessage("There is no Graph whose Id is '1'").build();;
+
+ // Neighbour not found in the server
+ NeighbourGrpc neighbour = client.getNeighbour(1, 1, 1);//id not present
+
+ assertEquals(ufoundedNeighbour, neighbour);
+
+ GraphGrpc graph = Client.createGraphGrpc(null);
+ graph = client.createGraph(graph).getGraph();
+
+ List<NeighbourGrpc> neighbours = new ArrayList<NeighbourGrpc>();
+ NeighbourGrpc nb = Client.createNeighbourGrpc("Node1");
+ neighbours.add(nb);
+ NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null);
+ NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", neighbours, null);
+ NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null);
+ NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null);
+ NodeGrpc n5 = Client.createNodeGrpc("Node5", "webserver", null, null);
+ Map<String,String> map = new HashMap<String,String>();
+ map.put("webserver", "Node5");
+ ConfigurationGrpc conf = Client.createConfigurationGrpc(map, null, null, null);
+ NodeGrpc n6 = Client.createNodeGrpc("Node6", "webclient", null, conf);
+ NodeGrpc n7 = Client.createNodeGrpc("Node7", "cache", null, null);
+ NodeGrpc n8 = Client.createNodeGrpc("Node8", "firewall", null, null);
+ NodeGrpc n9 = Client.createNodeGrpc("Node9", "fieldmodifier", null, null);
+ NodeGrpc n10 = Client.createNodeGrpc("Node10", "dpi", null, null);
+ NewNode nw1 = client.createNode(n1, graph.getId());
+ NewNode nw2 = client.createNode(n2, graph.getId());
+ NewNode nw3 = client.createNode(n3, graph.getId());
+ NewNode nw4 = client.createNode(n4, graph.getId());
+ NewNode nw5 = client.createNode(n5, graph.getId());
+ NewNode nw6 = client.createNode(n6, graph.getId());
+ NewNode nw7 = client.createNode(n7, graph.getId());
+ NewNode nw8 = client.createNode(n8, graph.getId());
+ NewNode nw9 = client.createNode(n9, graph.getId());
+ NewNode nw10 = client.createNode(n10, graph.getId());
+ assertEquals(nw1.getSuccess(),true);
+ assertEquals(nw2.getSuccess(),true);
+ assertEquals(nw3.getSuccess(),true);
+ assertEquals(nw4.getSuccess(),true);
+ assertEquals(nw5.getSuccess(),true);
+ assertEquals(nw6.getSuccess(),true);
+ assertEquals(nw7.getSuccess(),true);
+ assertEquals(nw8.getSuccess(),true);
+ assertEquals(nw9.getSuccess(),true);
+ assertEquals(nw10.getSuccess(),true);
+
+ // getNeighbour, but first add it
+ NeighbourGrpc addedNeighbour = Client.createNeighbourGrpc("Node9");
+ NewNeighbour response = client.createNeighbour(addedNeighbour, graph.getId(), nw1.getNode().getId());
+ addedNeighbour = response.getNeighbour();
+ neighbour = client.getNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour.getId());
+
+ assertEquals(addedNeighbour.getId(), neighbour.getId());
+
+ //updateNeighbour
+ NeighbourGrpc updatedNeighbour = Client.createNeighbourGrpc("Node10");
+
+ response = client.updateNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour.getId(),updatedNeighbour);
+
+ assertEquals(response.getSuccess(),true);
+ assertEquals(response.getNeighbour().getName(),"Node10");
+ }
+
+ @Test
+ public void test6Neighbours() throws Exception {
+ System.out.println("[DEBUG] test6Load starts");
+ // setup
+ GraphGrpc graph = Client.createGraphGrpc(null);
+ //createGraph
+ graph = client.createGraph(graph).getGraph();
+
+ NodeGrpc n1 = Client.createNodeGrpc("Node1", "antispam", null, null);
+ NodeGrpc n2 = Client.createNodeGrpc("Node2", "endhost", null, null);
+ NodeGrpc n3 = Client.createNodeGrpc("Node3", "endhost", null, null);
+ NodeGrpc n4 = Client.createNodeGrpc("Node4", "endpoint", null, null);
+ NewNode nw1 = client.createNode(n1, graph.getId());
+ NewNode nw2 = client.createNode(n2, graph.getId());
+ NewNode nw3 = client.createNode(n3, graph.getId());
+ NewNode nw4 = client.createNode(n4, graph.getId());
+ assertEquals(nw1.getSuccess(),true);
+ assertEquals(nw2.getSuccess(),true);
+ assertEquals(nw3.getSuccess(),true);
+ assertEquals(nw4.getSuccess(),true);
+
+ //createNeighbour
+ NeighbourGrpc nn1 = Client.createNeighbourGrpc("Node2");
+ NewNeighbour addedNeighbour1 = client.createNeighbour(nn1, graph.getId(), nw1.getNode().getId());
+ assertEquals(addedNeighbour1.getSuccess(),true);
+ NeighbourGrpc nn2 = Client.createNeighbourGrpc("Node3");
+ NewNeighbour addedNeighbour2 = client.createNeighbour(nn2, graph.getId(), nw1.getNode().getId());
+ assertEquals(addedNeighbour2.getSuccess(),true);
+ NeighbourGrpc nn3 = Client.createNeighbourGrpc("Node4");
+ NewNeighbour addedNeighbour3 = client.createNeighbour(nn3, graph.getId(), nw1.getNode().getId());
+ assertEquals(addedNeighbour3.getSuccess(),true);
+
+ nn1 = NeighbourGrpc.newBuilder(nn1).setId(1).build();
+ nn2 = NeighbourGrpc.newBuilder(nn2).setId(2).build();
+ nn3 = NeighbourGrpc.newBuilder(nn3).setId(3).build();
+ // run
+ List<NeighbourGrpc> node_list = client.getNeighbours(graph.getId(), nw1.getNode().getId());
+ TreeSet<NeighbourGrpc> pts = new TreeSet<NeighbourGrpc>(new NeighbourGrpcComparator());
+ pts.addAll(node_list);
+ Iterator<NeighbourGrpc> neighbours = pts.iterator();
+
+ while(neighbours.hasNext()){
+ neighbours.next();
+ }
+
+ if(neighbours.hasNext()){
+ assertEquals(neighbours.next(), addedNeighbour1.getNeighbour());
+ assertEquals(neighbours.next(), addedNeighbour2.getNeighbour());
+ assertEquals(neighbours.next(), addedNeighbour3.getNeighbour());
+ }
+
+ //deleteNeighbour
+ boolean succ = client.deleteNeighbour(graph.getId(), nw1.getNode().getId(), addedNeighbour1.getNeighbour().getId());
+ assertEquals(succ, true);
+ // run
+ node_list = client.getNeighbours(graph.getId(), nw1.getNode().getId());
+ pts = new TreeSet<NeighbourGrpc>(new NeighbourGrpcComparator());
+ pts.addAll(node_list);
+ neighbours = pts.iterator();
+
+ while(neighbours.hasNext()){
+ neighbours.next();
+ }
+
+
+ if(neighbours.hasNext()){
+ assertEquals(neighbours.next(), addedNeighbour2.getNeighbour());
+ assertEquals(neighbours.next(), addedNeighbour3.getNeighbour());
+ }
+ }
+}
+
+
+class NodeGrpcComparator implements Comparator<NodeGrpc> {
+ public int compare(NodeGrpc n0, NodeGrpc n1) {
+ return n0.getName().compareTo(n1.getName());
+ }
+}
+
+class NeighbourGrpcComparator implements Comparator<NeighbourGrpc> {
+ public int compare(NeighbourGrpc n0, NeighbourGrpc n1) {
+ return n0.getName().compareTo(n1.getName());
+ }
+}
+
+class GraphGrpcComparator implements Comparator<GraphGrpc> {
+ public int compare(GraphGrpc n0, GraphGrpc n1) {
+ if(n0.getId() == n1.getId())
+ return 0;
+ else if (n0.getId() > n1.getId())
+ return 1;
+ else return -1;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java b/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java
new file mode 100644
index 0000000..79deaff
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/test/MultiThreadTest.java
@@ -0,0 +1,220 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.test;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.MethodSorters;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.NodeGrpc;
+import it.polito.verigraph.client.VerifyClientException;
+import it.polito.verigraph.grpc.client.Client;
+import it.polito.verigraph.grpc.server.Service;
+
+/**
+ * Unit tests for gRPC project.
+ * For testing concurrency on server side.
+ */
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MultiThreadTest {
+ private Service server;
+ private Client client;
+
+ @Before
+ public void setUp() throws Exception {
+ client = new Client("localhost" , 50051);
+ server = new Service(50051);
+
+ server.start();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ server.stop();
+ client.shutdown();
+ }
+
+ private void testUpdateGraphStatus(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ GraphGrpc retrieveGraphResponse =client.getGraph(1);
+
+ UpdateGraph task = new UpdateGraph(client, 1, retrieveGraphResponse);
+
+ List<MultiThreadTest.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<NewGraph>> futures = executorService.invokeAll(tasks);
+ List<Boolean> resultList = new ArrayList<Boolean>(futures.size());
+
+ // Check for exceptions
+ for (Future<NewGraph> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ resultList.add(future.get().getSuccess());
+ }
+ // Validate the dimensions
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<Boolean> expectedList = new ArrayList<Boolean>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(true);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private void testUpdateGraph(final int threadCount) throws Exception {
+ GraphGrpc retrieveGraph = client.getGraph(2L);
+
+ NodeGrpc nodeToEdit = Client.createNodeGrpc("client",
+ "endpoint",
+ null,
+ Client.createConfigurationGrpc(null, null, "client", ""));
+
+ GraphGrpc graphToUpdate = GraphGrpc.newBuilder(retrieveGraph).addNode(nodeToEdit).build();
+
+ String graphAsString = graphToUpdate.toString();
+
+ UpdateGraph task = new UpdateGraph(client, 2, graphToUpdate);
+
+ List<MultiThreadTest.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<NewGraph>> futures = executorService.invokeAll(tasks);
+ List<String> resultList = new ArrayList<String>(futures.size());
+
+ // Check for exceptions
+ for (Future<NewGraph> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ GraphGrpc graphReceived = future.get().getGraph();
+ NodeGrpc node = NodeGrpc.newBuilder(graphReceived.getNode(0)).setId(0).build();
+ GraphGrpc graph = GraphGrpc.newBuilder(graphReceived).setNode(0, node).build();
+ resultList.add(graph.toString());
+ }
+ // Validate dimensions
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<String> expectedList = new ArrayList<String>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(graphAsString);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private void testCreateGraphStatus(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException {
+
+ GraphGrpc graph = GraphGrpc.newBuilder().build();
+
+ CreateGraph task = new CreateGraph(client, graph);
+
+ List<MultiThreadTest.CreateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<Boolean>> futures = executorService.invokeAll(tasks);
+ List<Boolean> resultList = new ArrayList<Boolean>(futures.size());
+
+ // Check for exceptions
+ for (Future<Boolean> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ resultList.add(future.get());
+ }
+ // Validate the IDs
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<Boolean> expectedList = new ArrayList<Boolean>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(true);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private int randInt(int min, int max){
+ Random rand = new Random();
+ int randomNum = rand.nextInt((max - min) + 1) + min;
+ return randomNum;
+ }
+
+ @Test
+ public void updateGraphStatusCheck() throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ testUpdateGraphStatus(64);
+ }
+
+ @Test
+ public void updateGraphResponseCheck() throws Exception {
+ testUpdateGraph(16);
+ }
+
+ @Test
+ public void createGraphStatusCheck() throws JsonParseException, JsonMappingException, InterruptedException, ExecutionException, IOException {
+ testCreateGraphStatus(8);
+ }
+
+ class UpdateGraph implements Callable<NewGraph> {
+
+ private Client verifyClient;
+
+ private int graphId;
+
+ private GraphGrpc graph;
+
+ public UpdateGraph(Client verifyClient, int graphId, GraphGrpc graph) {
+ this.graphId = graphId;
+ this.graph = graph;
+ this.verifyClient = verifyClient;
+ }
+
+ @Override
+ public NewGraph call() throws Exception {
+ Thread.sleep(randInt(0,2000));
+ return this.verifyClient.updateGraph(this.graphId, this.graph);
+ }
+ }
+
+ class CreateGraph implements Callable<Boolean> {
+
+ private Client verifyClient;
+
+ private GraphGrpc graph;
+
+ public CreateGraph(Client verifyClient, GraphGrpc graph) {
+ this.graph = graph;
+ this.verifyClient = verifyClient;
+ }
+
+ @Override
+ public Boolean call() throws Exception {
+ Thread.sleep(randInt(0,2000));
+ return this.verifyClient.createGraph(this.graph).getSuccess();
+ }
+
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/grpc/test/ReachabilityTest.java b/verigraph/src/it/polito/verigraph/grpc/test/ReachabilityTest.java
new file mode 100644
index 0000000..a256763
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/grpc/test/ReachabilityTest.java
@@ -0,0 +1,274 @@
+/*******************************************************************************
+ * 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.verigraph.grpc.test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.MethodSorters;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.BufferedReader;
+import java.io.FilenameFilter;
+import java.io.InputStreamReader;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.fge.jsonschema.core.exceptions.ProcessingException;
+import com.github.fge.jsonschema.main.JsonSchema;
+
+import it.polito.verigraph.grpc.GraphGrpc;
+import it.polito.verigraph.grpc.NewGraph;
+import it.polito.verigraph.grpc.Policy;
+import it.polito.verigraph.grpc.VerificationGrpc;
+import it.polito.verigraph.client.VerifyClientException;
+import it.polito.verigraph.grpc.client.Client;
+import it.polito.verigraph.grpc.server.GrpcUtils;
+import it.polito.verigraph.grpc.server.Service;
+import it.polito.verigraph.service.ValidationUtils;
+import it.polito.verigraph.test.TestCase;
+import it.polito.verigraph.test.TestExecutionException;
+
+@RunWith(JUnit4.class)
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class ReachabilityTest {
+ private File schema;
+ private List<File>testFiles= new ArrayList<File>();
+ private List<TestCase>testCases= new ArrayList<TestCase>();
+ private Client client;
+ private Service server;
+
+ @Before
+ public void setUpBeforeClass() throws Exception {
+ client = new Client("localhost" , 50051);
+ server = new Service(50051);
+ server.start();
+
+ String folderName = System.getProperty("user.dir") + "/tester/testcases";
+ File folder = new File(folderName);
+ if (!folder.exists()) {
+ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+ String s;
+ do{
+ System.out.println("Please enter the testcases folder path: ");
+ s = in.readLine();
+ if (isValidpath(s)){
+ folder = new File(s);
+ break;
+ }
+ }while (s != null && s.length() != 0);
+ if(s == null)
+ System.exit(0);
+ }
+ String schemaName = System.getProperty("user.dir") + "/tester/testcase_schema.json";
+ File schema = new File(schemaName);
+ if (!schema.exists()) {
+ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+ String s;
+ do{
+ System.out.println("Please enter the full path of 'testcase_schema.json': ");
+ s = in.readLine();
+ if (isValidpath(s)){
+ folder = new File(s);
+ break;
+ }
+ }while (s != null && s.length() != 0);
+ if(s == null)
+ System.exit(0);
+ }
+
+ this.schema = schema;
+ this.testFiles = getTests(folder);
+ this.testCases = getTestCases(this.testFiles);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ server.stop();
+ client.shutdown();
+ }
+
+ @Test
+ public final void wrongReachability() {
+ System.out.println("[DEBUG] wrongReachability starts");
+ System.out.println("DEBUG: starting testWrongReachability");
+
+ VerificationGrpc nullVer = VerificationGrpc.newBuilder()
+ .setErrorMessage("There is no Graph whose Id is '52'").build();
+ //verification on uncreated graph
+ if(client.getGraph(52) != null){
+ client.deleteGraph(52);
+ }
+ Policy policyToVerify = Client.createPolicy("Node1", "Node4", "reachability", null, 52);
+ VerificationGrpc ver = client.verify(policyToVerify);
+ assertEquals(ver, nullVer);
+
+ //verification on uncreated nodes
+ GraphGrpc graph = GraphGrpc.newBuilder().build();
+ graph = client.createGraph(graph).getGraph();
+ nullVer = VerificationGrpc.newBuilder()
+ .setErrorMessage("The \'source\' parameter \'Node5\' is not valid, please insert the name of an existing node").build();
+ policyToVerify = Client.createPolicy("Node5", "Node4", "reachability", null, graph.getId());
+ ver = client.verify(policyToVerify);
+ assertEquals(ver, nullVer);
+
+ //verification on uncreated nodes
+ nullVer = VerificationGrpc.newBuilder()
+ .setErrorMessage("The \'source\' parameter \'Node1\' is not valid, please insert the name of an existing node").build();
+
+ policyToVerify = Client.createPolicy("Node1", "Node10", "reachability", null, graph.getId());
+ ver = client.verify(policyToVerify);
+ assertEquals(ver, nullVer);
+
+ }
+
+ public List<File> getTests(File folder) {
+ List<File> filesList = new ArrayList<File>();
+
+ System.out.println("Test folder set to '" + folder.getAbsolutePath() + "'");
+
+ File[] files = folder.listFiles(new FilenameFilter() {
+
+ @Override
+ public boolean accept(File dir, String name) {
+ return name.endsWith(".json");
+ }
+ });
+
+ for (File f : files) {
+ filesList.add(f);
+ System.out.println("File '" + f.getName() + "' added to test files");
+ }
+
+ return filesList;
+ }
+
+ public List<TestCase> getTestCases(List<File> files)throws JsonParseException, JsonMappingException, IOException,
+ Exception {
+ List<TestCase> testCases = new ArrayList<TestCase>();
+
+ for (File file : files) {
+ validateTestFile(file);
+ try {
+ TestCase tc = new ObjectMapper().readValue(file, TestCase.class);
+ testCases.add(tc);
+ }
+ catch (Exception e) {
+ throw e;
+ }
+ }
+
+ return testCases;
+ }
+
+ @Test
+ public void runTestCases() throws VerifyClientException, TestExecutionException {
+ System.out.println("[DEBUG] runTestCases starts");
+ int counter = 0;
+ for (TestCase tc : this.testCases) {
+ List<String> results = runTestCase(tc);
+ Iterator<String> iter = tc.getResults().iterator();
+
+ if(results.isEmpty()){
+ throw new TestExecutionException("Error running test given in file '"+ this.testFiles.get(counter).getName()+ "'.");
+ }
+
+ for(String result : results){
+ if (iter.hasNext()){
+ if( !result.equals(iter.next()))
+ throw new TestExecutionException("Error running test given in file '"+ this.testFiles.get(counter).getName()
+ + "'. Test returned '" + result + "' instead of '" + tc.getResults() + "'.");
+ else
+ System.out.println("Test given in file '"+ this.testFiles.get(counter).getName() + "' returned '"
+ + result + "' as expected");
+ } else throw new TestExecutionException("Error running test given in file '"+ this.testFiles.get(counter).getName()
+ + "'. Test returned '" + result + "' instead of '" + tc.getResults() + "'.");
+ }
+ counter++;
+
+ }
+ System.out.println("All tests PASSED");
+ }
+
+ private List<String> runTestCase(TestCase tc) throws VerifyClientException, TestExecutionException{
+ GraphGrpc graph = GrpcUtils.obtainGraph(tc.getGraph());
+ ArrayList<String> results = new ArrayList<String>();
+
+ NewGraph newGraph = this.client.createGraph(graph);
+ if(newGraph.getSuccess() == false)
+ throw new VerifyClientException("gRPC request failed");
+ GraphGrpc createdGraph = newGraph.getGraph();
+
+ GraphGrpc addedgraph = client.getGraph(createdGraph.getId());
+ System.out.println(addedgraph);
+
+ for(String url : tc.getPolicyUrlParameters()){
+ final Map<String, String> map = GrpcUtils.getParamGivenString(url);
+ Policy policy = Client.createPolicy(map.get("source"),
+ map.get("destination"),
+ map.get("type"),
+ map.get("middlebox"),
+ createdGraph.getId());
+ VerificationGrpc verification = this.client.verify(policy);
+ results.add(verification.getResult());
+ }
+ return results;
+ }
+
+ public void validateTestFile(File testFile) throws Exception {
+ JsonSchema schemaNode = null;
+ try {
+ schemaNode = ValidationUtils.getSchemaNode(schema);
+ }
+ catch (IOException e) {
+ throw new Exception("Unable to load '" + schema.getAbsolutePath() + "' schema file");
+ }
+ catch (ProcessingException e) {
+ throw new Exception("Unable to resolve '" + schema.getAbsolutePath() + "' schema file as a schema node");
+ }
+
+ JsonNode jsonNode;
+ try {
+ jsonNode = ValidationUtils.getJsonNode(testFile);
+ }
+ catch (IOException e) {
+ throw new Exception("Unable to load '" + testFile.getAbsolutePath() + "' as a json node");
+ }
+
+ try {
+ ValidationUtils.validateJson(schemaNode, jsonNode);
+ }
+ catch (ProcessingException e) {
+ throw new Exception("There were errors in the validation of file '"+ testFile.getAbsolutePath()
+ + "' against the json schema '" + schema.getAbsolutePath() + "': " + e.getMessage());
+
+ }
+ }
+
+ private static boolean isValidpath(String s) {
+ if (s==null)
+ return false;
+ File file = new File(s);
+ return file.exists();
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/Checker.java b/verigraph/src/it/polito/verigraph/mcnet/components/Checker.java
new file mode 100644
index 0000000..2d1f2d5
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/Checker.java
@@ -0,0 +1,377 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Model;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Status;
+import it.polito.verigraph.mcnet.components.IsolationResult;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/**Various checks for specific properties in the network.
+ *
+ *
+ */
+public class Checker {
+
+ Context ctx;
+ Network net;
+ NetContext nctx;
+ Solver solver;
+ ArrayList<BoolExpr> constraints;
+ public BoolExpr [] assertions;
+ public Status result;
+ public Model model;
+
+
+ public Checker(Context context,NetContext nctx,Network network){
+ this.ctx = context;
+ this.net = network;
+ this.nctx = nctx;
+ this.solver = ctx.mkSolver();
+ this.constraints = new ArrayList<BoolExpr>();
+ }
+
+ /**Resets the constraints
+ *
+ */
+ public void clearState (){
+ this.solver.reset();
+ this.constraints = new ArrayList<BoolExpr>();
+ }
+
+ /**Checks whether the source provided can reach the destination
+ *
+ * @param src
+ * @param dest
+ * @return
+ */
+ public IsolationResult checkIsolationProperty (NetworkObject src, NetworkObject dest){
+ assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ solver.push ();
+ addConstraints();
+
+
+ Expr p0 = ctx.mkConst("check_isolation_p0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+ Expr p1 = ctx.mkConst("check_isolation_p1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_1 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ IntExpr t_0 = ctx.mkIntConst("check_isolation_t0_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_1 = ctx.mkIntConst("check_isolation_t1_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+ // Constraint1recv(n_0,destNode,p0,t_0)
+ this.solver.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p0, t_0));
+
+ // Constraint2send(srcNode,n_1,p1,t_1)
+ this.solver.add((BoolExpr)nctx.send.apply(src.getZ3Node(), n_1, p1, t_1));
+
+ // Constraint3nodeHasAddr(srcNode,p1.srcAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(src.getZ3Node(), nctx.pf.get("src").apply(p1)));
+
+
+ // Constraint4p1.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p1), src.getZ3Node()));
+
+ // Constraint5nodeHasAddr(destNode,p1.destAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(dest.getZ3Node(), nctx.pf.get("dest").apply(p1)));
+
+ //NON sembrano necessari
+ // this.solver.add(z3.Or(this.ctx.nodeHasAddr(src.getZ3Node(), this.ctx.packet.src(p0)),\
+ // this.ctx.nodeHasAddr(n_0, this.ctx.packet.src(p0)),\
+ // this.ctx.nodeHasAddr(n_1, this.ctx.packet.src(p0))))
+ //this.solver.add(this.ctx.packet.dest(p1) == this.ctx.packet.dest(p0))
+
+ // Constraint6p1.origin == p0.origin
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p1),nctx.pf.get("origin").apply(p0)));
+
+ // Constraint7nodeHasAddr(destNode, p0.destAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(dest.getZ3Node(), nctx.pf.get("dest").apply(p0)));
+
+ result = this.solver.check();
+ model = null;
+ assertions = this.solver.getAssertions();
+ if (result == Status.SATISFIABLE){
+ model = this.solver.getModel();
+ }
+ this.solver.pop();
+ return new IsolationResult(ctx,result, p0, n_0, t_1, t_0, nctx, assertions, model);
+ }
+
+
+
+ /*public IsolationResult CheckIsolationFlowProperty (NetworkObject src, NetworkObject dest){
+assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ solver.push ();
+ addConstraints();
+
+ Expr p = ctx.mkConst("check_isolation_p_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_1 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_2 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+
+ IntExpr t_0 = ctx.mkIntConst("check_isolation_t0_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_1 = ctx.mkIntConst("check_isolation_t1_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_2 = ctx.mkIntConst("check_isolation_t2_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+// Constraint1recv(n_0,destNode,p,t_0)
+ this.solver.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p, t_0));
+
+// Constraint2send(srcNode,n_1,p1,t_1)
+ this.solver.add((BoolExpr)nctx.send.apply(src.getZ3Node(), n_1, p, t_1));
+
+// Constraint3nodeHasAddr(srcNode,p.srcAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(src.getZ3Node(), nctx.pf.get("src").apply(p)));
+
+// Constraint4p.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p), src.getZ3Node()));
+
+
+ Expr p_2 = ctx.mkConst("check_isolation_p_flow_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+
+ // Constraint5there does not exist p_2, n_2, t_2 :
+// send(destNode,n_2,p_2,t_2) &&
+// p_2.srcAddr == p. destAddr &&
+// p_2.srcPort == p.destPort &&
+// p_2.destPort == p.srcPort &&
+// p_2.destt == p.src &&
+// t_2 < t_0
+ this.solver.add(ctx.mkNot(ctx.mkExists(new Expr[]{p_2,n_2,t_2},
+ ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(dest.getZ3Node(), n_2, p_2, t_2),
+ ctx.mkEq(nctx.pf.get("src").apply(p_2), nctx.pf.get("dest").apply(p)),
+ ctx.mkEq(nctx.src_port.apply(p_2), nctx.dest_port.apply(p)),
+ ctx.mkEq(nctx.dest_port.apply(p_2), nctx.src_port.apply(p)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_2), nctx.pf.get("src").apply(p)),
+ ctx.mkLt(t_2,t_0)),1,null,null,null,null)));
+ //System.out.println((ctx.mkNot(ctx.mkExists(new Expr[]{p_2,n_2,t_2},
+ctx.mkAnd(
+(BoolExpr)nctx.send.apply(dest.getZ3Node(), n_2, p_2, t_2),
+ctx.mkEq(nctx.pf.get("src").apply(p_2), nctx.pf.get("dest").apply(p)),
+ctx.mkEq(nctx.src_port.apply(p_2), nctx.dest_port.apply(p)),
+ctx.mkEq(nctx.dest_port.apply(p_2), nctx.src_port.apply(p)),
+ctx.mkEq(nctx.pf.get("dest").apply(p_2), nctx.pf.get("src").apply(p)),
+ctx.mkLt(t_2,t_0)),1,null,null,null,null))));
+
+ result = this.solver.check();
+ model = null;
+ assertions = this.solver.getAssertions();
+ if (result == Status.SATISFIABLE){
+ model = this.solver.getModel();
+ }
+ this.solver.pop();
+ return new IsolationResult(ctx,result, p, n_0, t_1, t_0, nctx, assertions, model);
+}
+
+
+
+ public IsolationResult CheckNodeTraversalProperty (NetworkObject src, NetworkObject dest, NetworkObject node){
+assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ solver.push ();
+ addConstraints();
+
+ Expr p = ctx.mkConst("check_isolation_p_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_1 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_2 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+
+ IntExpr t_0 = ctx.mkIntConst("check_isolation_t0_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_1 = ctx.mkIntConst("check_isolation_t1_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_2 = ctx.mkIntConst("check_isolation_t2_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+// Constraint1recv(n_0,destNode,p,t_0)
+ this.solver.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p, t_0));
+
+// Constraint2send(srcNode,n_1,p1,t_1)
+ this.solver.add((BoolExpr)nctx.send.apply(src.getZ3Node(), n_1, p, t_1));
+
+// Constraint3nodeHasAddr(srcNode,p.srcAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(src.getZ3Node(), nctx.pf.get("src").apply(p)));
+
+// Constraint4p.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p), src.getZ3Node()));
+
+
+//Constraint5there does not exist n_2, t_2 : recv(n_2,node,p,t_2) && t_2 < t_0
+ this.solver.add(ctx.mkNot(ctx.mkExists(new Expr[]{n_2,t_2},
+ ctx.mkAnd(
+ (BoolExpr)nctx.recv.apply(n_2, node.getZ3Node(), p, t_2),
+ ctx.mkLt(t_2,t_0)),1,null,null,null,null)));
+
+//Constraint 6there does not exist n_2, t_2 : send(node,n_2,p,t_2) && t_2 < t_0
+ this.solver.add(ctx.mkNot(ctx.mkExists(new Expr[]{n_2,t_2},
+ctx.mkAnd(
+(BoolExpr)nctx.send.apply(node.getZ3Node(), n_2, p, t_2),
+ctx.mkLt(t_2,t_0)),1,null,null,null,null)));
+
+
+ result = this.solver.check();
+ model = null;
+ assertions = this.solver.getAssertions();
+ if (result == Status.SATISFIABLE){
+ model = this.solver.getModel();
+ }
+ this.solver.pop();
+ return new IsolationResult(ctx,result, p, n_0, t_1, t_0, nctx, assertions, model);
+
+ }
+
+ public IsolationResult CheckLinkTraversalProperty (NetworkObject src, NetworkObject dest, NetworkObject le0, NetworkObject le1){
+assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ solver.push ();
+ addConstraints();
+
+ Expr p = ctx.mkConst("check_isolation_p_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ Expr n_1 =ctx.mkConst("check_isolation_n_1_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+
+ IntExpr t_0 = ctx.mkIntConst("check_isolation_t0_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_1 = ctx.mkIntConst("check_isolation_t1_"+src.getZ3Node()+"_"+dest.getZ3Node());
+ IntExpr t_2 = ctx.mkIntConst("check_isolation_t2_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+// Constraint1recv(n_0,destNode,p,t_0)
+ this.solver.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p, t_0));
+
+// Constraint2send(srcNode,n_1,p,t_1)
+ this.solver.add((BoolExpr)nctx.send.apply(src.getZ3Node(), n_1, p, t_1));
+
+// Constraint3nodeHasAddr(srcNode,p.srcAddr)
+ this.solver.add((BoolExpr)nctx.nodeHasAddr.apply(src.getZ3Node(), nctx.pf.get("src").apply(p)));
+
+// Constraint4p.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p), src.getZ3Node()));
+
+//Constraint5∃ t_1, t_2 :
+ // send(linkNode0,linkNode1,p,t_1) &&
+// recv(linkNode0,linkNode1,p,t_2) &&
+// t_1 < t_0 &&
+// t_2 < t_0
+ this.solver.add(ctx.mkExists(new Expr[]{t_1,t_2},
+ ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(le0.getZ3Node(), le1.getZ3Node(), p, t_1),
+ (BoolExpr)nctx.recv.apply(le0.getZ3Node(), le1.getZ3Node(), p, t_2),
+ ctx.mkLt(t_1,t_0),
+ ctx.mkLt(t_2,t_0)),1,null,null,null,null));
+
+
+ result = this.solver.check();
+ model = null;
+ assertions = this.solver.getAssertions();
+ if (result == Status.SATISFIABLE){
+ model = this.solver.getModel();
+ }
+ this.solver.pop();
+ return new IsolationResult(ctx,result, p, n_0, t_1, t_0, nctx, assertions, model);
+
+ }
+
+ public Result CheckDataIsolationPropertyCore (NetworkObject src, NetworkObject dest){
+ assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ List<BoolExpr> constr = new ArrayList(this.getConstraints());
+
+ Expr p = ctx.mkConst("check_isolation_p_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+
+ IntExpr t = ctx.mkIntConst("check_isolation_t_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+// Constraint1recv(n_0,destNode,p,t)
+ constr.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p, t));
+
+
+// Constraint2p.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p), src.getZ3Node()));
+
+ this.solver.push();
+
+ // Constraint3for each constraint( n -> constraint)
+ ArrayList<BoolExpr> names =new ArrayList<BoolExpr>();
+ for(BoolExpr con : constr){
+ BoolExpr n = ctx.mkBoolConst(""+con);
+ names.add(n);
+ this.solver.add(ctx.mkImplies(n, con));
+ }
+
+ BoolExpr[] nam = new BoolExpr[names.size()];
+ result = this.solver.check(names.toArray(nam));
+ Result ret =null;
+
+ if (result == Status.SATISFIABLE){
+ System.out.println("SAT");
+ ret = new Result(ctx,this.solver.getModel());
+ }else if(result == Status.UNSATISFIABLE){
+ System.out.println("unsat");
+ ret = new Result(ctx,this.solver.getUnsatCore());
+ }
+ this.solver.pop();
+ return ret;
+ }
+
+ public DataIsolationResult CheckDataIsolationProperty(NetworkObject src, NetworkObject dest){
+ assert(net.elements.contains(src));
+ assert(net.elements.contains(dest));
+ solver.push ();
+ addConstraints();
+
+ Expr p = ctx.mkConst("check_isolation_p_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.packet);
+
+ Expr n_0 =ctx.mkConst("check_isolation_n_0_"+src.getZ3Node()+"_"+dest.getZ3Node(), nctx.node);
+ IntExpr t = ctx.mkIntConst("check_isolation_t_"+src.getZ3Node()+"_"+dest.getZ3Node());
+
+// Constraint1recv(n_0,destNode,p,t)
+ this.solver.add((BoolExpr)nctx.recv.apply(n_0, dest.getZ3Node(), p, t));
+
+// Constraint2p.origin == srcNode
+ this.solver.add(ctx.mkEq(nctx.pf.get("origin").apply(p), src.getZ3Node()));
+
+ result = this.solver.check();
+ model = null;
+ assertions = this.solver.getAssertions();
+ if (result == Status.SATISFIABLE){
+ model = this.solver.getModel();
+ }
+ this.solver.pop();
+ return new DataIsolationResult(ctx,result, p, n_0, t, nctx, assertions, model);
+ }
+ */
+
+
+
+ public void addConstraints(){
+ nctx.addConstraints(solver);
+ net.addConstraints(solver);
+ for (NetworkObject el : net.elements)
+ el.addConstraints(solver);
+ }
+
+
+ public List<BoolExpr> getConstraints(){
+ Solver l = ctx.mkSolver();
+ nctx.addConstraints(l);
+ net.addConstraints(l);
+ for (NetworkObject el : net.elements)
+ el.addConstraints(l);
+ return Arrays.asList(l.getAssertions());
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/Core.java b/verigraph/src/it/polito/verigraph/mcnet/components/Core.java
new file mode 100644
index 0000000..3789817
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/Core.java
@@ -0,0 +1,43 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import com.microsoft.z3.Context;
+import com.microsoft.z3.Solver;
+
+/**Core component for everything that matters
+ *
+ *
+ */
+public abstract class Core{
+
+ final int MAX_PORT = 512;
+
+ /**
+ * Base class for all objects in the modeling framework
+ * @param ctx
+ * @param args
+ */
+ public Core(Context ctx, Object[]... args){ // Object[]... -> The nearest way to implement variable length argument lists
+ //in Java, in the most generic way.
+ init(ctx,args);
+ }
+ /**
+ * Override _init for any constructor initialization. Avoids having to explicitly call super.__init__ every Time.class
+ * @param ctx
+ * @param args
+ */
+ abstract protected void init(Context ctx,Object[]... args);
+
+ /**
+ * Add constraints to solver
+ * @param solver
+ */
+ abstract protected void addConstraints(Solver solver);
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/DataIsolationResult.java b/verigraph/src/it/polito/verigraph/mcnet/components/DataIsolationResult.java
new file mode 100644
index 0000000..b56f960
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/DataIsolationResult.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.Model;
+import com.microsoft.z3.Status;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+
+/**Data structure for the response to a check request for data isolation property
+ *
+ */
+public class DataIsolationResult {
+
+ Context ctx;
+ public NetContext nctx;
+ public Status result;
+ public Model model;
+ public Expr violating_packet,last_hop,last_time,t_1;
+ public BoolExpr [] assertions;
+
+ public DataIsolationResult(Context ctx,Status result, Expr violating_packet, Expr last_hop, Expr last_time, NetContext nctx, BoolExpr[] assertions, Model model){
+ this.ctx = ctx;
+ this.result = result;
+ this.violating_packet = violating_packet;
+ this.last_hop = last_hop;
+ this.model = model;
+ this.last_time = last_time;
+ this.assertions = assertions;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/IsolationResult.java b/verigraph/src/it/polito/verigraph/mcnet/components/IsolationResult.java
new file mode 100644
index 0000000..0fe0946
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/IsolationResult.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.Model;
+import com.microsoft.z3.Status;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+
+/**
+ * Data structure for the response to check requests for isolation properties
+ *
+ */
+public class IsolationResult {
+
+ Context ctx;
+ public NetContext nctx;
+ public Status result;
+ public Model model;
+ public Expr violating_packet,last_hop,last_send_time,last_recv_time,t_1;
+ public BoolExpr [] assertions;
+
+ public IsolationResult(Context ctx,Status result, Expr violating_packet, Expr last_hop, Expr last_send_time, Expr last_recv_time,NetContext nctx, BoolExpr[] assertions, Model model){
+ this.ctx = ctx;
+ this.result = result;
+ this.violating_packet = violating_packet;
+ this.last_hop = last_hop;
+ this.model = model;
+ this.last_send_time = last_send_time;
+ this.last_recv_time = last_recv_time;
+ this.assertions = assertions;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/NetContext.java b/verigraph/src/it/polito/verigraph/mcnet/components/NetContext.java
new file mode 100644
index 0000000..f0db902
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/NetContext.java
@@ -0,0 +1,365 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Constructor;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.DatatypeSort;
+import com.microsoft.z3.EnumSort;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Sort;
+import it.polito.verigraph.mcnet.netobjs.DumbNode;
+import it.polito.verigraph.mcnet.components.Core;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/**
+ * Basic fields and other things required for model checking.
+ *
+ */
+public class NetContext extends Core{
+
+
+ List<BoolExpr> constraints;
+ List<Core> policies;
+
+ public HashMap<String,NetworkObject> nm; //list of nodes, callable by node name
+ public HashMap<String,DatatypeExpr> am; // list of addresses, callable by address name
+ public HashMap<String,FuncDecl> pf;
+ Context ctx;
+ public EnumSort node,address;
+ public FuncDecl src_port,dest_port,nodeHasAddr,addrToNode,send,recv;
+ public DatatypeSort packet;
+
+ /* Constants definition
+ - used in the packet proto field */
+ public final int HTTP_REQUEST = 1;
+ public final int HTTP_RESPONSE = 2;
+ public final int POP3_REQUEST = 3;
+ public final int POP3_RESPONSE = 4;
+
+ /**
+ * Context for all of the rest that follows. Every network needs one of these
+ * @param ctx
+ * @param args
+ */
+ public NetContext(Context ctx,Object[]... args ){
+ super(ctx,args);
+
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ nm = new HashMap<String,NetworkObject>(); //list of nodes, callable by node name
+ am = new HashMap<String,DatatypeExpr>(); // list of addresses, callable by address name
+ pf= new HashMap<String,FuncDecl>() ;
+
+
+ mkTypes((String[])args[0],(String[])args[1]);
+
+ constraints = new ArrayList<BoolExpr>();
+ policies = new ArrayList<Core>();
+
+ baseCondition();
+
+ }
+
+ /**
+ * A policy is a collection of shared algorithms or functions used by multiple components
+ * (for instance compression or DPI policies etc).
+ * @param policy
+ */
+ public void AddPolicy (NetworkObject policy){
+ policies.add(policy);
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ for (Core policy : policies){
+ policy.addConstraints(solver);
+ }
+ }
+
+ private void mkTypes (String[] nodes, String[] addresses){
+ //Nodes in a network
+ node = ctx.mkEnumSort("Node", nodes);
+
+ for(int i=0;i<node.getConsts().length;i++){
+ DatatypeExpr fd = (DatatypeExpr)node.getConst(i);
+ DumbNode dn =new DumbNode(ctx,new Object[]{fd});
+
+ nm.put(fd.toString(),dn);
+ }
+
+ //Addresses for this network
+ String[] new_addr = new String[addresses.length+1];
+ for(int k=0;k<addresses.length;k++)
+ new_addr[k] = addresses[k];
+
+ new_addr[new_addr.length-1] = "null";
+ address = ctx.mkEnumSort("Address", new_addr);
+ for(int i=0;i<address.getConsts().length;i++){
+ DatatypeExpr fd = (DatatypeExpr)address.getConst(i);
+
+
+ am.put(fd.toString(),fd);
+ }
+
+ // Type for packets, contains (some of these are currently represented as relations):
+ // - src: Source address
+ // - dest: Destination address
+ // - origin: Node where the data originated. (Node)
+ // - body: Packet contents. (Integer)
+ // - seq: Sequence number for packets. (Integer)
+ // - options: A representation for IP options. (Integer)
+
+ String[] fieldNames = new String[]{
+ "src","dest","inner_src","inner_dest","origin","orig_body","body","seq","proto","emailFrom","url","options","encrypted"};
+ Sort[] srt = new Sort[]{
+ address,address,address,address,node,ctx.mkIntSort(),ctx.mkIntSort(),ctx.mkIntSort(),
+ ctx.mkIntSort(),ctx.mkIntSort(),ctx.mkIntSort(),ctx.mkIntSort(),ctx.mkBoolSort()};
+ Constructor packetcon = ctx.mkConstructor("packet", "is_packet", fieldNames, srt, null);
+ packet = ctx.mkDatatypeSort("packet", new Constructor[] {packetcon});
+
+
+ for(int i=0;i<fieldNames.length;i++){
+ pf.put(fieldNames[i], packet.getAccessors()[0][i]); // pf to get packet's function declarations by name
+ }
+
+
+ src_port = ctx.mkFuncDecl("sport", packet, ctx.mkIntSort());
+ dest_port = ctx.mkFuncDecl("dport", packet, ctx.mkIntSort());
+
+ // Some commonly used relations
+
+ // nodeHasAddr: node -> address -> boolean
+
+ /* OUTPUT:
+ * declare-fun nodeHasAddr (Node Address) Bool
+ * declare-fun addrToNode (Address) Node
+ */
+
+ nodeHasAddr = ctx.mkFuncDecl("nodeHasAddr", new Sort[]{node, address},ctx.mkBoolSort());
+
+
+ // addrToNode: address -> node
+ addrToNode = ctx.mkFuncDecl("addrToNode", address, node);
+
+
+ // Send and receive both have the form:
+ // source-> destination -> packet-> int-> bool
+
+
+ /*OUTPUT:
+ * declare-fun send (Node Node packet Int) Bool
+ * declare-fun recv(Node Node paket Int) Bool
+ */
+
+
+ // send: node -> node -> packet-> int-> bool
+ send = ctx.mkFuncDecl("send", new Sort[]{ node, node, packet, ctx.mkIntSort()},ctx.mkBoolSort());
+
+
+ // recv: node -> node -> packet-> int-> bool
+ recv = ctx.mkFuncDecl("recv", new Sort[]{ node, node, packet, ctx.mkIntSort()},ctx.mkBoolSort());
+
+ }
+
+ /**
+ * Set up base conditions for the network
+ */
+ private void baseCondition(){
+ // Basic constraints for the overall model
+ Expr n_0 = ctx.mkConst("ctx_base_n_0", node);
+ Expr n_1 = ctx.mkConst("ctx_base_n_1", node);
+ Expr n_2 = ctx.mkConst("ctx_base_n_2", node);
+ Expr p_0 = ctx.mkConst("ctx_base_p_0", packet);
+ Expr p_1 = ctx.mkConst("ctx_base_p_1", packet);
+ IntExpr t_0 = ctx.mkIntConst("ctx_base_t_0");
+ IntExpr t_1 = ctx.mkIntConst("ctx_base_t_1");
+
+ // Constraint1 send(n_0, n_1, p_0, t_0) -> n_0 != n_1
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)send.apply(n_0, n_1, p_0, t_0),ctx.mkNot(ctx.mkEq( n_0, n_1))),1,null,null,null,null));
+
+ // Constraint2 recv(n_0, n_1, p_0, t_0) -> n_0 != n_1
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),ctx.mkNot(ctx.mkEq( n_0, n_1))),1,null,null,null,null));
+
+ // Constraint3 send(n_0, n_1, p_0, t_0) -> p_0.src != p_0.dest
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkNot(ctx.mkEq( pf.get("src").apply(p_0), pf.get("dest").apply(p_0)))),1,null,null,null,null));
+
+ // Constraint4 recv(n_0, n_1, p_0, t_0) -> p_0.src != p_0.dest
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkNot(ctx.mkEq(pf.get("src").apply(p_0),pf.get("dest").apply(p_0)))),1,null,null,null,null));
+
+ // Constraint5 recv(n_0, n_1, p, t_0) -> send(n_0, n_1, p, t_1) && t_1 < t_0
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkExists(new Expr[]{t_1},
+ ctx.mkAnd((BoolExpr)send.apply(n_0, n_1, p_0, t_1),
+ ctx.mkLt(t_1, t_0)),1,null,null,null,null)),1,null,null,null,null));
+
+ // Constraint6 send(n_0, n_1, p, t_0) -> p.src_port > 0 && p.dest_port < MAX_PORT
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkAnd( ctx.mkGe((IntExpr)src_port.apply(p_0),(IntExpr)ctx.mkInt(0)),
+ ctx.mkLt((IntExpr)src_port.apply(p_0),(IntExpr) ctx.mkInt(MAX_PORT)))),1,null,null,null,null));
+
+ // Constraint7 recv(n_0, n_1, p, t_0) -> p.src_port > 0 && p.dest_port < MAX_PORT
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkAnd( ctx.mkGe((IntExpr)dest_port.apply(p_0),(IntExpr)ctx.mkInt(0)),
+ ctx.mkLt((IntExpr)dest_port.apply(p_0),(IntExpr) ctx.mkInt(MAX_PORT)))),1,null,null,null,null));
+
+ // Constraint8 recv(n_0, n_1, p_0, t_0) -> t_0 > 0
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkGt(t_0,ctx.mkInt(0))),1,null,null,null,null));
+
+ // Constraint9 send(n_0, n_1, p_0, t_0) -> t_0 > 0
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkGt(t_0,ctx.mkInt(0))),1,null,null,null,null));
+
+ // Extra constriants for supporting the VPN gateway
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkNot(ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.am.get("null")))),
+ ctx.mkNot(ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0)))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.am.get("null"))),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ ctx.mkEq(this.pf.get("inner_dest").apply(p_0), this.am.get("null"))),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkNot(ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.am.get("null")))),
+ ctx.mkNot(ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0)))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.am.get("null"))),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)recv.apply(n_0, n_1, p_0, t_0),
+ ctx.mkEq(this.pf.get("inner_dest").apply(p_0), this.am.get("null"))),
+ ctx.mkEq(this.pf.get("inner_src").apply(p_0), this.pf.get("inner_dest").apply(p_0))),1,null,null,null,null));
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, n_1, p_0, t_0, n_2, p_1, t_1},
+ ctx.mkImplies(
+ ctx.mkAnd(
+ ctx.mkLt(t_1, t_0),
+ (BoolExpr)send.apply(n_0, n_1, p_0, t_0),
+ (BoolExpr)this.pf.get("encrypted").apply(p_1),
+ (BoolExpr)recv.apply(n_2, n_0, p_1, t_1),
+ (BoolExpr)this.pf.get("encrypted").apply(p_0)),
+ ctx.mkAnd(
+ ctx.mkEq(this.pf.get("inner_src").apply(p_1), this.pf.get("inner_src").apply(p_0)),
+ ctx.mkEq(this.pf.get("inner_dest").apply(p_1), this.pf.get("inner_dest").apply(p_0)),
+ ctx.mkEq(this.pf.get("origin").apply(p_1), this.pf.get("origin").apply(p_0)),
+ ctx.mkEq(this.pf.get("orig_body").apply(p_1), this.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(this.pf.get("body").apply(p_1), this.pf.get("body").apply(p_0)),
+ ctx.mkEq(this.pf.get("seq").apply(p_1), this.pf.get("seq").apply(p_0)),
+ ctx.mkEq(this.pf.get("proto").apply(p_1), this.pf.get("proto").apply(p_0)),
+ ctx.mkEq(this.pf.get("emailFrom").apply(p_1), this.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(this.pf.get("url").apply(p_1), this.pf.get("url").apply(p_0)),
+ ctx.mkEq(this.pf.get("options").apply(p_1), this.pf.get("options").apply(p_0)))),1,null,null,null,null)
+ );
+
+
+ }
+
+ /**
+ * Two packets have equal headers
+ * @param p1
+ * @param p2
+ * @return
+ */
+ public BoolExpr PacketsHeadersEqual(Expr p1, Expr p2){
+ return ctx.mkAnd(new BoolExpr[]{
+ ctx.mkEq(pf.get("src").apply(p1), pf.get("src").apply(p2)),
+ ctx.mkEq(pf.get("dest").apply(p1), pf.get("dest").apply(p2)),
+ ctx.mkEq(pf.get("origin").apply(p1), pf.get("origin").apply(p2)),
+ ctx.mkEq(pf.get("seq").apply(p1), pf.get("seq").apply(p2)),
+ ctx.mkEq(src_port.apply(p1),src_port.apply(p2)),
+ ctx.mkEq(dest_port.apply(p1), dest_port.apply(p2)),
+ ctx.mkEq(pf.get("options").apply(p1),pf.get("options").apply(p2))});
+ }
+
+ /**
+ * Two packets have equal bodies
+ * @param p1
+ * @param p2
+ * @return
+ */
+ public BoolExpr PacketContentEqual(Expr p1, Expr p2){
+ return ctx.mkEq(pf.get("body").apply(p1), pf.get("body").apply(p2));
+ }
+
+
+ /* seems to be useless
+ *
+public Function failurePredicate (NetContext context)
+{
+ return (NetworkObject node) -> ctx.mkNot(context.failed (node.z3Node));
+
+}*/
+
+ public BoolExpr destAddrPredicate (Expr p, DatatypeExpr address){
+ return ctx.mkEq(pf.get("dest").apply(p),address);
+ }
+
+ public BoolExpr srcAddrPredicate (Expr p, DatatypeExpr address){
+ return ctx.mkEq(pf.get("src").apply(p),address);
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/Network.java b/verigraph/src/it/polito/verigraph/mcnet/components/Network.java
new file mode 100644
index 0000000..df1cece
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/Network.java
@@ -0,0 +1,314 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Z3Exception;
+import it.polito.verigraph.mcnet.components.Core;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+import it.polito.verigraph.mcnet.components.Tuple;
+
+/**Model for a network, encompasses routing and wiring
+ *
+ *
+ */
+public class Network extends Core{
+
+ Context ctx;
+ NetContext nctx;
+ List<BoolExpr> constraints;
+ public List<NetworkObject> elements;
+
+
+
+ public Network(Context ctx,Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ this.nctx = (NetContext) args[0][0];
+ constraints = new ArrayList<BoolExpr>();
+ elements = new ArrayList<NetworkObject>();
+
+ }
+
+ /**Composes the network linking the configured network objects
+ *
+ * @param elements
+ */
+ public void attach (NetworkObject ... elements){
+ for(NetworkObject el : elements)
+ this.elements.add(el);
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ try {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ } catch (Z3Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Specify host to address mapping.
+ * Handles the case in which we have more than one address for a node
+ * @param addrmap
+ */
+ public void setAddressMappings(ArrayList<Tuple<NetworkObject,ArrayList<DatatypeExpr>>> addrmap){
+ // Set address mapping for nodes.
+ for (Tuple<NetworkObject,ArrayList<DatatypeExpr>> entry : addrmap) {
+ NetworkObject node=entry._1;
+ List<DatatypeExpr> addr=entry._2;
+ Expr a_0 = ctx.mkConst(node+"_address_mapping_a_0",nctx.address);
+ ArrayList<BoolExpr> or_clause = new ArrayList<BoolExpr>();
+
+ // Constraint 1 addrToNode(foreach ad in addr) = node
+ for (DatatypeExpr ad : addr){
+ constraints.add(ctx.mkEq(nctx.addrToNode.apply(ad), node.getZ3Node()));
+ or_clause.add(ctx.mkEq(a_0,ad));
+
+ // System.out.println("Constraints mapping: " + (ctx.mkEq(nctx.addrToNode.apply(ad), node.getZ3Node())));
+
+ }
+ BoolExpr[] orClause = new BoolExpr[or_clause.size()];
+
+ // Constraint 2nodeHasAddr(node, a_0) == Or(foreach ad in addr (a_0 == ad))
+ // Note we need the iff here to make sure that we set nodeHasAddr to false
+ // for other addresses.
+ constraints.add(ctx.mkForall(new Expr[]{a_0},
+ ctx.mkEq(ctx.mkOr(or_clause.toArray(orClause)), nctx.nodeHasAddr.apply(node.getZ3Node(), a_0)),1,null,null,null,null));
+
+
+ }
+ //System.out.println("Constraints mapping: " + constraints);
+ }
+
+
+
+ /**
+ * Don't forward packets addressed to node
+ * @param node
+ */
+ public void saneSend(NetworkObject node){
+ Expr n_0 = ctx.mkConst(node+"_saneSend_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst(node+"_saneSend_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst(node+"_saneSend_t_0");
+ // Constant: node
+ //Constraint send(node, n_0, p, t_0) -> !nodeHasAddr(node, p.dest)
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node.getZ3Node(),n_0, p_0, t_0),
+ ctx.mkNot((BoolExpr)nctx.nodeHasAddr.apply( node.getZ3Node(),
+ nctx.pf.get("dest").apply(p_0)))),1,null,null,null,null));
+ }
+
+ /**
+ * Node sends all traffic through gateway
+ * @param node
+ * @param gateway
+ */
+ public void setGateway (NetworkObject node, NetworkObject gateway){
+ // SetGateway(self, node, gateway): All packets from node are sent through gateway
+ Expr n_0 = ctx.mkConst(node+"_gateway_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst(node+"_gateway_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst(node+"_gateway_t_0");
+
+ //Constraint send(node, n_0, p_0, t_0) -> n_0 = gateway
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.send.apply(node.getZ3Node(), n_0, p_0, t_0),
+ ctx.mkEq(n_0,gateway.getZ3Node())),1,null,null,null,null));
+
+ // constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0, node.getZ3Node(), p_0, t_0),
+ // ctx.mkEq(n_0,gateway.getZ3Node())),1,null,null,null,null));
+ }
+
+ /**
+ * Assigns a specific routing table to a network object. Routing entries in the form: address -> node
+ * @param node
+ * @param routing_table
+ */
+ public void routingTable (NetworkObject node,ArrayList<Tuple<DatatypeExpr,NetworkObject>> routing_table){
+ compositionPolicy(node,routing_table);
+ }
+
+ /**
+ * Composition policies steer packets between middleboxes.
+ * @param node
+ * @param policy
+ */
+ public void compositionPolicy (NetworkObject node,ArrayList<Tuple<DatatypeExpr,NetworkObject>> policy){
+ //Policy is of the form predicate -> node
+ Expr p_0 = ctx.mkConst(node+"_composition_p_0", nctx.packet);
+ Expr n_0 = ctx.mkConst(node+"_composition_n_0", nctx.node);
+ Expr t_0 = ctx.mkIntConst(node+"_composition_t_0");
+
+ HashMap<String,ArrayList<BoolExpr>> collected = new HashMap<String,ArrayList<BoolExpr>>();
+ HashMap<String,NetworkObject> node_dict = new HashMap<String,NetworkObject>();
+ BoolExpr predicates;
+ for(int y=0;y<policy.size();y++){
+ Tuple<DatatypeExpr,NetworkObject> tp = policy.get(y);
+ if(collected.containsKey(""+tp._2)) collected.get(""+tp._2).add(nctx.destAddrPredicate(p_0,tp._1));
+ else{
+ ArrayList<BoolExpr> alb = new ArrayList<BoolExpr>();
+ alb.add(nctx.destAddrPredicate(p_0,tp._1));
+ collected.put(""+tp._2,alb);
+
+ }
+ node_dict.put(""+tp._2, tp._2);
+
+ }
+ // System.out.println("collected: " + collected);
+
+ //Constraintforeach rtAddr,rtNode in rt( send(node, n_0, p_0, t_0) &&
+ //Or(foreach rtAddr in rt destAddrPredicate(p_0,rtAddr)) -> n_0 == rtNode )
+ for (Map.Entry<String,ArrayList<BoolExpr>> entry : collected.entrySet()) {
+ BoolExpr[] pred = new BoolExpr[entry.getValue().size()];
+ predicates = ctx.mkOr(entry.getValue().toArray(pred));
+
+ constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(node.getZ3Node(), n_0, p_0, t_0), predicates),
+ ctx.mkEq(n_0, node_dict.get(entry.getKey()).getZ3Node())),1,null,null,null,null));
+ /*System.out.println("cnstraints: " + (ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(node.getZ3Node(), n_0, p_0, t_0), predicates),
+ ctx.mkEq(n_0, node_dict.get(entry.getKey()).getZ3Node())),1,null,null,null,null)));*/
+ }
+ //System.out.println("constraints composition policy: " + constraints);
+
+ }
+
+ /**
+ * Routing entries are in the form: address -> node. Also allows packet to be sent to another box for further processing
+ * @param node
+ * @param routing_table
+ * @param shunt_node
+ */
+ public void routingTableShunt (NetworkObject node,ArrayList<Tuple<DatatypeExpr,NetworkObject>> routing_table,NetworkObject shunt_node){
+ compositionPolicyShunt(node,routing_table,shunt_node);
+ }
+
+ /**
+ * Composition policies steer packets between middleboxes.Policy is in the form: predicate -> node
+ * @param node
+ * @param routing_table
+ * @param shunt_node
+ */
+ public void compositionPolicyShunt (NetworkObject node,ArrayList<Tuple<DatatypeExpr,NetworkObject>> routing_table,NetworkObject shunt_node){
+ Expr p_0 = ctx.mkConst(node+"_composition_p_0", nctx.packet);
+ Expr n_0 = ctx.mkConst(node+"_composition_n_0", nctx.node);
+ Expr t_0 = ctx.mkIntConst(node+"_composition_t_0");
+
+ HashMap<String,ArrayList<BoolExpr>> collected = new HashMap<String,ArrayList<BoolExpr>>();
+ HashMap<String,NetworkObject> node_dict = new HashMap<String,NetworkObject>();
+ BoolExpr predicates;
+ for(int y=0;y<routing_table.size();y++){
+ Tuple<DatatypeExpr,NetworkObject> tp = routing_table.get(y);
+ if(collected.containsKey(""+tp._2)) collected.get(""+tp._2).add(nctx.destAddrPredicate(p_0,tp._1));
+ else{
+ ArrayList<BoolExpr> alb = new ArrayList<BoolExpr>();
+ alb.add(nctx.destAddrPredicate(p_0,tp._1));
+ collected.put(""+tp._2,alb);
+ }
+ node_dict.put(""+tp._2, tp._2);
+ }
+
+ //Constraintforeach rtAddr,rtNode in rt( send(node, n_0, p_0, t_0) &&
+ //Or(foreach rtAddr in rt destAddrPredicate(p_0,rtAddr)) -> n_0 == rtNode )
+ for (Map.Entry<String,ArrayList<BoolExpr>> entry : collected.entrySet()) {
+ BoolExpr[] pred = new BoolExpr[entry.getValue().size()];
+ predicates = ctx.mkOr(entry.getValue().toArray(pred));
+
+ constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(node.getZ3Node(), n_0, p_0, t_0), predicates),
+ ctx.mkOr(ctx.mkEq(n_0, node_dict.get(entry.getKey()).getZ3Node()),ctx.mkEq(n_0, shunt_node.getZ3Node()))),1,null,null,null,null));
+ }
+
+ }
+
+ // public void SimpleIsolation (NetworkObject node, ArrayList<DatatypeExpr> addresses){
+ // Expr p = ctx.mkConst(node+"_s_p", nctx.packet);
+ // Expr n = ctx.mkConst(node+"_s_n", nctx.node);
+ // IntExpr t = ctx.mkInt(node+"_s_t");
+ //
+ // BoolExpr[] a_pred= new BoolExpr[addresses.size()];
+ // for(int y=0;y<addresses.size();y++){
+ // DatatypeExpr de = addresses.get(y);
+ // a_pred[y] = ctx.mkOr(ctx.mkEq(nctx.pf.get("src").apply(p), de),ctx.mkEq(nctx.pf.get("dest").apply(p), de));
+ // }
+ //
+ // constraints.add(
+ // ctx.mkForall(new Expr[]{p, n, t},
+ // ctx.mkImplies((BoolExpr)nctx.recv.apply(n, node.getZ3Node(), p, t),
+ // ctx.mkOr(a_pred)),1,null,null,null,null));
+ // constraints.add(
+ // ctx.mkForall(new Expr[]{p, n, t},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(node.getZ3Node(), n, p, t),
+ // ctx.mkOr(a_pred)),1,null,null,null,null));
+ // }
+
+
+ /**
+ * Set isolation constraints on a node.
+ * Doesn't need to be set but useful when interfering policies are in play.
+ * @param node
+ * @param adjacencies
+ *
+ */
+ public void SetIsolationConstraint ( NetworkObject node, ArrayList<NetworkObject> adjacencies){
+
+ Expr n_0 = ctx.mkConst(node+"_isolation_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst(node+"_isolation_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkInt(node+"_isolation_t_0");
+
+ BoolExpr[] adj = new BoolExpr[adjacencies.size()];
+ for(int y=0;y<adjacencies.size();y++){
+ NetworkObject no = adjacencies.get(y);
+ adj[y] = ctx.mkEq(n_0,no.getZ3Node());
+ }
+ BoolExpr clause = ctx.mkOr(adj);
+
+ constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node.getZ3Node(), n_0, p_0, t_0),
+ clause),1,null,null,null,null));
+ constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0, node.getZ3Node(), p_0, t_0),
+ clause),1,null,null,null,null));
+ }
+
+ /**
+ * Return all currently attached endhosts
+ * @return NetworkObject
+ */
+ public List<String> EndHosts(){
+ List<String> att_nos = new ArrayList<String>();
+ for(NetworkObject el :elements){
+ if(el.isEndHost){
+ //System.out.println("el: "+el);
+ att_nos.add(el.getZ3Node().toString());
+ }
+ }
+ return att_nos;
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/NetworkObject.java b/verigraph/src/it/polito/verigraph/mcnet/components/NetworkObject.java
new file mode 100644
index 0000000..0438b04
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/NetworkObject.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+
+import it.polito.verigraph.mcnet.components.Core;
+
+/** Represents a generic network object.
+ *
+ *
+ */
+public abstract class NetworkObject extends Core{
+
+ public NetworkObject(Context ctx,Object[]... args) {
+ super(ctx,args);
+ }
+
+ protected DatatypeExpr z3Node;
+ protected boolean isEndHost;
+ /**
+ * Get a reference to the z3 node this class wraps around
+ * @return
+ */
+ abstract public DatatypeExpr getZ3Node();
+
+ public String toString(){
+ return z3Node.toString();
+ }
+
+ //There is probably an error: z3Node.hashCode = 0 because AST.hashCode() has always hash=0
+ /*public int hashCode(){
+ return z3Node.hashCode();
+}*/
+
+ /**
+ * A simple way to determine the set of endhosts
+ * @return
+ */
+ public boolean isEndHost(){
+ return isEndHost;
+ }
+
+ /**
+ * Wrap methods to set policy
+ * @param policy
+ * @throws UnsupportedOperationException
+ */
+ void setPolicy (Object policy) throws UnsupportedOperationException{
+ throw new UnsupportedOperationException();
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/Result.java b/verigraph/src/it/polito/verigraph/mcnet/components/Result.java
new file mode 100644
index 0000000..3bc6512
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/Result.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.Model;
+
+/**Data structure for the core of the response to a check request for data isolation property
+ *
+ */
+public class Result {
+ Context ctx;
+ public Model model;
+ public BoolExpr[] unsat_core;
+
+ /**
+ *
+ * @param ctx
+ * @param model
+ */
+ public Result(Context ctx, Model model){
+ this.ctx = ctx;
+ this.model = model;
+ }
+
+ /**
+ *
+ * @param ctx
+ * @param unsat_core
+ */
+ public Result(Context ctx, BoolExpr[] unsat_core){
+ this.ctx = ctx;
+ this.unsat_core = unsat_core;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/components/Tuple.java b/verigraph/src/it/polito/verigraph/mcnet/components/Tuple.java
new file mode 100644
index 0000000..a6c3ece
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/components/Tuple.java
@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.components;
+
+/** A data structure which is an utility to make a generic couple of objects with different types in Java
+ *
+ */
+public class Tuple<T, U> {
+ public final T _1;
+ public final U _2;
+
+
+ public Tuple(T arg1,U arg2) {
+ super();
+ this._1 = arg1;
+ this._2 = arg2;
+ }
+
+ public Tuple(){
+ this._1 = null;
+ this._2 = null;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("(%s, %s)", _1, _2);
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/AclFirewall.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/AclFirewall.java
new file mode 100644
index 0000000..63b2c6d
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/AclFirewall.java
@@ -0,0 +1,123 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Sort;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+import it.polito.verigraph.mcnet.components.Tuple;
+
+/** Represents a Firewall with the associated Access Control List
+ *
+ */
+public class AclFirewall extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr fw;
+ ArrayList<Tuple<DatatypeExpr,DatatypeExpr>> acls;
+ Network net;
+ NetContext nctx;
+ FuncDecl acl_func;
+
+ public AclFirewall(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ acls = new ArrayList<Tuple<DatatypeExpr,DatatypeExpr>>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ fw = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ net.saneSend(this);
+ firewallSendRules();
+
+ }
+
+ /**
+ * Wrap add acls
+ * @param policy
+ */
+ public void setPolicy(ArrayList<Tuple<DatatypeExpr, DatatypeExpr>> policy){
+ addAcls(policy);
+ }
+
+ public void addAcls(ArrayList<Tuple<DatatypeExpr,DatatypeExpr>> acls){
+ this.acls.addAll(acls);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return fw;
+ }
+
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ aclConstraints(solver);
+ }
+
+ private void firewallSendRules (){
+ Expr p_0 = ctx.mkConst(fw+"_firewall_send_p_0", nctx.packet);
+ Expr n_0 = ctx.mkConst(fw+"_firewall_send_n_0", nctx.node);
+ Expr n_1 = ctx.mkConst(fw+"_firewall_send_n_1", nctx.node);
+ IntExpr t_0 = ctx.mkIntConst(fw+"_firewall_send_t_0");
+ IntExpr t_1 = ctx.mkIntConst(fw+"_firewall_send_t_1");
+ acl_func = ctx.mkFuncDecl(fw+"_acl_func", new Sort[]{nctx.address, nctx.address},ctx.mkBoolSort());
+
+ //Constraint1send(fw, n_0, p, t_0) -> (exist n_1,t_1 : (recv(n_1, fw, p, t_1) &&
+ // t_1 < t_0 && !acl_func(p.src,p.dest))
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.send.apply(new Expr[]{ fw, n_0, p_0, t_0}),
+ ctx.mkExists(new Expr[]{t_1},
+ ctx.mkAnd(ctx.mkLt(t_1,t_0),
+ ctx.mkExists(new Expr[]{n_1},
+ nctx.recv.apply(n_1, fw, p_0, t_1),1,null,null,null,null),
+ ctx.mkNot((BoolExpr)acl_func.apply(nctx.pf.get("src").apply(p_0), nctx.pf.get("dest").apply(p_0)))),1,null,null,null,null)),1,null,null,null,null));
+
+ }
+
+ private void aclConstraints(Solver solver){
+ if (acls.size() == 0)
+ return;
+ Expr a_0 = ctx.mkConst(fw+"_firewall_acl_a_0", nctx.address);
+ Expr a_1 = ctx.mkConst(fw+"_firewall_acl_a_1", nctx.address);
+ BoolExpr[] acl_map = new BoolExpr[acls.size()];
+ for(int y=0;y<acls.size();y++){
+ Tuple<DatatypeExpr,DatatypeExpr> tp = acls.get(y);
+ acl_map[y] = ctx.mkOr(ctx.mkAnd(ctx.mkEq(a_0,tp._1),ctx.mkEq(a_1,tp._2)), ctx.mkAnd(ctx.mkEq(a_0,tp._2),ctx.mkEq(a_1,tp._1)));
+ }
+ //Constraint2acl_func(a_0,a_1) == or(foreach ip1,ip2 in acl_map ((a_0 == ip1 && a_1 == ip2)||(a_0 == ip2 && a_1 == ip1)))
+ solver.add(ctx.mkForall(new Expr[]{a_0, a_1},
+ ctx.mkEq(
+ acl_func.apply(a_0, a_1),
+ ctx.mkOr(acl_map)),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/DumbNode.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/DumbNode.java
new file mode 100644
index 0000000..02f51e4
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/DumbNode.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/**
+ * This is just a wrapper around z3 instances. The idea is that by using this we perhaps need to have
+ * fewer (or no) ifs to deal with the case where we don't instantiate an object for a node
+ *
+ */
+public class DumbNode extends NetworkObject {
+ public DumbNode(Context ctx, Object[]... args){
+ super(ctx,args);
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ return;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ isEndHost=true;
+ this.z3Node = (DatatypeExpr)args[0][0];
+ }
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return z3Node;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/EndHost.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/EndHost.java
new file mode 100644
index 0000000..5eee644
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/EndHost.java
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**
+ * End host network objects
+ *
+ *
+ */
+public class EndHost extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr node;
+ Network net;
+ NetContext nctx;
+
+ public EndHost(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=true;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ node = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ endHostRules();
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return node;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void endHostRules (){
+ Expr n_0 = ctx.mkConst("eh_"+node+"_n_0", nctx.node);
+ IntExpr t_0 = ctx.mkIntConst("eh_"+node+"_t_0");
+ Expr p_0 = ctx.mkConst("eh_"+node+"_p_0", nctx.packet);
+
+ //Constraint1send(node, n_0, p, t_0) -> nodeHasAddr(node,p.src)
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.send.apply(new Expr[]{ node, n_0, p_0, t_0}),
+ (BoolExpr)nctx.nodeHasAddr.apply(new Expr[]{node, nctx.pf.get("src").apply(p_0)})),1,null,null,null,null));
+ //Constraint2send(node, n_0, p, t_0) -> p.origin == node
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.send.apply(new Expr[]{ node, n_0, p_0, t_0}),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),node)),1,null,null,null,null));
+ //Constraint3 send(node, n_0, p, t_0) -> p.orig_body == p.body
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.send.apply(new Expr[]{ node, n_0, p_0, t_0}),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),1,null,null,null,null));
+ //Constraint4recv(n_0, node, p, t_0) -> nodeHasAddr(node,p.dest)
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(
+ (BoolExpr)nctx.recv.apply(new Expr[]{ n_0, node, p_0, t_0}),
+ (BoolExpr)nctx.nodeHasAddr.apply(new Expr[]{node, nctx.pf.get("dest").apply(p_0)})),1,null,null,null,null));
+
+ // Just a try: here we state that an endhost is not able to issue a HTTP response traffic
+ // See PolitoCache.py model for constants definition (2 means HTTP_RESPONSE, 1 means HTTP_REQUEST)
+ // constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(node, n_0, p_0, t_0),
+ // ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(1))),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PacketModel.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PacketModel.java
new file mode 100644
index 0000000..0fe08c9
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PacketModel.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import com.microsoft.z3.DatatypeExpr;
+
+/*
+ * Fields that can be configured -> "dest","body","seq","proto","emailFrom","url","options"
+ */
+public class PacketModel {
+
+ private DatatypeExpr ip_dest;
+ private Integer body;
+ private Integer seq;
+ private Integer proto;
+ private Integer emailFrom;
+ private Integer url;
+ private Integer options;
+
+ public DatatypeExpr getIp_dest() {
+ return ip_dest;
+ }
+ public void setIp_dest(DatatypeExpr ip_dest) {
+ this.ip_dest = ip_dest;
+ }
+ public Integer getBody() {
+ return body;
+ }
+ public void setBody(Integer body) {
+ this.body = body;
+ }
+ public Integer getSeq() {
+ return seq;
+ }
+ public void setSeq(Integer seq) {
+ this.seq = seq;
+ }
+ public Integer getProto() {
+ return proto;
+ }
+ public void setProto(Integer proto) {
+ this.proto = proto;
+ }
+ public Integer getEmailFrom() {
+ return emailFrom;
+ }
+ public void setEmailFrom(Integer emailFrom) {
+ this.emailFrom = emailFrom;
+ }
+ public Integer getUrl() {
+ return url;
+ }
+ public void setUrl(Integer url) {
+ this.url = url;
+ }
+ public Integer getOptions() {
+ return options;
+ }
+ public void setOptions(Integer options) {
+ this.options = options;
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoAntispam.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoAntispam.java
new file mode 100644
index 0000000..6a5cab0
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoAntispam.java
@@ -0,0 +1,120 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/**
+ * Model of an anti-spam node
+ *
+ */
+public class PolitoAntispam extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoAntispam;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoAntispam(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoAntispam = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ //net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoAntispam;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void installAntispam (int[] blackList){
+ Expr n_0 = ctx.mkConst(politoAntispam+"_n_0", nctx.node);
+ Expr n_1 = ctx.mkConst(politoAntispam+"_n_1", nctx.node);
+ Expr p_0 = ctx.mkConst(politoAntispam+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst(politoAntispam+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst(politoAntispam+"_t_1");
+ IntExpr ef_0 = ctx.mkIntConst(politoAntispam+"_ef_0");
+
+ isInBlacklist = ctx.mkFuncDecl(politoAntispam+"_isInBlacklist", ctx.mkIntSort(), ctx.mkBoolSort());
+ BoolExpr[] blConstraint = new BoolExpr[blackList.length];
+ if(blackList.length != 0){
+ for (int i=0;i<blackList.length;i++)
+ blConstraint[i]=(ctx.mkEq(ef_0,ctx.mkInt(blackList[i])));
+ //Constraint1aif(isInBlackList(ef_0) == or(for bl in blacklist (ef_0==bl)) ? true : false
+ constraints.add(ctx.mkForall(new Expr[]{ef_0}, ctx.mkIff((BoolExpr)isInBlacklist.apply(ef_0),ctx.mkOr(blConstraint)),1,null,null,null,null));
+ }else{
+ //Constraint1bisInblackList(ef_0) == false
+ constraints.add(ctx.mkForall(new Expr[]{ef_0}, ctx.mkEq((BoolExpr)isInBlacklist.apply(ef_0), ctx.mkBool(false)),1,null,null,null,null));
+ }
+
+ //Constraint2 send(politoAntispam, n_0, p, t_0) && p.proto(POP3_RESP) ->
+ //(exist n_1,t_1 : (recv(n_1, politoAntispam, p, t_1) && t_1 < t_0)) && !isInBlackList(p.emailFrom)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(politoAntispam, n_0, p_0, t_0), ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_RESPONSE))),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{n_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1, politoAntispam, p_0, t_1), ctx.mkLt(t_1 , t_0)),1,null,null,null,null),
+ ctx.mkNot((BoolExpr)isInBlacklist.apply(nctx.pf.get("emailFrom").apply(p_0))))),1,null,null,null,null));
+
+ //Constraint3 send(politoAntispam, n_0, p, t_0) && p.proto(POP3_REQ) ->
+ //(exist n_1,t_1 : (recv(n_1, politoAntispam, p, t_1) && t_1 < t_0))
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(politoAntispam, n_0, p_0, t_0), ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_REQUEST))),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{n_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1, politoAntispam, p_0, t_1),
+ ctx.mkLt(t_1 , t_0)),1,null,null,null,null))),1,null,null,null,null));
+
+ //Constraint4 send(politoAntispam, politoErrFunction, p, t_0) ->
+ // (exist n_1,t_1 : (recv(n_1, politoAntispam, p, t_1) && t_1 < t_0 && p.emailFrom ==1))
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoAntispam, nctx.nm.get("politoErrFunction").getZ3Node(), p_0, t_0),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{n_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1, politoAntispam, p_0, t_1),
+ ctx.mkLt(t_1 , t_0),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_0),ctx.mkInt(1))),1,null,null,null,null))),1,null,null,null,null));
+
+ //Constraint5 send(politoAntispam, n_0, p, t_0) -> p.proto == POP_REQ || p.protpo == POP_RESP
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoAntispam, n_0, p_0, t_0),
+ ctx.mkOr(ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_REQUEST)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_RESPONSE)))),1,null,null,null,null));
+
+ //Constraint6 send(politoAntispam, n_0, p, t_0) -> nodeHasAddr(politoAntispam,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoAntispam, n_0, p_0, t_0),
+ ctx.mkNot((BoolExpr)nctx.nodeHasAddr.apply(politoAntispam,nctx.pf.get("src").apply(p_0)))),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoCache.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoCache.java
new file mode 100644
index 0000000..0d5ce55
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoCache.java
@@ -0,0 +1,177 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Sort;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**Cache Model
+ *
+ *
+ */
+public class PolitoCache extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoCache;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoCache(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoCache = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ //net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoCache;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void installCache (NetworkObject[] internalNodes){
+ Expr n_0 = ctx.mkConst("politoCache_"+politoCache+"_n_0", nctx.node);
+ Expr n_1 = ctx.mkConst("politoCache_"+politoCache+"_n_1", nctx.node);
+ Expr n_2 = ctx.mkConst("politoCache_"+politoCache+"_n_2", nctx.node);
+
+ Expr p_0 = ctx.mkConst("politoCache_"+politoCache+"_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("politoCache_"+politoCache+"_p_1", nctx.packet);
+ Expr p_2 = ctx.mkConst("politoCache_"+politoCache+"_p_2", nctx.packet);
+
+ IntExpr t_0 = ctx.mkIntConst("politoCache_"+politoCache+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst("politoCache_"+politoCache+"_t_1");
+ IntExpr t_2 = ctx.mkIntConst("politoCache_"+politoCache+"_t_2");
+
+ Expr a_0 = ctx.mkConst(politoCache+"politoCache_a_0", nctx.node);
+ IntExpr u_0 = ctx.mkIntConst("politoCache_"+politoCache+"_u_0");
+
+ FuncDecl isInternalNode = ctx.mkFuncDecl(politoCache+"_isInternalNode", nctx.node, ctx.mkBoolSort());
+ FuncDecl isInCache = ctx.mkFuncDecl(politoCache+"_isInCache", new Sort[]{ctx.mkIntSort(),ctx.mkIntSort()}, ctx.mkBoolSort());
+
+ assert(internalNodes.length!=0); //No internal nodes => Should never happen
+
+ //Modeling the behavior of the isInternalNode() and isInCache() functions
+ BoolExpr[] internalNodesConstraint = new BoolExpr[internalNodes.length];
+ for(int w=0;w<internalNodesConstraint.length;w++)
+ internalNodesConstraint[w]= (ctx.mkEq(a_0,internalNodes[w].getZ3Node()));
+
+ //Constraint1 if(isInternalNode(a_0) == or(listadeinodiinterni) ? True : false
+ constraints.add(
+ ctx.mkForall(new Expr[]{a_0},
+ ctx.mkIff((BoolExpr)isInternalNode.apply(a_0), ctx.mkOr(internalNodesConstraint)),1,null,null,null,null));
+
+ // constraints.add(ctx.mkForall(new Expr[]{a_0}, ctx.mkEq(isInternalNode.apply(a_0),ctx.mkOr(internalNodesConstraint)),1,null,null,null,null));
+
+ // constraints.add(ctx.mkForall(new Expr[]{u_0, t_0},
+ // ctx.mkITE(ctx.mkExists(new Expr[]{t_1, t_2, p_1, p_2, n_1, n_2},
+ // ctx.mkAnd(ctx.mkLt(t_1, t_2),
+ // ctx.mkLt(t_1, t_0),
+ // ctx.mkLt(t_2, t_0),
+ // (BoolExpr)nctx.recv.apply(n_1, politoCache, p_1, t_1),
+ // (BoolExpr)nctx.recv.apply(n_2, politoCache, p_2, t_2),
+ // ctx.mkEq(nctx.pf.get("proto").apply(p_1),ctx.mkInt(nctx.HTTP_REQUEST)),
+ // ctx.mkEq(nctx.pf.get("proto").apply(p_2),ctx.mkInt(nctx.HTTP_RESPONSE)),
+ // (BoolExpr)isInternalNode.apply(n_1),
+ // ctx.mkNot((BoolExpr)isInternalNode.apply(n_2)),
+ // ctx.mkEq(nctx.pf.get("url").apply(p_1),u_0),
+ // ctx.mkEq(nctx.pf.get("url").apply(p_2),u_0)),1,null,null,null,null),
+ // ctx.mkEq(isInCache.apply(u_0,t_0),ctx.mkBool(true)),ctx.mkEq(isInCache.apply(u_0,t_0),ctx.mkBool(false))),1,null,null,null,null));
+ //
+
+ //Constraint2 isInCache(u_0,t_0), exist t_1, t_2, p_1, p_2, n_1, n_2 :
+ // ( t_1< t_2 < t_0 && recv(n_1, politoCache, p_1, t_1) && recv(n_2, politoCache, p_2, t_2))) &&
+ // p_1.proto == HTTP_REQ && p_2.proto == HTTP_RESP &&
+ // isInternalNode(n_1) && !isInternalNode(n_2) &&
+ // p_1.url == u_0 && p_2.url == u_0 )
+ constraints.add(
+ ctx.mkForall(new Expr[]{u_0, t_0},
+ ctx.mkImplies((BoolExpr)isInCache.apply(u_0, t_0),
+ ctx.mkExists(new Expr[]{t_1,t_2,p_1,p_2,n_1, n_2},
+ ctx.mkAnd(
+ ctx.mkLt(t_1, t_2),
+ ctx.mkLt(t_1, t_0),
+ ctx.mkLt(t_2, t_0),
+ (BoolExpr)nctx.recv.apply(n_1, politoCache, p_1, t_1),
+ (BoolExpr)nctx.recv.apply(n_2, politoCache, p_2, t_2),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), ctx.mkInt(nctx.HTTP_REQUEST)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_2), ctx.mkInt(nctx.HTTP_RESPONSE)),
+ (BoolExpr)isInternalNode.apply(n_1),
+ ctx.mkNot((BoolExpr)isInternalNode.apply(n_2)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), u_0),
+ ctx.mkEq(nctx.pf.get("url").apply(p_2), u_0)),1,null,null,null,null)),1,null,null,null,null));
+ // //Always in cache
+ // constraints.add(ctx.mkForall(new Expr[]{u_0, t_0},ctx.mkEq(isInCache.apply(u_0,t_0),ctx.mkBool(true)),1,null,null,null,null));
+
+ //Constraint3 Modeling the behavior of the cache
+ //send(politoCache, n_0, p, t_0) && !isInternalNode(n_0) ->
+ // (exist t_1,n_1 :
+ // (t_1 < t_0 && recv(n_1, politoCache, p, t_1) &&
+ // p.proto == HTTP_REQ && !isInCache(p.url,t_0))
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0,p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)nctx.send.apply(politoCache,n_0,p_0,t_0),ctx.mkNot((BoolExpr)isInternalNode.apply(n_0))),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{t_1, n_1},
+ ctx.mkAnd(
+ ctx.mkLt(t_1, t_0),
+ (BoolExpr)isInternalNode.apply(n_1),
+ (BoolExpr)nctx.recv.apply(n_1, politoCache, p_0, t_1)),1,null,null,null,null),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_REQUEST)),
+ ctx.mkNot((BoolExpr)isInCache.apply(nctx.pf.get("url").apply(p_0), t_0)))),1,null,null,null,null));
+
+ //Constraint4 send(politoCache, n_0, p, t_0) && isInternalNode(n_0) ->
+ // (exist p_1,t_1 :
+ // (t_1 < t_0 && recv(n_0, politoCache, p_1, t_1) &&
+ // p_1.proto == HTTP_REQ && p.proto == HTTP_RESP &&
+ // p_1.url == p.url && p.src == p_1.dest && p.dest==p_1.src
+ // && isInCache(p.url,t_0))
+ constraints.add(
+ ctx.mkForall(new Expr[]{n_0,p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)nctx.send.apply(politoCache,n_0,p_0,t_0),(BoolExpr)isInternalNode.apply(n_0)),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{p_1, t_1},
+ ctx.mkAnd(
+ ctx.mkLt(t_1, t_0),
+ (BoolExpr)nctx.recv.apply(n_0, politoCache, p_1, t_1),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), ctx.mkInt(nctx.HTTP_REQUEST)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), nctx.pf.get("url").apply(p_0))),1,null,null,null,null),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_RESPONSE)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_0), nctx.pf.get("dest").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), nctx.pf.get("src").apply(p_1)),
+ (BoolExpr)isInCache.apply(nctx.pf.get("url").apply(p_0), t_0))),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoEndHost.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoEndHost.java
new file mode 100644
index 0000000..61f23af
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoEndHost.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+import it.polito.verigraph.mcnet.netobjs.PacketModel;
+
+public class PolitoEndHost extends NetworkObject {
+
+ List<BoolExpr> constraints = new ArrayList<BoolExpr>();
+ Context ctx;
+ DatatypeExpr politoEndHost;
+ Network net;
+ NetContext nctx;
+
+ public PolitoEndHost(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoEndHost;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ this.isEndHost = true;
+ this.politoEndHost = this.z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ this.net = (Network)args[0][1];
+ this.nctx = (NetContext)args[0][2];
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ /*
+ * Fields that can be configured -> "dest","body","seq","proto","emailFrom","url","options"
+ */
+ public void installEndHost (PacketModel packet){
+ //System.out.println("Installing PolitoEndHost...");
+ Expr n_0 = ctx.mkConst("PolitoEndHost_"+politoEndHost+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst("PolitoEndHost_"+politoEndHost+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("PolitoEndHost_"+politoEndHost+"_t_0");
+ BoolExpr predicatesOnPktFields = ctx.mkTrue();
+
+ if(packet.getIp_dest() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("dest").apply(p_0), packet.getIp_dest()));
+ if(packet.getBody() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("body").apply(p_0), ctx.mkInt(packet.getBody())));
+ if(packet.getEmailFrom() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("emailFrom").apply(p_0), ctx.mkInt(packet.getEmailFrom())));
+ if(packet.getOptions() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("options").apply(p_0), ctx.mkInt(packet.getOptions())));
+ if(packet.getProto() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(packet.getProto())));
+ if(packet.getSeq() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("seq").apply(p_0), ctx.mkInt(packet.getSeq())));
+ if(packet.getUrl() != null)
+ predicatesOnPktFields = ctx.mkAnd(predicatesOnPktFields, ctx.mkEq(nctx.pf.get("url").apply(p_0), ctx.mkInt(packet.getUrl())));
+
+ //Constraint1 send(politoWebClient, n_0, p, t_0) -> p.origin == politoWebClient && p.orig_body == p.body && nodeHasAddr(politoWebClient,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoEndHost, n_0, p_0, t_0),
+ ctx.mkAnd(predicatesOnPktFields,
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),politoEndHost),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoEndHost,nctx.pf.get("src").apply(p_0)))),1,null,null,null,null));
+
+ //Constraint2 recv(n_0, politoWebClient, p, t_0) -> nodeHasAddr(politoWebClient,p.dest)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0,politoEndHost, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoEndHost,nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+ //System.out.println("Done.");
+
+
+ return;
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoErrFunction.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoErrFunction.java
new file mode 100644
index 0000000..93cef9e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoErrFunction.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**Error Function objects
+ *
+ *
+ */
+public class PolitoErrFunction extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoErrFunction;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoErrFunction(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=true;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoErrFunction = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ errFunctionRules();
+ //net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoErrFunction;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ //System.out.println("[ERR FUNC] Installing rules.");
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ private void errFunctionRules (){
+ Expr n_0 = ctx.mkConst("PolitoErrFunction_"+politoErrFunction+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst("PolitoErrFunction_"+politoErrFunction+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("PolitoErrFunction_"+politoErrFunction+"_t_0");
+
+ // constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(politoErrFunction, n_0, p_0, t_0),
+ // (BoolExpr)nctx.nodeHasAddr.apply(politoErrFunction, nctx.pf.get("src").apply(p_0))),1,null,null,null,null));
+ // constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(politoErrFunction, n_0, p_0, t_0),
+ // ctx.mkEq(nctx.pf.get("origin").apply(p_0), politoErrFunction)),1,null,null,null,null));
+ //
+ // constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(politoErrFunction, n_0, p_0, t_0),
+ // ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),1,null,null,null,null));
+
+
+ // Constraint1 We want the ErrFunction not to send out any packet
+ // send(politoErrFunction, n_0, p, t_0) -> 1 == 2
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoErrFunction, n_0, p_0, t_0),
+ ctx.mkEq(ctx.mkInt(1),ctx.mkInt(2))),1,null,null,null,null));
+
+ // constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(n_0, politoErrFunction, p_0, t_0),
+ // (BoolExpr)nctx.nodeHasAddr.apply(politoErrFunction, nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+ }
+}
+
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoFieldModifier.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoFieldModifier.java
new file mode 100644
index 0000000..38b842b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoFieldModifier.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+public class PolitoFieldModifier extends NetworkObject {
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoFieldModifier;
+ Network net;
+ NetContext nctx;
+
+ public PolitoFieldModifier(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoFieldModifier;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoFieldModifier = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void installFieldModifier (){
+ Expr x = ctx.mkConst("politoFieldModifier_"+politoFieldModifier+"_x", nctx.node);
+ Expr y = ctx.mkConst("politoFieldModifier_"+politoFieldModifier+"_y", nctx.node);
+
+ Expr p_0 = ctx.mkConst("politoFieldModifier_"+politoFieldModifier+"_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("politoFieldModifier_"+politoFieldModifier+"_p_1", nctx.packet);
+
+ IntExpr t_0 = ctx.mkIntConst("politoFieldModifier_"+politoFieldModifier+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst("politoFieldModifier_"+politoFieldModifier+"_t_1");
+
+ constraints.add(
+ ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoFieldModifier,x,p_0,t_0),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd(ctx.mkLt(t_1, t_0),
+ (BoolExpr)nctx.recv.apply(y, politoFieldModifier, p_1, t_1),
+ ctx.mkEq(nctx.pf.get("encrypted").apply(p_0), nctx.pf.get("encrypted").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_0), nctx.pf.get("src").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), nctx.pf.get("dest").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_0), nctx.pf.get("inner_src").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("inner_dest").apply(p_0), nctx.pf.get("inner_dest").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0), nctx.pf.get("origin").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0), nctx.pf.get("orig_body").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_0), nctx.pf.get("body").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_0), nctx.pf.get("seq").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), nctx.pf.get("proto").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_0), nctx.pf.get("emailFrom").apply(p_1)),
+ ctx.mkNot(ctx.mkEq(nctx.pf.get("url").apply(p_0), nctx.pf.get("url").apply(p_1))),
+ ctx.mkEq(nctx.pf.get("options").apply(p_0), nctx.pf.get("options").apply(p_1))),1,null,null,null,null)),
+ 1,null,null,null,null));
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoIDS.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoIDS.java
new file mode 100644
index 0000000..8251c71
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoIDS.java
@@ -0,0 +1,139 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+public class PolitoIDS extends NetworkObject {
+
+ public static final int DROGA = 1; //no go
+ public static final int GATTINI = 2; //go
+
+ Context ctx;
+ List<BoolExpr> constraints = new ArrayList<BoolExpr>();
+ DatatypeExpr politoIDS;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+
+ public PolitoIDS(Context ctx, Object[]...args){
+ super(ctx, args);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoIDS;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+
+ this.ctx = ctx;
+ this.isEndHost = false;
+ this.politoIDS = this.z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ this.net = (Network)args[0][1];
+ this.nctx = (NetContext)args[0][2];
+
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+
+ }
+
+ public void installIDS(int[] blackList){
+ Expr n_0 = ctx.mkConst(politoIDS + "_n_0", nctx.node);
+ Expr n_1 = ctx.mkConst(politoIDS + "_n_1", nctx.node);
+ Expr p_0 = ctx.mkConst(politoIDS + "_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst(politoIDS + "_t_0");
+ IntExpr t_1 = ctx.mkIntConst(politoIDS + "_t_1");
+ Expr b_0 = ctx.mkIntConst(politoIDS + "_b_0");
+
+ isInBlacklist = ctx.mkFuncDecl(politoIDS + "_isInBlacklist", ctx.mkIntSort(), ctx.mkBoolSort());
+
+
+ BoolExpr[] blConstraints = new BoolExpr[blackList.length];
+ if(blackList.length != 0){
+
+ for(int i = 0; i<blackList.length; i++)
+ blConstraints[i] = ctx.mkEq(b_0, ctx.mkInt(blackList[i]));
+
+ this.constraints.add(ctx.mkForall(new Expr[]{b_0},
+ ctx.mkIff((BoolExpr)isInBlacklist.apply(b_0), ctx.mkOr(blConstraints)),
+ 1,
+ null, null, null, null));
+
+ }else{
+ this.constraints.add(ctx.mkForall(new Expr[]{b_0},
+ ctx.mkEq(isInBlacklist.apply(b_0), ctx.mkBool(false)),
+ 1,
+ null, null, null, null));
+ }
+
+ //Constraint2 send(politoIDS, n_0, p, t_0) && (p.proto(HTTP_RESPONSE) || p.proto(HTTP_REQUEST)) ->
+ //(exist n_1,t_1 : (recv(n_1, politoIDS, p, t_1) && t_1 < t_0)) && !isInBlackList(p.body)
+
+ this.constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(politoIDS, n_0, p_0, t_0), ctx.mkOr(ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_RESPONSE)), ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_REQUEST)))),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{n_1,t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1,politoIDS,p_0,t_1),ctx.mkLt(t_1, t_0)),
+ 1,
+ null, null, null, null),
+ ctx.mkNot((BoolExpr)isInBlacklist.apply(nctx.pf.get("body").apply(p_0))))),
+ 1,
+ null, null, null, null));
+
+ //Constraint3 send(politoIDS, n_0, p, t_0) && p.proto(HTTP_REQUEST) ->
+ //(exist n_1,t_1 : (recv(n_1, politoIDS, p, t_1) && t_1 < t_0)) Constraint not needed anymore (included in contr. 2)
+ /* this.constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies(ctx.mkAnd((BoolExpr)nctx.send.apply(politoIDS, n_0, p_0, t_0), ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_REQUEST))),
+ ctx.mkAnd(ctx.mkExists(new Expr[]{n_1,t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1,politoIDS,p_0,t_1),ctx.mkLt(t_1, t_0)),
+ 1,
+ null, null, null, null))),
+ 1,
+ null, null, null, null));
+ */
+
+ //Constraint5send(politoIDS, n_0, p, t_0) -> p.proto == HTTP_REQ || p.protpo == HTTP_RESP
+
+ this.constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoIDS, n_0, p_0, t_0),
+ ctx.mkOr(ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_REQUEST)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_RESPONSE)))),
+ 1,
+ null,null,null,null));
+
+ //Constraint6send(politoIDS, n_0, p, t_0) -> nodeHasAddr(politoIDS,p.src)
+
+ this.constraints.add(ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoIDS, n_0, p_0, t_0),
+ ctx.mkNot((BoolExpr)nctx.nodeHasAddr.apply(politoIDS,nctx.pf.get("src").apply(p_0)))),
+ 1,
+ null,null,null,null));
+
+
+
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailClient.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailClient.java
new file mode 100644
index 0000000..aa6a815
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailClient.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**
+ * MailClient objects
+ *
+ */
+public class PolitoMailClient extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoMailClient;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoMailClient(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=true;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoMailClient = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ DatatypeExpr ipServer = (DatatypeExpr) args[0][3];
+ mailClientRules(ipServer);
+ //net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoMailClient;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ //System.out.println("[MailClient] Installing rules.");
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ private void mailClientRules (DatatypeExpr ipServer){
+ Expr n_0 = ctx.mkConst("PolitoMailClient_"+politoMailClient+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst("PolitoMailClient_"+politoMailClient+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("PolitoMailClient_"+politoMailClient+"_t_0");
+
+ //Constraint1 send(politoMailClient, n_0, p, t_0) -> nodeHasAddr(politoMailClient,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailClient, n_0, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoMailClient,nctx.pf.get("src").apply(p_0))),1,null,null,null,null));
+
+ //Constraint2 send(politoMailClient, n_0, p, t_0) -> p.origin == politoMailClient
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),politoMailClient)),1,null,null,null,null));
+
+ //Constraint3 send(politoMailClient, n_0, p, t_0) -> p.orig_body == p.body
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),1,null,null,null,null));
+
+ //Constraint4 recv(n_0, politoMailClient, p, t_0) -> nodeHasAddr(politoMailClient,p.dest)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0,politoMailClient, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoMailClient,nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+ //Constraint5 This client is only able to produce POP3 requests
+ //send(politoMailClient, n_0, p, t_0) -> p.proto == POP3_REQ
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_REQUEST))),1,null,null,null,null));
+
+ //Constraint6 send(politoMailClient, n_0, p, t_0) -> p.dest == ip_mailServer
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), ipServer)),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailServer.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailServer.java
new file mode 100644
index 0000000..4daaaff
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoMailServer.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/** Mail server objects
+ *
+ *
+ */
+public class PolitoMailServer extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoMailServer;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoMailServer(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoMailServer = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ mailServerRules();
+ net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoMailServer;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ private void mailServerRules (){
+ Expr n_0 = ctx.mkConst(politoMailServer+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst(politoMailServer+"_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst(politoMailServer+"_p_1", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst(politoMailServer+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst(politoMailServer+"_t_1");
+
+ //Constraint1 send(politoMailServer, n_0, p, t_0) -> nodeHasAddr(politoMailServer,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoMailServer,nctx.pf.get("src").apply(p_0))),1,null,null,null,null));
+
+ //Constraint2 send(politoMailServer, n_0, p, t_0) -> p.origin == politoMailServer
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),politoMailServer)),1,null,null,null,null));
+
+ //Constraint3 send(politoMailServer, n_0, p, t_0) -> p.orig_body == p.body
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),1,null,null,null,null));
+
+ //Constraint4 recv(n_0, politoMailServer, p, t_0) -> nodeHasAddr(politoMailServer,p.dest)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0,politoMailServer, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoMailServer,nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+ //Constraint5 send(politoMailServer, n_0, p, t_0) -> p.proto == POP3_RESP && p.emailFrom == 1
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ ctx.mkAnd(ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_RESPONSE)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_0), ctx.mkInt(1)))),1,null,null,null,null));
+
+ //Constraint6 send(politoMailServer, n_0, p, t_0) ->
+ // (exist p_1, t_1 : (t_1 < t_0 && recv(n_0, politoMailServer, p_1, t_1) &&
+ // p_0.proto == POP3_RESP && p_1.proto == POP3_REQ && p_0.dest == p_1.src )
+
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ ctx.mkExists(new Expr[]{p_1, t_1},
+ ctx.mkAnd(ctx.mkLt(t_1, t_0),
+ (BoolExpr)nctx.recv.apply(n_0, politoMailServer, p_1, t_1),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.POP3_RESPONSE)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), ctx.mkInt(nctx.POP3_REQUEST)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), nctx.pf.get("src").apply(p_1))),1,null,null,null,null)),1,null,null,null,null));
+
+ // constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ // ctx.mkImplies((BoolExpr)nctx.send.apply(politoMailServer, n_0, p_0, t_0),
+ // ctx.mkEq(nctx.pf.get("emailFrom").apply(p_0),ctx.mkInt(2))),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNF.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNF.java
new file mode 100644
index 0000000..227224c
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNF.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Sort;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/** First example of custom network function: a simple filter
+ *
+ *
+ */
+public class PolitoNF extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoNF;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+
+ public PolitoNF(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoNF = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ //net.saneSend(this);
+ }
+
+ public void politoNFRules (DatatypeExpr ipA,DatatypeExpr ipB){
+ // System.out.println("[PolitoNf] Installing rules");
+ Expr n_0 = ctx.mkConst("politoNF_"+politoNF+"_n_0", nctx.node);
+ Expr n_1 = ctx.mkConst("politoNF_"+politoNF+"_n_1", nctx.node);
+ Expr p_0 = ctx.mkConst("politoNF_"+politoNF+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("politoNF_"+politoNF+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst("politoNF_"+politoNF+"_t_1");
+ Expr a_0 = ctx.mkConst(politoNF+"_politoNF_a_0", nctx.address);
+ Expr a_1 = ctx.mkConst(politoNF+"_politoNF_a_1", nctx.address);
+
+ FuncDecl myFunction = ctx.mkFuncDecl(politoNF+"_myFunction", new Sort[]{nctx.address,nctx.address}, ctx.mkBoolSort());
+
+ BoolExpr myConstraint = ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoNF, n_0, p_0, t_0),
+ ctx.mkExists(new Expr[]{n_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(n_1, politoNF, p_0, t_1),
+ ctx.mkLt(t_1 , t_0),
+ (BoolExpr)myFunction.apply(nctx.pf.get("src").apply(p_0), nctx.pf.get("dest").apply(p_0))),1,null,null,null,null)),1,null,null,null,null);
+
+ BoolExpr funcConstraint = ctx.mkOr(ctx.mkAnd(ctx.mkEq(a_0, ipA), ctx.mkEq(a_1, ipB)), ctx.mkAnd(ctx.mkEq(a_0,ipB), ctx.mkEq(a_1,ipA)));
+
+ // Constraint1myFunction(a_0,a_1) == ((a_0 == ipA && a_1 == ipB) || (a_0 == ipB && a_1 == ipA))
+ constraints.add(
+ ctx.mkForall(new Expr[]{a_0,a_1},
+ ctx.mkEq(myFunction.apply(a_0, a_1), funcConstraint),1,null,null,null,null));
+
+ //Constraint2send(politoNF, n_0, p, t_0) ->
+ //(exist n_1,t_1 : (t_1 < t_0 && recv(n_1, politoNF, p, t_1) && myFunction(p.src,p.dest))
+ constraints.add(myConstraint);
+
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoNF;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNat.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNat.java
new file mode 100644
index 0000000..218d9ba
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoNat.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**
+ * NAT Model object
+ *
+ */
+public class PolitoNat extends NetworkObject{
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr nat;
+ List<DatatypeExpr> private_addresses;
+ List<NetworkObject> private_node;
+ Network net;
+ NetContext nctx;
+ FuncDecl private_addr_func ;
+
+ public PolitoNat(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=false;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ nat = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ private_addresses = new ArrayList<DatatypeExpr>();
+ private_node = new ArrayList<NetworkObject>();
+ net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return nat;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ /*
+private void addPrivateAdd(List<DatatypeExpr> address){
+private_addresses.addAll(address);
+}
+ */
+
+ public List<DatatypeExpr> getPrivateAddress(){
+ return private_addresses;
+ }
+
+ public void natModel(DatatypeExpr natIp){
+ Expr x = ctx.mkConst("x", nctx.node);
+ Expr y = ctx.mkConst("y", nctx.node);
+ Expr z = ctx.mkConst("z", nctx.node);
+
+ Expr p_0 = ctx.mkConst("p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("p_1", nctx.packet);
+ Expr p_2 = ctx.mkConst("p_2", nctx.packet);
+
+ IntExpr t_0 = ctx.mkIntConst("t_0");
+ IntExpr t_1 = ctx.mkIntConst("t_1");
+ IntExpr t_2 = ctx.mkIntConst("t_2");
+
+ // private_addr_func = ctx.mkFuncDecl("private_addr_func", nctx.address, ctx.mkBoolSort());
+ private_addr_func = ctx.mkFuncDecl(nat + "_nat_func", nctx.address, ctx.mkBoolSort());
+
+ //Constraint1
+ // "send(nat, x, p_0, t_0) && !private_addr_func(p_0.dest) ->
+ // p_0.src == ip_politoNat &&
+ // (exist y, p_1,t_1 :
+ // (recv(y, nat, p_1, t_1) && t_1 < t_0 &&
+ // private_addr_func(p1.src) &&
+ // p_1.origin == p_0.origin &&
+ // same for p_1.<dest,orig_body,body,seq,proto,emailFrom,url,options> == p_0.<...>) "
+ constraints.add( ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)nctx.send.apply(nat, x, p_0, t_0),
+ ctx.mkNot((BoolExpr)private_addr_func.apply(nctx.pf.get("dest").apply(p_0)))),
+ ctx.mkAnd(
+ ctx.mkEq(nctx.pf.get("src").apply(p_0),natIp),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd(
+ (BoolExpr)nctx.recv.apply(y, nat, p_1, t_1),
+ ctx.mkLt(t_1 , t_0),
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("src").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_1),nctx.pf.get("origin").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1),nctx.pf.get("dest").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1),nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1),nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1),nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1),nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1),nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1),nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1),nctx.pf.get("options").apply(p_0))),1,null,null,null,null))),1,null,null,null,null));
+
+ //Constraint2
+ // send(nat, x, p_0, t_0) && private_addr_func(p_0.dest) ->
+ // !private_addr_func(p_0.src) &&
+ // (exist y, p_1,t_1 :
+ // (recv(y, nat, p_1, t_1) && t_1 < t_0 &&
+ // !private_addr_func(p1.src) &&
+ // p_1.dest == ip_politoNat &&
+ // p_1.origin == p_0.origin &&
+ // same for p_1.<src,orig_body,body,seq,proto,emailFrom,url,options> == p_0.<...>)
+ constraints.add( ctx.mkForall(new Expr[]{x, p_0, t_0},
+ ctx.mkImplies(
+ ctx.mkAnd((BoolExpr)nctx.send.apply(nat, x, p_0, t_0),
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("dest").apply(p_0))),
+ ctx.mkAnd(
+ ctx.mkNot((BoolExpr)private_addr_func.apply(nctx.pf.get("src").apply(p_0))),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd(
+ ctx.mkLt(t_1 , t_0),
+ (BoolExpr)nctx.recv.apply(y, nat, p_1, t_1),
+ ctx.mkNot((BoolExpr)private_addr_func.apply(nctx.pf.get("src").apply(p_1))),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1),natIp),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1),nctx.pf.get("src").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),nctx.pf.get("origin").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1),nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1),nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1),nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1),nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1),nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1),nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1),nctx.pf.get("options").apply(p_0)),
+ ctx.mkExists(new Expr[]{z, p_2, t_2},
+ ctx.mkAnd(
+ ctx.mkLt(t_2 , t_1),
+ (BoolExpr)nctx.recv.apply(z, nat, p_2, t_2),
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("src").apply(p_2)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1),nctx.pf.get("dest").apply(p_2)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_0),nctx.pf.get("dest").apply(p_2)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_2),nctx.pf.get("dest").apply(p_0))),1,null,null,null,null)),1,null,null,null,null))),1,null,null,null,null));
+
+ }
+
+ public void setInternalAddress(ArrayList<DatatypeExpr> internalAddress){
+ List<BoolExpr> constr = new ArrayList<BoolExpr>();
+ Expr n_0 = ctx.mkConst("nat_node", nctx.address);
+
+ for(DatatypeExpr n : internalAddress){
+ constr.add(ctx.mkEq(n_0,n));
+ }
+ BoolExpr[] constrs = new BoolExpr[constr.size()];
+ //Constraintprivate_addr_func(n_0) == or(n_0==n foreach internal address)
+ constraints.add(ctx.mkForall(new Expr[]{n_0}, ctx.mkEq(private_addr_func.apply(n_0),ctx.mkOr(constr.toArray(constrs))),1,null,null,null,null));
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnAccess.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnAccess.java
new file mode 100644
index 0000000..8a8dea2
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnAccess.java
@@ -0,0 +1,141 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+public class PolitoVpnAccess extends NetworkObject {
+
+ List<BoolExpr> constraints = new ArrayList<BoolExpr>();
+ DatatypeExpr politoVpnAccess;
+ FuncDecl private_addr_func;
+ NetContext nctx;
+ Context ctx;
+ Network net;
+
+ public PolitoVpnAccess(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoVpnAccess;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ this.isEndHost = false;
+ this.politoVpnAccess = this.z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ this.net = (Network)args[0][1];
+ this.nctx = (NetContext)args[0][2];
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void vpnAccessModel(DatatypeExpr vpnAccessIp, DatatypeExpr vpnExitIp) {
+ Expr x = ctx.mkConst("vpn_x", nctx.node);
+ Expr y = ctx.mkConst("vpn_y", nctx.node);
+
+ Expr p_0 = ctx.mkConst("vpn_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("vpn_p_1", nctx.packet);
+
+ IntExpr t_0 = ctx.mkIntConst("vpn_t_0");
+ IntExpr t_1 = ctx.mkIntConst("vpn_t_1");
+
+ private_addr_func = ctx.mkFuncDecl("vpn_private_addr_func", nctx.address, ctx.mkBoolSort());
+
+ BoolExpr constraint1 = ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies(ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(politoVpnAccess, x, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_0), nctx.am.get("null"))),
+ ctx.mkAnd(
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("dest").apply(p_0)),
+ ctx.mkNot((BoolExpr)nctx.pf.get("encrypted").apply(p_0)),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(y, politoVpnAccess, p_1, t_1),
+ ctx.mkLt(t_1, t_0),
+ (BoolExpr)nctx.pf.get("encrypted").apply(p_1),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1), vpnExitIp),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1), vpnAccessIp),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_1), nctx.pf.get("src").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("inner_dest").apply(p_1), nctx.pf.get("dest").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_1), nctx.pf.get("origin").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1), nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1), nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1), nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1), nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1), nctx.pf.get("options").apply(p_0))), 1, null, null, null, null))),
+ 1,null,null,null,null);
+
+ constraints.add(constraint1);
+
+ BoolExpr constraint2 = ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies(ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(politoVpnAccess, x, p_0, t_0),
+ ctx.mkNot(ctx.mkEq(nctx.pf.get("inner_src").apply(p_0), nctx.am.get("null")))),
+ ctx.mkAnd(
+ ctx.mkEq(nctx.pf.get("src").apply(p_0), vpnAccessIp),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), vpnExitIp),
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("inner_src").apply(p_0)),
+ ctx.mkNot(ctx.mkEq(nctx.pf.get("inner_dest").apply(p_0), vpnAccessIp)),
+ (BoolExpr)nctx.pf.get("encrypted").apply(p_0),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(y, politoVpnAccess, p_1, t_1),
+ ctx.mkLt(t_1, t_0),
+ ctx.mkNot((BoolExpr)nctx.pf.get("encrypted").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1), nctx.pf.get("inner_src").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1), nctx.pf.get("inner_dest").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_1), nctx.am.get("null")),
+ ctx.mkEq(nctx.pf.get("inner_dest").apply(p_1), nctx.am.get("null")),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_1), nctx.pf.get("origin").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1), nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1), nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1), nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1), nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1), nctx.pf.get("options").apply(p_0))), 1, null, null, null, null))),
+ 1,null,null,null,null);
+
+ constraints.add(constraint2);
+ }
+
+ public void setInternalAddress(ArrayList<DatatypeExpr> internalAddress){
+ List<BoolExpr> constr = new ArrayList<BoolExpr>();
+ Expr n_0 = ctx.mkConst("vpn_node", nctx.address);
+
+ for(DatatypeExpr n : internalAddress){
+ constr.add(ctx.mkEq(n_0,n));
+ }
+ BoolExpr[] constrs = new BoolExpr[constr.size()];
+ //Constraintprivate_addr_func(n_0) == or(n_0==n foreach internal address)
+ constraints.add(ctx.mkForall(new Expr[]{n_0}, ctx.mkEq(private_addr_func.apply(n_0),ctx.mkOr(constr.toArray(constrs))),1,null,null,null,null));
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnExit.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnExit.java
new file mode 100644
index 0000000..3710c7b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoVpnExit.java
@@ -0,0 +1,141 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+public class PolitoVpnExit extends NetworkObject {
+
+ List<BoolExpr> constraints = new ArrayList<BoolExpr>();
+ DatatypeExpr politoVpnExit;
+ FuncDecl private_addr_func;
+ NetContext nctx;
+ Context ctx;
+ Network net;
+
+ public PolitoVpnExit(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoVpnExit;
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ this.isEndHost = false;
+ this.politoVpnExit = this.z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ this.net = (Network)args[0][1];
+ this.nctx = (NetContext)args[0][2];
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ public void vpnExitModel(DatatypeExpr vpnAccessIp, DatatypeExpr vpnExitIp) {
+ Expr x = ctx.mkConst("vpn_x", nctx.node);
+ Expr y = ctx.mkConst("vpn_y", nctx.node);
+
+ Expr p_0 = ctx.mkConst("vpn_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("vpn_p_1", nctx.packet);
+
+ IntExpr t_0 = ctx.mkIntConst("vpn_t_0");
+ IntExpr t_1 = ctx.mkIntConst("vpn_t_1");
+
+ private_addr_func = ctx.mkFuncDecl("vpn_private_addr_func", nctx.address, ctx.mkBoolSort());
+
+ BoolExpr constraint1 = ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies(ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(politoVpnExit, x, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_0), nctx.am.get("null"))),
+ ctx.mkAnd(
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("src").apply(p_0)),
+ ctx.mkNot((BoolExpr)nctx.pf.get("encrypted").apply(p_0)),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(y, politoVpnExit, p_1, t_1),
+ ctx.mkLt(t_1, t_0),
+ (BoolExpr)nctx.pf.get("encrypted").apply(p_1),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1), vpnAccessIp),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1), vpnExitIp),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_1), nctx.pf.get("src").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("inner_dest").apply(p_1), nctx.pf.get("dest").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_1), nctx.pf.get("origin").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1), nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1), nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1), nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1), nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1), nctx.pf.get("options").apply(p_0))), 1, null, null, null, null))),
+ 1,null,null,null,null);
+
+ constraints.add(constraint1);
+
+ BoolExpr constraint2 = ctx.mkForall(new Expr[]{t_0, p_0, x},
+ ctx.mkImplies(ctx.mkAnd(
+ (BoolExpr)nctx.send.apply(politoVpnExit, x, p_0, t_0),
+ ctx.mkNot(ctx.mkEq(nctx.pf.get("inner_src").apply(p_0), nctx.am.get("null")))),
+ ctx.mkAnd(
+ ctx.mkEq(nctx.pf.get("src").apply(p_0), vpnExitIp),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), vpnAccessIp),
+ (BoolExpr)private_addr_func.apply(nctx.pf.get("dest").apply(p_0)),
+ ctx.mkNot(ctx.mkEq(nctx.pf.get("inner_dest").apply(p_1), vpnExitIp)),
+ (BoolExpr)nctx.pf.get("encrypted").apply(p_0),
+ ctx.mkExists(new Expr[]{y, p_1, t_1},
+ ctx.mkAnd((BoolExpr)nctx.recv.apply(y, politoVpnExit, p_1, t_1),
+ ctx.mkLt(t_1, t_0),
+ ctx.mkNot((BoolExpr)nctx.pf.get("encrypted").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_1), nctx.pf.get("inner_src").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_1), nctx.pf.get("inner_dest").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("inner_src").apply(p_1), nctx.am.get("null")),
+ ctx.mkEq(nctx.pf.get("inner_dest").apply(p_1), nctx.am.get("null")),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_1), nctx.pf.get("origin").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_1), nctx.pf.get("orig_body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("body").apply(p_1), nctx.pf.get("body").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("seq").apply(p_1), nctx.pf.get("seq").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), nctx.pf.get("proto").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("emailFrom").apply(p_1), nctx.pf.get("emailFrom").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("url").apply(p_1), nctx.pf.get("url").apply(p_0)),
+ ctx.mkEq(nctx.pf.get("options").apply(p_1), nctx.pf.get("options").apply(p_0))), 1, null, null, null, null))),
+ 1,null,null,null,null);
+
+ constraints.add(constraint2);
+ }
+
+ public void setInternalAddress(ArrayList<DatatypeExpr> internalAddress){
+ List<BoolExpr> constr = new ArrayList<BoolExpr>();
+ Expr n_0 = ctx.mkConst("vpn_node", nctx.address);
+
+ for(DatatypeExpr n : internalAddress){
+ constr.add(ctx.mkEq(n_0,n));
+ }
+ BoolExpr[] constrs = new BoolExpr[constr.size()];
+ //Constraintprivate_addr_func(n_0) == or(n_0==n foreach internal address)
+ constraints.add(ctx.mkForall(new Expr[]{n_0}, ctx.mkEq(private_addr_func.apply(n_0),ctx.mkOr(constr.toArray(constrs))),1,null,null,null,null));
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebClient.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebClient.java
new file mode 100644
index 0000000..462389e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebClient.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+
+/**
+ * WebClient
+ */
+public class PolitoWebClient extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr politoWebClient;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoWebClient(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=true;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ politoWebClient = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ DatatypeExpr ipServer = (DatatypeExpr) args[0][3];
+ webClientRules(ipServer);
+ //net.saneSend(this);
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return politoWebClient;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ //System.out.println("[MailClient] Installing rules.");
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ private void webClientRules (DatatypeExpr ipServer){
+ Expr n_0 = ctx.mkConst("PolitoWebClient_"+politoWebClient+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst("PolitoWebClient_"+politoWebClient+"_p_0", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("PolitoWebClient_"+politoWebClient+"_t_0");
+
+ //Constraint1send(politoWebClient, n_0, p, t_0) -> nodeHasAddr(politoWebClient,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoWebClient, n_0, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoWebClient,nctx.pf.get("src").apply(p_0))),1,null,null,null,null));
+
+ //Constraint2send(politoWebClient, n_0, p, t_0) -> p.origin == politoWebClient
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoWebClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),politoWebClient)),1,null,null,null,null));
+
+ //Constraint3send(politoWebClient, n_0, p, t_0) -> p.orig_body == p.body
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoWebClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),1,null,null,null,null));
+
+ //Constraint4recv(n_0, politoWebClient, p, t_0) -> nodeHasAddr(politoWebClient,p.dest)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0,politoWebClient, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(politoWebClient,nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+
+ //Constraint5This client is only able to produce HTTP requests
+ //send(politoWebClient, n_0, p, t_0) -> p.proto == HTTP_REQ
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoWebClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_REQUEST))),1,null,null,null,null));
+
+ //Constraint6send(politoWebClient, n_0, p, t_0) -> p.dest == ipServer
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(politoWebClient, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), ipServer)),1,null,null,null,null));
+
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebServer.java b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebServer.java
new file mode 100644
index 0000000..e5d579d
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/mcnet/netobjs/PolitoWebServer.java
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * 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.verigraph.mcnet.netobjs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+/**
+ * WebServer object
+ *
+ */
+public class PolitoWebServer extends NetworkObject{
+
+ List<BoolExpr> constraints;
+ Context ctx;
+ DatatypeExpr node;
+ Network net;
+ NetContext nctx;
+ FuncDecl isInBlacklist;
+
+ public PolitoWebServer(Context ctx, Object[]... args) {
+ super(ctx, args);
+ }
+
+ @Override
+ protected void init(Context ctx, Object[]... args) {
+ this.ctx = ctx;
+ isEndHost=true;
+ constraints = new ArrayList<BoolExpr>();
+ z3Node = ((NetworkObject)args[0][0]).getZ3Node();
+ node = z3Node;
+ net = (Network)args[0][1];
+ nctx = (NetContext)args[0][2];
+ webServerRules();
+
+ }
+
+ @Override
+ public DatatypeExpr getZ3Node() {
+ return node;
+ }
+
+ @Override
+ protected void addConstraints(Solver solver) {
+ BoolExpr[] constr = new BoolExpr[constraints.size()];
+ solver.add(constraints.toArray(constr));
+ }
+
+ private void webServerRules (){
+ Expr n_0 = ctx.mkConst("webserver_"+node+"_n_0", nctx.node);
+ Expr p_0 = ctx.mkConst("webserver_"+node+"_p_0", nctx.packet);
+ Expr p_1 = ctx.mkConst("webserver_"+node+"_p_1", nctx.packet);
+ IntExpr t_0 = ctx.mkIntConst("webserver_"+node+"_t_0");
+ IntExpr t_1 = ctx.mkIntConst("webserver_"+node+"_t_1");
+
+ //Constraint1 send(politoWebServer, n_0, p, t_0) -> nodeHasAddr(politoWebServer,p.src)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node, n_0, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(node,nctx.pf.get("src").apply(p_0))),1,null,null,null,null));
+
+ //Constraint2 send(politoWebServer, n_0, p, t_0) -> p.origin == politoWebServer
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("origin").apply(p_0),node)),1,null,null,null,null));
+
+ //Constraint3 send(politoWebServer, n_0, p, t_0) -> p.orig_body == p.body
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node, n_0, p_0, t_0),
+ ctx.mkEq(nctx.pf.get("orig_body").apply(p_0),nctx.pf.get("body").apply(p_0))),
+ 1,null,null,null,null));
+
+ //Constraint4 recv(n_0, politoWebServer, p, t_0) -> nodeHasAddr(politoWebServer,p.dest)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.recv.apply(n_0,node, p_0, t_0),
+ (BoolExpr)nctx.nodeHasAddr.apply(node,nctx.pf.get("dest").apply(p_0))),1,null,null,null,null));
+
+ //Constraint5 send(politoWebServer, n_0, p, t_0) ->
+ // (exist p_1,t_1 :
+ // (t_1 < t_0 && recv(n_0, politoWebServer, p_1, t_1) &&
+ // p_0.proto == HTTP_RESP && p_1.proto == HTTP_REQ &&
+ // p_0.dest == p_1.src && p_0.src == p_1.dest && p_0.url == p_1.url)
+ constraints.add( ctx.mkForall(new Expr[]{n_0, p_0, t_0},
+ ctx.mkImplies((BoolExpr)nctx.send.apply(node, n_0, p_0, t_0),
+ ctx.mkExists(new Expr[]{p_1, t_1},
+ ctx.mkAnd(
+ ctx.mkLt(t_1, t_0),
+ ctx.mkEq(nctx.pf.get("url").apply(p_0), nctx.pf.get("url").apply(p_1)),
+ (BoolExpr)nctx.recv.apply(n_0, node, p_1, t_1),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_0), ctx.mkInt(nctx.HTTP_RESPONSE)),
+ ctx.mkEq(nctx.pf.get("proto").apply(p_1), ctx.mkInt(nctx.HTTP_REQUEST)),
+ ctx.mkEq(nctx.pf.get("dest").apply(p_0), nctx.pf.get("src").apply(p_1)),
+ ctx.mkEq(nctx.pf.get("src").apply(p_0), nctx.pf.get("dest").apply(p_1))),
+ 1,null,null,null,null)),1,null,null,null,null));
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Configuration.java b/verigraph/src/it/polito/verigraph/model/Configuration.java
new file mode 100644
index 0000000..ecd0e7e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Configuration.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlTransient;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import it.polito.verigraph.deserializer.ConfigurationCustomDeserializer;
+import it.polito.verigraph.serializer.CustomConfigurationSerializer;
+
+@XmlRootElement
+@ApiModel("Configuration")
+@JsonSerialize(using = CustomConfigurationSerializer.class)
+@JsonDeserialize(using = ConfigurationCustomDeserializer.class)
+public class Configuration {
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private String id;
+
+ @ApiModelProperty(required = false)
+ @XmlTransient
+ private String description= "";
+
+ @ApiModelProperty(required = true)
+ private JsonNode configuration;
+
+ public Configuration() {
+
+ }
+
+ public Configuration(String id, String description, JsonNode configuration) {
+ this.id = id;
+ this.description = description;
+ this.configuration = configuration;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public JsonNode getConfiguration() {
+ return configuration;
+ }
+
+ public void setConfiguration(JsonNode configuration) {
+ this.configuration = configuration;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Entry.java b/verigraph/src/it/polito/verigraph/model/Entry.java
new file mode 100644
index 0000000..5f46945
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Entry.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+public class Entry {
+ private String direction;
+ private String destination;
+
+ public Entry(String direction, String destination) {
+ this.direction = direction;
+ this.destination = destination;
+ }
+
+ public String getDirection() {
+ return direction;
+ }
+
+ public void setDirection(String direction) {
+ this.direction = direction;
+ }
+
+ public String getDestination() {
+ return destination;
+ }
+
+ public void setDestination(String destination) {
+ this.destination = destination;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/ErrorMessage.java b/verigraph/src/it/polito/verigraph/model/ErrorMessage.java
new file mode 100644
index 0000000..e4aef4d
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/ErrorMessage.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "Error")
+@XmlRootElement
+public class ErrorMessage {
+
+ @ApiModelProperty(example = "Error message")
+ private String errorMessage;
+ @ApiModelProperty(allowableValues = "400,403,404,500", value = "HTTP error code", example = "[400,403,404,500]")
+ private int errorCode;
+ @ApiModelProperty(example = "http://localhost:8080/verigraph/api-docs/")
+ private String documentation;
+
+ public ErrorMessage() {
+
+ }
+
+ public ErrorMessage(String errorMessage, int errorCode, String documentation) {
+ this.errorMessage = errorMessage;
+ this.errorCode = errorCode;
+ this.documentation = documentation;
+ }
+
+ public String getErrorMessage() {
+ return errorMessage;
+ }
+
+ public void setErrorMessage(String errorMessage) {
+ this.errorMessage = errorMessage;
+ }
+
+ public int getErrorCode() {
+ return errorCode;
+ }
+
+ public void setErrorCode(int errorCode) {
+ this.errorCode = errorCode;
+ }
+
+ public String getDocumentation() {
+ return documentation;
+ }
+
+ public void setDocumentation(String documentation) {
+ this.documentation = documentation;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Graph.java b/verigraph/src/it/polito/verigraph/model/Graph.java
new file mode 100644
index 0000000..22b4907
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Graph.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlTransient;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import it.polito.verigraph.deserializer.GraphCustomDeserializer;
+import it.polito.verigraph.serializer.CustomMapSerializer;
+
+@ApiModel(value = "Graph")
+@XmlRootElement
+@JsonDeserialize(using = GraphCustomDeserializer.class)
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class Graph {
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private long id;
+
+ @ApiModelProperty(name = "nodes", notes = "Nodes", dataType = "List[it.polito.verigraph.model.Node]")
+ private Map<Long, Node>nodes= new HashMap<Long, Node>();
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private Set<Link>links= new HashSet<Link>();
+
+ public Graph() {
+
+ }
+
+ public Graph(long id) {
+ this.id = id;
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ @JsonSerialize(using = CustomMapSerializer.class)
+ public Map<Long, Node> getNodes() {
+ return nodes;
+ }
+
+ public void setNodes(Map<Long, Node> nodes) {
+ this.nodes = nodes;
+ }
+
+ @XmlTransient
+ public Set<Link> getLinks() {
+ return links;
+ }
+
+ public void setLinks(Set<Link> links) {
+ this.links = links;
+ }
+
+ public void addLink(String url, String rel) {
+ Link link = new Link();
+ link.setLink(url);
+ link.setRel(rel);
+ links.add(link);
+ }
+
+ public Node searchNodeByName(String name) {
+ for (Node node : this.nodes.values()) {
+ if (node.getName().equals(name))
+ return node;
+ }
+ return null;
+ }
+
+ public int nodesWithName(String name) {
+ int occurrences = 0;
+ for (Node node : this.nodes.values()) {
+ if (node.getName().equals(name))
+ occurrences++;
+
+ }
+ return occurrences;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Link.java b/verigraph/src/it/polito/verigraph/model/Link.java
new file mode 100644
index 0000000..d17880b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Link.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "Link")
+public class Link {
+ @ApiModelProperty(required = false, hidden = true)
+ private String link;
+ @ApiModelProperty(required = false, hidden = true)
+ private String rel;
+
+ public String getLink() {
+ return link;
+ }
+
+ public void setLink(String link) {
+ this.link = link;
+ }
+
+ public String getRel() {
+ return rel;
+ }
+
+ public void setRel(String rel) {
+ this.rel = rel;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((link == null) ? 0 : link.hashCode());
+ result = prime * result + ((rel == null) ? 0 : rel.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ Link other = (Link) obj;
+ if (link == null) {
+ if (other.link != null)
+ return false;
+ }
+ else if (!link.equals(other.link))
+ return false;
+ if (rel == null) {
+ if (other.rel != null)
+ return false;
+ }
+ else if (!rel.equals(other.rel))
+ return false;
+ return true;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Neighbour.java b/verigraph/src/it/polito/verigraph/model/Neighbour.java
new file mode 100644
index 0000000..2c0a406
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Neighbour.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import javax.xml.bind.annotation.XmlTransient;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "Neighbour")
+public class Neighbour {
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private long id;
+
+ @ApiModelProperty(required = true,
+ example = "nat",
+ value = "The neighbour name must refer to an existing node of the same graph")
+ private String name;
+
+ public Neighbour() {
+
+ }
+
+ public Neighbour(long id, String name) {
+ this.id = id;
+ this.name = name;
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((name == null) ? 0 : name.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ else
+ return false;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Node.java b/verigraph/src/it/polito/verigraph/model/Node.java
new file mode 100644
index 0000000..4d54ffd
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Node.java
@@ -0,0 +1,151 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlTransient;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import it.polito.verigraph.deserializer.NodeCustomDeserializer;
+import it.polito.verigraph.serializer.CustomMapSerializer;
+
+@ApiModel(value = "Node")
+@XmlRootElement
+@JsonDeserialize(using = NodeCustomDeserializer.class)
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class Node {
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private long id;
+
+ @ApiModelProperty(required = true, example = "ep", value = "The name of the node can be any string")
+ private String name;
+
+ @ApiModelProperty(required = true,
+ example = "endpoint",
+ value = "The functional types that are currently supported are: endpoint, firewall, nat, antispam, webclient, webserver, mailclient, mailserver")
+ private String functional_type;
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private Configuration configuration= new Configuration();
+
+ @ApiModelProperty(name = "neighbours",
+ notes = "Neighbours",
+ dataType = "List[it.polito.verigraph.model.Neighbour]")
+ private Map<Long, Neighbour>neighbours= new HashMap<Long, Neighbour>();
+
+ @ApiModelProperty(required = false, hidden = true)
+ @XmlTransient
+ private Set<Link>links= new HashSet<>();
+
+ public Node() {
+
+ }
+
+ public Node(long id, String name, String functional_type, Configuration configuration) {
+ this.id = id;
+ this.name = name;
+ this.functional_type = functional_type;
+ this.configuration = configuration;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getFunctional_type() {
+ return functional_type;
+ }
+
+ public void setFunctional_type(String functional_type) {
+ this.functional_type = functional_type;
+ }
+
+ // @XmlTransient
+ public Configuration getConfiguration() {
+ return configuration;
+ }
+
+ public void setConfiguration(Configuration configuration) {
+ this.configuration = configuration;
+ }
+
+ @JsonSerialize(using = CustomMapSerializer.class)
+ public Map<Long, Neighbour> getNeighbours() {
+ return neighbours;
+ }
+
+ public void setNeighbours(Map<Long, Neighbour> neighbours) {
+ this.neighbours = neighbours;
+ }
+
+ public long getId() {
+ return this.id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Set<Link> getLinks() {
+ return links;
+ }
+
+ public void setLinks(Set<Link> links) {
+ this.links = links;
+ }
+
+ public void addLink(String url, String rel) {
+ Link link = new Link();
+ link.setLink(url);
+ link.setRel(rel);
+ links.add(link);
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((name == null) ? 0 : name.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ else
+ return false;
+ }
+
+ public Neighbour searchNeighbourByName(String name) {
+ for (Neighbour neighbour : this.neighbours.values()) {
+ if (neighbour.getName().equals(name))
+ return neighbour;
+ }
+ return null;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/model/Test.java b/verigraph/src/it/polito/verigraph/model/Test.java
new file mode 100644
index 0000000..4dc44f0
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Test.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Test {
+ private List<Node> nodes= new ArrayList<Node>();
+ private String result;
+
+ public Test() {
+
+ }
+
+ public Test(List<Node> paths, int result) {
+ switch (result) {
+ case 0:
+ this.result = "SAT";
+ break;
+ case -1:
+ this.result = "UNSAT";
+ break;
+ case -2:
+ this.result = "UNKNOWN";
+ break;
+ default:
+ this.result = "UNKNWON";
+ break;
+ }
+ this.nodes = paths;
+ }
+
+ public Test(List<Node> paths, String result) {
+ this.nodes = paths;
+ this.result = result;
+ }
+
+ public List<Node> getPath() {
+ return nodes;
+ }
+
+ public void setPath(List<Node> paths) {
+ this.nodes = paths;
+ }
+
+ public String getResult() {
+ return result;
+ }
+
+ public void setResult(String result) {
+ this.result = result;
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/model/Verification.java b/verigraph/src/it/polito/verigraph/model/Verification.java
new file mode 100644
index 0000000..1dad96e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/model/Verification.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * 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.verigraph.model;
+
+import java.util.ArrayList;
+import java.util.List;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel(value = "Policy verification")
+public class Verification {
+
+ @ApiModelProperty(example = "SAT | UNSAT | UNKNOWN")
+ private String result;
+ private String comment;
+ private List<Test> tests= new ArrayList<Test>();
+
+ public Verification() {
+
+ }
+
+ public Verification(String result) {
+ this.result = result;
+ }
+
+ public Verification(String result, List<Test> tests, String comment){
+ this.result = result;
+ this.tests = tests;
+ this.comment = comment;
+ }
+
+ public Verification(String result, String comment){
+ this.result = result;
+ this.comment = comment;
+ }
+
+ public String getResult() {
+ return result;
+ }
+
+ public void setResult(String result) {
+ this.result = result;
+ }
+
+ public List<Test> getTests() {
+ return tests;
+ }
+
+ public void setTests(List<Test> tests) {
+ this.tests = tests;
+ }
+
+ public String getComment() {
+ return comment;
+ }
+
+ public void setComment(String comment) {
+ this.comment = comment;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/resources/GraphResource.java b/verigraph/src/it/polito/verigraph/resources/GraphResource.java
new file mode 100644
index 0000000..cae90e7
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/resources/GraphResource.java
@@ -0,0 +1,194 @@
+/*******************************************************************************
+ * 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.verigraph.resources;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.List;
+import javax.ws.rs.BeanParam;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import javax.xml.bind.JAXBException;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import it.polito.neo4j.exceptions.MyInvalidDirectionException;
+import it.polito.neo4j.exceptions.MyInvalidIdException;
+import it.polito.neo4j.exceptions.MyNotFoundException;
+import it.polito.verigraph.model.ErrorMessage;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.model.Verification;
+import it.polito.verigraph.resources.beans.VerificationBean;
+import it.polito.verigraph.service.GraphService;
+import it.polito.verigraph.service.VerificationService;
+
+@Path("/graphs")
+@Api(value = "/graphs", description = "Manage graphs")
+@Consumes(MediaType.APPLICATION_JSON)
+@Produces(MediaType.APPLICATION_JSON)
+public class GraphResource {
+ GraphService graphService= new GraphService();
+ VerificationService verificationService= new VerificationService();
+
+ @GET
+ @ApiOperation(httpMethod = "GET",
+ value = "Returns all graphs",
+ notes = "Returns an array of graphs",
+ response = Graph.class,
+ responseContainer = "List")
+ @ApiResponses(value = { @ApiResponse(code = 200,
+ message = "All the graphs have been returned in the message body",
+ response = Graph.class,
+ responseContainer = "List"),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class)})
+ public List<Graph> getGraphs() throws JsonProcessingException, MyNotFoundException {
+ return graphService.getAllGraphs();
+ }
+
+ @POST
+ @ApiOperation(httpMethod = "POST",
+ value = "Creates a graph",
+ notes = "Creates a signle graph",
+ response = Response.class)
+ @ApiResponses(value = {@ApiResponse(code = 400, message = "Invalid graph supplied", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 201, message = "Graph successfully created", response = Graph.class) })
+ public Response addGraph(@ApiParam(value = "New graph object", required = true) Graph graph,
+ @Context UriInfo uriInfo) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+ Graph newGraph = graphService.addGraph(graph);
+ String newId = String.valueOf(newGraph.getId());
+ URI uri = uriInfo.getAbsolutePathBuilder().path(newId).build();
+ return Response.created(uri).entity(newGraph).build();
+ }
+
+ @GET
+ @Path("/{graphId}")
+ @ApiOperation(httpMethod = "GET",
+ value = "Returns a graph",
+ notes = "Returns a signle graph",
+ response = Graph.class)
+ @ApiResponses(value = {@ApiResponse(code = 403, message = "Invalid graph id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200,
+ message = "The requested graph has been returned in the message body",
+ response = Graph.class) })
+ public Graph getGraph(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @Context UriInfo uriInfo) throws JsonParseException, JsonMappingException, JAXBException, IOException {
+ Graph graph = graphService.getGraph(graphId);
+ graph.addLink(getUriForSelf(uriInfo, graph), "self");
+ graph.addLink(getUriForNodes(uriInfo, graph), "nodes");
+ return graph;
+ }
+
+ @PUT
+ @Path("/{graphId}")
+ @ApiOperation(httpMethod = "PUT", value = "Edits a graph", notes = "Edits a single graph", response = Graph.class)
+ @ApiResponses(value = {@ApiResponse(code = 400, message = "Invalid graph object", response = ErrorMessage.class),
+ @ApiResponse(code = 403, message = "Invalid graph id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "Graph edited successfully", response = Graph.class) })
+ public Graph updateGraph(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long id,
+ @ApiParam(value = "Updated graph object", required = true) Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+ graph.setId(id);
+ return graphService.updateGraph(graph);
+ }
+
+ @DELETE
+ @Path("/{graphId}")
+ @ApiOperation(httpMethod = "DELETE", value = "Deletes a graph", notes = "Deletes a signle graph")
+ @ApiResponses(value = {@ApiResponse(code = 403, message = "Invalid graph id", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 204, message = "Graph successfully deleted") })
+ public void deleteGraph(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long id) {
+ graphService.removeGraph(id);
+ }
+
+ @GET
+ @Path("/{graphId}/policy")
+ @ApiOperation(httpMethod = "GET",
+ value = "Verifies a given policy in a graph",
+ notes = "In order to verify a given policy (e.g. 'reachability') all nodes of the desired graph must have a valid configuration.")
+ @ApiResponses(value = {@ApiResponse(code = 403,
+ message = "Invalid graph id or invalid configuration for source and/or destination node",
+ response = ErrorMessage.class),
+ @ApiResponse(code = 404,
+ message = "Graph not found or source node not found or destination node not found or configuration for source and/or destination node not available",
+ response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),})
+ public Verification verifyGraph(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "'source' and 'destination' must refer to names of existing nodes in the same graph, 'type' refers to the required verification between the two (e.g. 'reachability')",
+ required = true) @BeanParam VerificationBean verificationBean) throws MyInvalidDirectionException, JsonParseException, JsonMappingException, JAXBException, IOException {
+
+ return verificationService.verify(graphId, verificationBean);
+ }
+
+ private String getUriForSelf(UriInfo uriInfo, Graph graph) {
+ String uri = uriInfo.getBaseUriBuilder()
+ .path(GraphResource.class)
+ .path(Long.toString(graph.getId()))
+ .build()
+ .toString();
+ return uri;
+ }
+
+ @GET
+ @Path("/{graphId}/paths")
+ @ApiOperation(httpMethod = "GET",value = "Retrieve all paths between two nodes")
+ @ApiResponses(value = {@ApiResponse(code = 403,
+ message = "Invalid graph id or invalid configuration for source and/or destination node",
+ response = ErrorMessage.class),
+ @ApiResponse(code = 404,
+ message = "Graph not found or source node not found or destination node not found or configuration for source and/or destination node not available",
+ response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),})
+
+ public List<List<Node>> getPaths(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "'source' must refer to name of existing nodes in the same graph",
+ required = true) @QueryParam("source") String srcName,
+ @ApiParam(value = "'destination' must refer to name of existing nodes in the same graph",
+ required = true)@QueryParam("destination") String dstName) throws MyInvalidDirectionException, JsonParseException, JsonMappingException, JAXBException, IOException {
+
+ return verificationService.getPaths(graphId, srcName, dstName);
+ }
+
+ private String getUriForNodes(UriInfo uriInfo, Graph graph) {
+ String uri = uriInfo.getBaseUriBuilder()
+ .path(GraphResource.class)
+ .path(GraphResource.class, "getNodeResource")
+ // .path(NodeResource.class)
+ .resolveTemplate("graphId", graph.getId())
+ .build()
+ .toString();
+ return uri;
+ }
+
+ @Path("/{graphId}/nodes")
+ public NodeResource getNodeResource() {
+ return new NodeResource();
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/resources/NeighbourResource.java b/verigraph/src/it/polito/verigraph/resources/NeighbourResource.java
new file mode 100644
index 0000000..3758f6b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/resources/NeighbourResource.java
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * 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.verigraph.resources;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.List;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import javax.xml.bind.JAXBException;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import it.polito.verigraph.model.ErrorMessage;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.service.NeighbourService;
+
+//@Path("/")
+@Api( hidden= true, value = "", description = "Manage neighbours" )
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+public class NeighbourResource {
+ private NeighbourService neighboursService = new NeighbourService();
+
+ @GET
+ @ApiOperation(
+ httpMethod = "GET",
+ value = "Returns all neighbours of a given node belonging to a given graph",
+ notes = "Returns an array of neighbours of a given node belonging to a given graph",
+ response = Neighbour.class,
+ responseContainer = "List")
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node id", response=ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response=ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "All the neighbours have been returned in the message body", response=Neighbour.class, responseContainer="List")})
+ public List<Neighbour> getAllNeighbours(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId) throws JsonProcessingException{
+ return neighboursService.getAllNeighbours(graphId, nodeId);
+ }
+
+ @POST
+ @ApiOperation(
+ httpMethod = "POST",
+ value = "Adds a neighbour to a given node belonging to a given graph",
+ notes = "Adds single neighbour to a given node belonging to a given graph",
+ response = Neighbour.class)
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node id", response=ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response=ErrorMessage.class),
+ @ApiResponse(code = 400, message = "Invalid neighbour object", response=ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 201, message = "Neighbour successfully created", response=Neighbour.class)})
+ public Response addNeighbour(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "New neighbour object. Neighbour name must refer to the name of an existing node of the same graph", required = true) Neighbour neighbour,
+ @Context UriInfo uriInfo) throws JsonParseException, JsonMappingException, JAXBException, IOException{
+ Neighbour newNeighbour = neighboursService.addNeighbour(graphId, nodeId, neighbour);
+ String newId = String.valueOf(newNeighbour.getId());
+ URI uri = uriInfo.getAbsolutePathBuilder().path(newId).build();
+ return Response.created(uri)
+ .entity(newNeighbour)
+ .build();
+ }
+
+ @PUT
+ @Path("{neighbourId}")
+ @ApiOperation(
+ httpMethod = "PUT",
+ value = "Edits a neighbour of a given node belonging to a given graph",
+ notes = "Edits a single neighbour of a given node belonging to a given graph",
+ response = Neighbour.class)
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node and/or neighbour id", response=ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node and /or neighbour not found", response=ErrorMessage.class),
+ @ApiResponse(code = 400, message = "Invalid neighbour object", response=ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "Neighbour edited successfully", response=Neighbour.class)})
+ public Neighbour updateNeighbour(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "Neighbour id", required = true) @PathParam("neighbourId") long neighbourId,
+ @ApiParam(value = "Updated neighbour object. Neighbour name must refer to the name of an existing node of the same graph", required = true) Neighbour neighbour) throws JAXBException, IOException{
+ neighbour.setId(neighbourId);
+ return neighboursService.updateNeighbour(graphId, nodeId, neighbour);
+ }
+
+ @DELETE
+ @Path("{neighbourId}")
+ @ApiOperation(
+ httpMethod = "DELETE",
+ value = "Removes a neighbour from a given node belonging to a given graph",
+ notes = "Deletes a single neighbour of a given node belonging to a given graph",
+ response = Neighbour.class)
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node and/or neighbour id", response=ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response=ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 204, message = "Node successfully deleted")})
+ public void deleteNeighbour(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "Neighbour id", required = true) @PathParam("neighbourId") long neighbourId){
+ neighboursService.removeNeighbour(graphId, nodeId, neighbourId);
+ }
+
+ @GET
+ @Path("{neighbourId}")
+ @ApiOperation(
+ httpMethod = "GET",
+ value = "Returns a neighbour of a given node belonging to a given graph",
+ notes = "Returns a single neighbour of a given node belonging to a given graph",
+ response = Neighbour.class)
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node and/or neighbour id", response=ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node and /or neighbour not found", response=ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "The requested neighbour has been returned in the message body", response=Neighbour.class)})
+ public Neighbour getNeighbour(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "Neighbour id", required = true) @PathParam("neighbourId") long neighbourId) throws JsonProcessingException{
+ return neighboursService.getNeighbour(graphId, nodeId, neighbourId);
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/resources/NodeResource.java b/verigraph/src/it/polito/verigraph/resources/NodeResource.java
new file mode 100644
index 0000000..9fa7319
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/resources/NodeResource.java
@@ -0,0 +1,206 @@
+/*******************************************************************************
+ * 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.verigraph.resources;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import javax.xml.bind.JAXBException;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import it.polito.neo4j.exceptions.MyInvalidIdException;
+import it.polito.neo4j.exceptions.MyNotFoundException;
+import it.polito.neo4j.manager.Neo4jDBManager;
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.ForbiddenException;
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.ErrorMessage;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.service.GraphService;
+import it.polito.verigraph.service.NodeService;
+
+@Api( hidden= true, value = "", description = "Manage nodes" )
+@Consumes(MediaType.APPLICATION_JSON)
+@Produces(MediaType.APPLICATION_JSON)
+public class NodeResource {
+
+ NodeService nodeService = new NodeService();
+
+ @GET
+ @ApiOperation(
+ httpMethod = "GET",
+ value = "Returns all nodes of a given graph",
+ notes = "Returns an array of nodes belonging to a given graph",
+ response = Node.class,
+ responseContainer = "List")
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "All the nodes have been returned in the message body", response = Node.class, responseContainer = "List") })
+ public List<Node> getNodes(@ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyNotFoundException{
+ return nodeService.getAllNodes(graphId);
+ }
+
+ @POST
+ @ApiOperation(
+ httpMethod = "POST",
+ value = "Creates a node in a given graph",
+ notes = "Creates a single node for a given graph",
+ response = Response.class)
+ @ApiResponses(value = { @ApiResponse(code = 400, message = "Invalid node supplied", response = ErrorMessage.class),
+ @ApiResponse(code = 403, message = "Invalid graph id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 201, message = "Node successfully created", response = Node.class)})
+ public Response addNode(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "New node object", required = true) Node node,
+ @Context UriInfo uriInfo) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyInvalidIdException {
+ Node newNode = nodeService.addNode(graphId, node);
+ String newId = String.valueOf(newNode.getId());
+ URI uri = uriInfo.getAbsolutePathBuilder().path(newId).build();
+ return Response.created(uri)
+ .entity(newNode)
+ .build();
+ }
+
+ @GET
+ @Path("{nodeId}")
+ @ApiOperation(
+ httpMethod = "GET",
+ value = "Returns a node of a given graph",
+ notes = "Returns a single node of a given graph",
+ response = Node.class)
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "The requested node has been returned in the message body", response = Node.class)})
+ public Node getNode(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @Context UriInfo uriInfo) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyNotFoundException{
+ Node node = nodeService.getNode(graphId, nodeId);
+ node.addLink(getUriForSelf(uriInfo, graphId, node), "self");
+ node.addLink(getUriForNeighbours(uriInfo, graphId, node), "neighbours");
+ return node;
+ }
+
+ @PUT
+ @Path("{nodeId}/configuration")
+ @ApiOperation(
+ httpMethod = "PUT",
+ value = "Adds/edits a configuration to a node of a given graph",
+ notes = "Configures a node. Once all the nodes of a graph have been configured a given policy can be verified for the graph (e.g. 'reachability' between two nodes).")
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "Configuration updated for the requested node", response=Configuration.class)})
+ public Configuration addNodeConfiguration(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "Node configuration", required = true) Configuration nodeConfiguration,
+ @Context UriInfo uriInfo) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyNotFoundException, MyInvalidIdException{
+
+ Configuration conf=nodeService.addNodeConfiguration(graphId, nodeId, nodeConfiguration);
+ return conf;
+
+ }
+
+
+ @PUT
+ @Path("{nodeId}")
+ @ApiOperation(
+ httpMethod = "PUT",
+ value = "Edits a node of a given graph",
+ notes = "Edits a single node of a given graph",
+ response = Node.class)
+ @ApiResponses(value = { @ApiResponse(code = 400, message = "Invalid node object", response = ErrorMessage.class),
+ @ApiResponse(code = 403, message = "Invalid graph and/or node id", response = ErrorMessage.class),
+ @ApiResponse(code = 404, message = "Graph and/or node not found", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 200, message = "Node edited successfully", response = Node.class)})
+ public Node updateNode(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId,
+ @ApiParam(value = "Updated node object", required = true) Node node) throws JAXBException, IOException, MyInvalidIdException{
+ node.setId(nodeId);
+ return nodeService.updateNode(graphId, node);
+ }
+
+ @DELETE
+ @Path("{nodeId}")
+ @ApiOperation(
+ httpMethod = "DELETE",
+ value = "Deletes a node of a given graph",
+ notes = "Deletes a single node of a given graph")
+ @ApiResponses(value = { @ApiResponse(code = 403, message = "Invalid graph and/or node id", response = ErrorMessage.class),
+ @ApiResponse(code = 500, message = "Internal server error", response = ErrorMessage.class),
+ @ApiResponse(code = 204, message = "Node successfully deleted")})
+ public void deleteNode(
+ @ApiParam(value = "Graph id", required = true) @PathParam("graphId") long graphId,
+ @ApiParam(value = "Node id", required = true) @PathParam("nodeId") long nodeId) throws JsonParseException, JsonMappingException, JAXBException, IOException{
+ nodeService.removeNode(graphId, nodeId);
+ }
+
+ private String getUriForSelf(UriInfo uriInfo, long graphId, Node node) {
+ String uri = uriInfo.getBaseUriBuilder()
+ //.path(NodeResource.class)
+ .path(GraphResource.class)
+ .path(GraphResource.class, "getNodeResource")
+ .resolveTemplate("graphId", graphId)
+ .path(Long.toString(node.getId()))
+ .build()
+ .toString();
+ return uri;
+ }
+
+ private String getUriForNeighbours(UriInfo uriInfo, long graphId, Node node) {
+ String uri = uriInfo.getBaseUriBuilder()
+ .path(GraphResource.class)
+ .path(GraphResource.class, "getNodeResource")
+ .resolveTemplate("graphId", graphId)
+ .path(Long.toString(node.getId()))
+ .path("neighbours")
+ .build()
+ .toString();
+ // .path(NodeResource.class)
+ // .path(NodeResource.class, "getNeighbourResource")
+ // .path(NeighbourResource.class)
+ // .resolveTemplate("nodeId", node.getId())
+ // .build()
+ // .toString();
+ return uri;
+ }
+
+ @Path("{nodeId}/neighbours")
+ public NeighbourResource getNeighbourResource(){
+ return new NeighbourResource();
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/resources/beans/VerificationBean.java b/verigraph/src/it/polito/verigraph/resources/beans/VerificationBean.java
new file mode 100644
index 0000000..619ee46
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/resources/beans/VerificationBean.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * 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.verigraph.resources.beans;
+
+import javax.ws.rs.QueryParam;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+
+@ApiModel("Verification")
+public class VerificationBean {
+
+ @ApiModelProperty(example = "webclient", value = "Source node. Must refer to an existing node of the same graph")
+ private @QueryParam("source") String source;
+
+ @ApiModelProperty(example = "webserver",
+ value = "Destination node. Must refer to an existing node of the same graph")
+ private @QueryParam("destination") String destination;
+
+ @ApiModelProperty(example = "reachability",
+ value = "Verification policy ('reachability', 'isolation', 'traversal')")
+ private @QueryParam("type") String type;
+
+ @ApiModelProperty(example = "firewall",
+ value = "Absent if verification type is 'reachability', equal to the name of a middlebox to be avoided if verification type is 'isolation', equal to the name of a middlebox to be traversed if verification type is 'traversal'")
+ private @QueryParam("middlebox") String middlebox;
+
+ public String getSource() {
+ return source;
+ }
+
+ public void setSource(String source) {
+ this.source = source;
+ }
+
+ public String getDestination() {
+ return destination;
+ }
+
+ public void setDestination(String destination) {
+ this.destination = destination;
+ }
+
+ public String getType() {
+ return type;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public String getMiddlebox() {
+ return middlebox;
+ }
+
+ public void setMiddlebox(String middlebox) {
+ this.middlebox = middlebox;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/serializer/CustomConfigurationSerializer.java b/verigraph/src/it/polito/verigraph/serializer/CustomConfigurationSerializer.java
new file mode 100644
index 0000000..74efdd8
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/serializer/CustomConfigurationSerializer.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * 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.verigraph.serializer;
+
+import java.io.IOException;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import it.polito.verigraph.exception.InternalServerErrorException;
+import it.polito.verigraph.model.Configuration;
+
+public class CustomConfigurationSerializer extends JsonSerializer<Configuration> {
+
+ @Override
+ public void serialize(Configuration conf, JsonGenerator jgen, SerializerProvider provider)
+ throws IOException, JsonProcessingException {
+ try {
+ jgen.writeObject(conf.getConfiguration());
+ } catch (IOException e) {
+ throw new InternalServerErrorException("I/O error serializing a configuration object: " + e.getMessage());
+ }
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/serializer/CustomMapSerializer.java b/verigraph/src/it/polito/verigraph/serializer/CustomMapSerializer.java
new file mode 100644
index 0000000..9d057fd
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/serializer/CustomMapSerializer.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * 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.verigraph.serializer;
+
+import java.io.IOException;
+import java.util.Map;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import it.polito.verigraph.exception.InternalServerErrorException;
+
+public class CustomMapSerializer extends JsonSerializer<Map<?, ?>> {
+ @Override
+ public void serialize(final Map<?, ?> value, final JsonGenerator jgen, final SerializerProvider provider) {
+ try {
+ jgen.writeObject(value.values());
+ } catch (IOException e) {
+ throw new InternalServerErrorException("I/O error serializing a map: " + e.getMessage());
+ }
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/GraphService.java b/verigraph/src/it/polito/verigraph/service/GraphService.java
new file mode 100644
index 0000000..7e92281
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/GraphService.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.IOException;
+import java.util.List;
+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.manager.Neo4jDBManager;
+import it.polito.neo4j.exceptions.MyInvalidIdException;
+import it.polito.neo4j.exceptions.MyNotFoundException;
+import it.polito.verigraph.exception.ForbiddenException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+
+public class GraphService {
+
+ private Neo4jDBManager manager= new Neo4jDBManager();
+ public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+
+ public GraphService() {}
+
+ public List<Graph> getAllGraphs() throws JsonProcessingException, MyNotFoundException {
+ List<Graph> result;
+ result=manager.getGraphs();
+ for(Graph g : result){
+ validateGraph(g);
+ }
+ return result;
+ }
+
+ public Graph getGraph(long id) throws JsonParseException, JsonMappingException, JAXBException, IOException {
+ if (id < 0) {
+ throw new ForbiddenException("Illegal graph id: " + id);
+ }
+ Graph localGraph=manager.getGraph(id);
+ validateGraph(localGraph);
+ return localGraph;
+ }
+
+ public Graph updateGraph(Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+ if (graph.getId() < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graph.getId());
+ }
+ validateGraph(graph);
+ Graph localGraph=new Graph();
+ localGraph=manager.updateGraph(graph);
+ vlogger.logger.info("Graph updated");
+ validateGraph(localGraph);
+ return localGraph;
+ }
+
+
+ public void removeGraph(long id) {
+
+ if (id < 0) {
+ throw new ForbiddenException("Illegal graph id: " + id);
+ }
+ manager.deleteGraph(id);
+ }
+
+ public Graph addGraph(Graph graph) throws JAXBException, JsonParseException, JsonMappingException, IOException, MyInvalidIdException {
+ validateGraph(graph);
+ Graph g=manager.addGraph(graph);
+ validateGraph(g);
+ return g;
+ }
+
+ public static void validateGraph(Graph graph) throws JsonProcessingException {
+ for (Node node : graph.getNodes().values()) {
+ NodeService.validateNode(graph, node);
+ }
+ }
+}
diff --git a/verigraph/src/it/polito/verigraph/service/JsonValidationService.java b/verigraph/src/it/polito/verigraph/service/JsonValidationService.java
new file mode 100644
index 0000000..8f09a25
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/JsonValidationService.java
@@ -0,0 +1,132 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import org.apache.commons.lang3.text.WordUtils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+
+public class JsonValidationService {
+
+ private Graph graph= new Graph();
+ private Node node= new Node();
+ public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+
+ public JsonValidationService() {}
+
+ public JsonValidationService(Graph graph, Node node) {
+ this.graph = graph;
+ this.node = node;
+ }
+
+ public boolean validateFieldAgainstNodeNames(String value) {
+ for (Node node : this.graph.getNodes().values()) {
+ if (node.getName().equals(value))
+ return true;
+ }
+ return false;
+ }
+
+ public void validateFieldsAgainstNodeNames(JsonNode node) {
+ if (node.isTextual()) {
+ boolean isValid = validateFieldAgainstNodeNames(node.asText());
+ if (!isValid) {
+ vlogger.logger.info(node.asText() + " is not a valid string!");
+ //System.out.println(node.asText() + " is not a valid string!");
+ throw new BadRequestException("String '"+ node.asText()
+ + "' is not valid for the configuration of node '" + this.node.getName()
+ + "'");
+ }
+ }
+ if (node.isArray()) {
+ for (JsonNode object : node) {
+ validateFieldsAgainstNodeNames(object);
+ }
+ }
+ if (node.isObject()) {
+ Iterator<Entry<String, JsonNode>> iter = node.fields();
+ while (iter.hasNext()) {
+ Entry<String, JsonNode> item = iter.next();
+ validateFieldsAgainstNodeNames(item.getValue());
+ }
+ }
+
+ }
+
+ public boolean validateNodeConfiguration() {
+ String className = WordUtils.capitalize(node.getFunctional_type()) + "Validator";
+
+ Class<?> validator;
+ try {
+ validator = Class.forName("it.polito.verigraph.validation." + className);
+ }
+ catch (ClassNotFoundException e) {
+ vlogger.logger.info(className+ " not found, configuration properties of node '" + node.getName()
+ + "' will be validated against node names");
+ //System.out.println(className+ " not found, configuration properties of node '" + node.getName()
+ //+ "' will be validated against node names");
+ return false;
+ }
+
+ Class<?> graphClass;
+ Class<?> nodeClass;
+ Class<?> configurationClass;
+ try {
+ graphClass = Class.forName("it.polito.verigraph.model.Graph");
+ nodeClass = Class.forName("it.polito.verigraph.model.Node");
+ configurationClass = Class.forName("it.polito.verigraph.model.Configuration");
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException("Model classes not found");
+ }
+
+ Class<?>[] paramTypes = new Class[3];
+ paramTypes[0] = graphClass;
+ paramTypes[1] = nodeClass;
+ paramTypes[2] = configurationClass;
+ String methodName = "validate";
+ Object instance;
+ try {
+ instance = validator.newInstance();
+ }
+ catch (InstantiationException e) {
+ throw new RuntimeException("'" + className + "' cannot be instantiated");
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException("Illegal access to '" + className + "' instantiation");
+ }
+ Method myMethod;
+ try {
+ myMethod = validator.getDeclaredMethod(methodName, paramTypes);
+ }
+ catch (NoSuchMethodException e) {
+ throw new RuntimeException("'" + methodName + "' method has to be implemented in " + className + " class");
+ }
+ try {
+ myMethod.invoke(instance, graph, node, node.getConfiguration());
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException("Illegal access to '" + methodName + "' method in " + className + " instance");
+ }
+ catch (InvocationTargetException e) {
+ throw new BadRequestException("Validation failed for node '"+ node.getName() + "': "
+ + e.getTargetException().getMessage());
+ }
+ return true;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/NeighbourService.java b/verigraph/src/it/polito/verigraph/service/NeighbourService.java
new file mode 100644
index 0000000..ab557bf
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/NeighbourService.java
@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+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.manager.Neo4jDBManager;
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.exception.ForbiddenException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+
+public class NeighbourService {
+
+ private Neo4jDBManager manager=new Neo4jDBManager();
+
+
+ public List<Neighbour> getAllNeighbours(long graphId, long nodeId) throws JsonProcessingException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+
+ Map<Long, Neighbour> neighbours = manager.getNeighbours(graphId, nodeId);
+ return new ArrayList<Neighbour>(neighbours.values());
+ }
+
+ public Neighbour getNeighbour(long graphId, long nodeId, long neighbourId) throws JsonProcessingException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+ if (neighbourId < 0) {
+ throw new ForbiddenException("Illegal neighbour id: " + neighbourId);
+ }
+
+ Neighbour neighbour=manager.getNeighbour(graphId, nodeId, neighbourId);
+ if (neighbour == null) {
+ throw new DataNotFoundException("Neighbour with id "+ neighbourId + " not found for node with id " + nodeId
+ + " in graph with id " + graphId);
+ }
+ return neighbour;
+ }
+
+ public Neighbour addNeighbour(long graphId, long nodeId, Neighbour neighbour) throws JsonParseException, JsonMappingException, JAXBException, IOException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+ Graph graph = manager.getGraph(graphId);
+ Node node=manager.getNodeById(nodeId, graphId);
+ validateNeighbour(graph, node, neighbour);
+ Neighbour out=manager.addNeighbours(graphId, nodeId, neighbour);
+ validateNeighbour(graph, node, neighbour);
+ return out;
+ }
+
+ public Neighbour updateNeighbour(long graphId, long nodeId, Neighbour neighbour) throws JAXBException, IOException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+ if (neighbour.getId() < 0) {
+ throw new ForbiddenException("Illegal neighbour id: " + nodeId);
+ }
+ Graph graph=manager.getGraph(graphId);
+ Node node=manager.getNodeById(nodeId, graphId);
+ if (node == null) {
+ throw new DataNotFoundException("Node with id " + nodeId + " not found in graph with id " + graphId);
+ }
+
+ validateNeighbour(graph, node, neighbour);
+ Neighbour n=manager.updateNeighbour(graphId, nodeId, neighbour);
+
+ return n;
+ }
+
+ public Neighbour removeNeighbour(long graphId, long nodeId, long neighbourId) {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+ if (neighbourId < 0) {
+ throw new ForbiddenException("Illegal neighbour id: " + nodeId);
+ }
+
+ Neighbour n=manager.deleteNeighbour(graphId, nodeId, neighbourId);
+ return n;
+ }
+
+ public static void validateNeighbour(Graph graph, Node node, Neighbour neighbour) throws JsonProcessingException {
+ if (graph == null)
+ throw new BadRequestException("Neighbour validation failed: cannot validate null graph");
+ if (node == null)
+ throw new BadRequestException("Neighbour validation failed: cannot validate null node");
+ if (neighbour == null)
+ throw new BadRequestException("Neighbour validation failed: cannot validate null neighbour");
+
+ if (neighbour.getName() == null)
+ throw new BadRequestException("Neighbour validation failed: neighbour 'name' field cannot be null");
+ if (neighbour.getName().equals(""))
+ throw new BadRequestException("Neighbour validation failed: neighbour 'name' field cannot be an empty string");
+
+ //Node nodeFound = graph.searchNodeByName(neighbour.getName());
+
+ Node nodeFound=graph.searchNodeByName(neighbour.getName());
+ if ((nodeFound == null) || (nodeFound.getName().equals(node.getName())))
+ throw new BadRequestException("Neighbour validation failed: '"+ neighbour.getName()
+ + "' is not a valid name for a neighbour of node '" + node.getName() + "'");
+
+ Neighbour neighbourFound = node.searchNeighbourByName(neighbour.getName());
+ if ((neighbourFound != null) && (neighbourFound.equals(neighbour) == false))
+ throw new BadRequestException("Neighbour validation failed: node '"+ node.getName()
+ + "' already has a neighbour named '" + neighbour.getName() + "'");
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/NodeService.java b/verigraph/src/it/polito/verigraph/service/NodeService.java
new file mode 100644
index 0000000..ffd6751
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/NodeService.java
@@ -0,0 +1,223 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.ws.rs.InternalServerErrorException;
+import javax.xml.bind.JAXBException;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.github.fge.jsonschema.core.exceptions.ProcessingException;
+import com.github.fge.jsonschema.main.JsonSchema;
+import it.polito.neo4j.exceptions.MyInvalidIdException;
+import it.polito.neo4j.exceptions.MyNotFoundException;
+import it.polito.neo4j.manager.Neo4jDBManager;
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.exception.ForbiddenException;
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Neighbour;
+import it.polito.verigraph.model.Node;
+
+public class NodeService {
+
+ private Neo4jDBManager manager=new Neo4jDBManager();
+
+ public NodeService() {}
+
+ public List<Node> getAllNodes(long graphId) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyNotFoundException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+
+ /*il controllo sull'esistenza del grafo viene fatto all'interno della getNodes
+
+ */
+
+ Map<Long, Node> nodes =manager.getNodes(graphId);
+ return new ArrayList<Node>(nodes.values());
+ }
+
+ public Node getNode(long graphId, long nodeId) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyNotFoundException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+
+ Node node=manager.getNodeById(nodeId, graphId);
+ if (node == null) {
+ throw new DataNotFoundException("Node with id " + nodeId + " not found in graph with id " + graphId);
+ }
+ return node;
+ }
+
+ public Node updateNode(long graphId, Node node) throws JAXBException, IOException, MyInvalidIdException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (node.getId() < 0) {
+ throw new ForbiddenException("Illegal node id: " + node.getId());
+ }
+
+ Graph graph=manager.getGraph(graphId);
+ validateNode(graph, node);
+
+ Node n=manager.updateNode(graphId, node, node.getId());
+ validateNode(graph, n);
+
+ return n;
+ }
+
+ public Node removeNode(long graphId, long nodeId) throws JsonParseException, JsonMappingException, JAXBException, IOException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+
+ Graph graph=manager.getGraph(graphId);
+ if (graph == null)
+ throw new DataNotFoundException("Graph with id " + graphId + " not found");
+ Node n=manager.deleteNode(graphId, nodeId);
+ return n;
+ }
+
+ public Node addNode(long graphId, Node node) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyInvalidIdException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+
+ Graph graph=manager.getGraph(graphId);
+ validateNode(graph, node);
+ Node n=manager.addNode(graphId, node);
+ validateNode(graph, n);
+ return n;
+ }
+
+ public Node searchByName(long graphId, String nodeName) throws JsonParseException, JsonMappingException, JAXBException, IOException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ Graph graph = manager.getGraph(graphId);
+ if (graph == null)
+ throw new DataNotFoundException("Graph with id " + graphId + " not found");
+ Map<Long, Node> nodes = graph.getNodes();
+ for (Node node : nodes.values()) {
+ if (node.getName().equals(nodeName))
+ return node;
+ }
+ return null;
+ }
+
+ public static void validateNode(Graph graph, Node node) throws JsonProcessingException {
+ if (graph == null)
+ throw new BadRequestException("Node validation failed: cannot validate null graph");
+ if (node == null)
+ throw new BadRequestException("Node validation failed: cannot validate null node");
+
+ if (node.getName() == null)
+ throw new BadRequestException("Node validation failed: node 'name' field cannot be null");
+ if (node.getFunctional_type() == null)
+ throw new BadRequestException("Node validation failed: node 'functional_type' field cannot be null");
+
+ if (node.getName().equals(""))
+ throw new BadRequestException("Node validation failed: node 'name' field cannot be an empty string");
+ if (node.getFunctional_type().equals(""))
+ throw new BadRequestException("Node validation failed: node 'functional_type' field cannot be an empty string");
+
+ Node nodeFound =graph.searchNodeByName(node.getName());
+ if ((nodeFound != null) && (nodeFound.equals(node) == false))
+ throw new BadRequestException("Node validation failed: graph already has a node named '"+ node.getName()
+ + "'");
+ Configuration configuration = node.getConfiguration();
+ if (configuration != null) {
+ JsonNode configurationJsonNode = configuration.getConfiguration();
+ // validate configuration against schema file
+ validateNodeConfigurationAgainstSchemaFile(node, configurationJsonNode);
+ JsonValidationService jsonValidator = new JsonValidationService(graph, node);
+ boolean hasCustomValidator = jsonValidator.validateNodeConfiguration();
+ if (!hasCustomValidator) {
+ jsonValidator.validateFieldsAgainstNodeNames(configurationJsonNode);
+ }
+ }
+
+ // validate neighbours
+ Map<Long, Neighbour> nodeNeighboursMap = node.getNeighbours();
+ if (nodeNeighboursMap == null)
+ throw new BadRequestException("Node validation failed: node 'neighbours' cannot be null");
+ for (Neighbour neighbour : nodeNeighboursMap.values()) {
+ NeighbourService.validateNeighbour(graph, node, neighbour);
+ }
+ }
+
+ public static void validateNodeConfigurationAgainstSchemaFile(Node node, JsonNode configurationJson) {
+ String schemaFileName = node.getFunctional_type() + ".json";
+
+ File schemaFile = new File(System.getProperty("catalina.base") + "/webapps/verigraph/jsonschema/" + schemaFileName);
+
+ if (!schemaFile.exists()) {
+ //if no REST client, try gRPC application
+ schemaFile = new File(System.getProperty("user.dir") + "/jsonschema/" + schemaFileName);
+
+ if (!schemaFile.exists()) {
+ throw new ForbiddenException("Functional type '"+ node.getFunctional_type()
+ + "' is not supported! Please edit 'functional_type' field of node '"
+ + node.getName() + "'");
+ }
+ }
+
+ JsonSchema schemaNode = null;
+ try {
+ schemaNode = ValidationUtils.getSchemaNode(schemaFile);
+ }
+ catch (IOException e) {
+ throw new InternalServerErrorException("Unable to load '" + schemaFileName + "' schema file");
+ }
+ catch (ProcessingException e) {
+ throw new InternalServerErrorException("Unable to resolve '"+ schemaFileName
+ + "' schema file as a schema node");
+ }
+
+ try {
+ ValidationUtils.validateJson(schemaNode, configurationJson);
+ }
+ catch (ProcessingException e) {
+ throw new BadRequestException("Something went wrong trying to validate node '"+ node.getName()
+ + "' with the following configuration: '" + configurationJson.toString()
+ + "' against the json schema '" + schemaFile.getName() + "': "
+ + e.getMessage());
+ }
+
+ }
+
+ public Configuration addNodeConfiguration(long graphId, long nodeId, Configuration nodeConfiguration) throws IOException, MyInvalidIdException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ if (nodeId < 0) {
+ throw new ForbiddenException("Illegal node id: " + nodeId);
+ }
+
+ Node node=manager.getNodeById(nodeId, graphId);
+ validateNodeConfigurationAgainstSchemaFile(node, nodeConfiguration.getConfiguration());
+ Configuration newConf=manager.updateConfiguration(nodeId, graphId, nodeConfiguration, node);
+ return newConf;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/ValidationUtils.java b/verigraph/src/it/polito/verigraph/service/ValidationUtils.java
new file mode 100644
index 0000000..d64b544
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/ValidationUtils.java
@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.github.fge.jackson.JsonLoader;
+import com.github.fge.jsonschema.core.exceptions.ProcessingException;
+import com.github.fge.jsonschema.core.report.ProcessingMessage;
+import com.github.fge.jsonschema.core.report.ProcessingReport;
+import com.github.fge.jsonschema.main.JsonSchema;
+import com.github.fge.jsonschema.main.JsonSchemaFactory;
+
+public class ValidationUtils {
+
+ public static final String JSON_V4_SCHEMA_IDENTIFIER= "http://json-schema.org/draft-04/schema#";
+ public static final String JSON_SCHEMA_IDENTIFIER_ELEMENT= "$schema";
+
+ public static JsonNode getJsonNode(String jsonText) throws IOException {
+ return JsonLoader.fromString(jsonText);
+ } // getJsonNode(text) ends
+
+ public static JsonNode getJsonNode(File jsonFile) throws IOException {
+ return JsonLoader.fromFile(jsonFile);
+ } // getJsonNode(File) ends
+
+ public static JsonNode getJsonNode(URL url) throws IOException {
+ return JsonLoader.fromURL(url);
+ } // getJsonNode(URL) ends
+
+ public static JsonNode getJsonNodeFromResource(String resource) throws IOException {
+ return JsonLoader.fromResource(resource);
+ } // getJsonNode(Resource) ends
+
+ public static JsonSchema getSchemaNode(String schemaText) throws IOException, ProcessingException {
+ final JsonNode schemaNode = getJsonNode(schemaText);
+ return _getSchemaNode(schemaNode);
+ } // getSchemaNode(text) ends
+
+ public static JsonSchema getSchemaNode(File schemaFile) throws IOException, ProcessingException {
+ final JsonNode schemaNode = getJsonNode(schemaFile);
+ return _getSchemaNode(schemaNode);
+ } // getSchemaNode(File) ends
+
+ public static JsonSchema getSchemaNode(URL schemaFile) throws IOException, ProcessingException {
+ final JsonNode schemaNode = getJsonNode(schemaFile);
+ return _getSchemaNode(schemaNode);
+ } // getSchemaNode(URL) ends
+
+ public static JsonSchema getSchemaNodeFromResource(String resource) throws IOException, ProcessingException {
+ final JsonNode schemaNode = getJsonNodeFromResource(resource);
+ return _getSchemaNode(schemaNode);
+ } // getSchemaNode() ends
+
+ public static void validateJson(JsonSchema jsonSchemaNode, JsonNode jsonNode) throws ProcessingException {
+ ProcessingReport report = jsonSchemaNode.validate(jsonNode);
+ if (!report.isSuccess()) {
+ for (ProcessingMessage processingMessage : report) {
+ throw new ProcessingException(processingMessage);
+ }
+ }
+ } // validateJson(Node) ends
+
+ public static boolean isJsonValid(JsonSchema jsonSchemaNode, JsonNode jsonNode) throws ProcessingException {
+ ProcessingReport report = jsonSchemaNode.validate(jsonNode);
+ return report.isSuccess();
+ } // validateJson(Node) ends
+
+ public static boolean isJsonValid(String schemaText, String jsonText) throws ProcessingException, IOException {
+ final JsonSchema schemaNode = getSchemaNode(schemaText);
+ final JsonNode jsonNode = getJsonNode(jsonText);
+ return isJsonValid(schemaNode, jsonNode);
+ } // validateJson(Node) ends
+
+ public static boolean isJsonValid(File schemaFile, File jsonFile) throws ProcessingException, IOException {
+ final JsonSchema schemaNode = getSchemaNode(schemaFile);
+ final JsonNode jsonNode = getJsonNode(jsonFile);
+ return isJsonValid(schemaNode, jsonNode);
+ } // validateJson(Node) ends
+
+ public static boolean isJsonValid(URL schemaURL, URL jsonURL) throws ProcessingException, IOException {
+ final JsonSchema schemaNode = getSchemaNode(schemaURL);
+ final JsonNode jsonNode = getJsonNode(jsonURL);
+ return isJsonValid(schemaNode, jsonNode);
+ } // validateJson(Node) ends
+
+ public static void validateJson(String schemaText, String jsonText) throws IOException, ProcessingException {
+ final JsonSchema schemaNode = getSchemaNode(schemaText);
+ final JsonNode jsonNode = getJsonNode(jsonText);
+ validateJson(schemaNode, jsonNode);
+ } // validateJson(text) ends
+
+ public static void validateJson(File schemaFile, File jsonFile) throws IOException, ProcessingException {
+ final JsonSchema schemaNode = getSchemaNode(schemaFile);
+ final JsonNode jsonNode = getJsonNode(jsonFile);
+ validateJson(schemaNode, jsonNode);
+ } // validateJson(File) ends
+
+ public static void validateJson(URL schemaDocument, URL jsonDocument) throws IOException, ProcessingException {
+ final JsonSchema schemaNode = getSchemaNode(schemaDocument);
+ final JsonNode jsonNode = getJsonNode(jsonDocument);
+ validateJson(schemaNode, jsonNode);
+ } // validateJson(URL) ends
+
+ public static void validateJsonResource(String schemaResource, String jsonResource)throws IOException,
+ ProcessingException {
+ final JsonSchema schemaNode = getSchemaNode(schemaResource);
+ final JsonNode jsonNode = getJsonNodeFromResource(jsonResource);
+ validateJson(schemaNode, jsonNode);
+ } // validateJsonResource() ends
+
+ private static JsonSchema _getSchemaNode(JsonNode jsonNode) throws ProcessingException {
+ final JsonNode schemaIdentifier = jsonNode.get(JSON_SCHEMA_IDENTIFIER_ELEMENT);
+ if (null == schemaIdentifier) {
+ ((ObjectNode) jsonNode).put(JSON_SCHEMA_IDENTIFIER_ELEMENT, JSON_V4_SCHEMA_IDENTIFIER);
+ }
+
+ final JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
+ return factory.getJsonSchema(jsonNode);
+ } // _getSchemaNode() ends
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/VerificationService.java b/verigraph/src/it/polito/verigraph/service/VerificationService.java
new file mode 100644
index 0000000..227ea4b
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/VerificationService.java
@@ -0,0 +1,625 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import javax.xml.bind.JAXBException;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.microsoft.z3.*;
+import it.polito.neo4j.exceptions.MyInvalidDirectionException;
+import it.polito.neo4j.jaxb.Paths;
+import it.polito.neo4j.manager.Neo4jDBManager;
+import it.polito.neo4j.manager.Neo4jLibrary;
+import it.polito.neo4j.translator.*;
+import it.polito.verigraph.exception.BadRequestException;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.exception.ForbiddenException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.model.Test;
+import it.polito.verigraph.model.Verification;
+import it.polito.verigraph.resources.beans.VerificationBean;
+import it.polito.verigraph.solver.GeneratorSolver;
+import it.polito.verigraph.solver.Scenario;
+
+public class VerificationService {
+
+ private Neo4jDBManager manager=new Neo4jDBManager();
+ //private final static Logger LOGGER = Logger.getLogger(VerigraphLogger.class.getName());
+ public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+
+ public VerificationService() {}
+
+ private Paths getPaths(Graph graph, Node sourceNode, Node destinationNode) throws MyInvalidDirectionException {
+
+ String source = sourceNode.getName();
+ String destination = destinationNode.getName();
+ Paths paths;
+ paths=manager.getPath(graph.getId(), source, destination, "outgoing");
+ return paths;
+ }
+
+ private List<List<String>> sanitizePaths(Paths paths) {
+ List<List<String>> sanitizedPaths = new ArrayList<List<String>>();
+ for (String path : paths.getPath()) {
+ List<String> newPath = extractPath(path);
+ sanitizedPaths.add(newPath);
+ }
+ return sanitizedPaths;
+ }
+
+ private List<String> extractPath(String path) {
+ List<String> newPath = new ArrayList<String>();
+ // find all nodes, i.e. all names between parentheses
+ Matcher m = Pattern.compile("\\(([^)]+)\\)").matcher(path);
+ while (m.find()) {
+ String node = m.group(1);
+ newPath.add(node);
+ }
+ return newPath;
+ }
+
+ private void printListsOfStrings(String message, List<List<String>> lists) {
+ vlogger.logger.info(message);
+ for (List<String> element : lists) {
+ StringBuilder paths= new StringBuilder();
+ for(String s : element){
+ paths.append(s+" ");
+ }
+ vlogger.logger.info(paths.toString());
+ //System.out.println(element);
+ }
+ }
+
+ public Verification verify(long graphId, VerificationBean verificationBean) throws MyInvalidDirectionException, JsonParseException, JsonMappingException, JAXBException, IOException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ GraphService graphService = new GraphService();
+ Graph graph = graphService.getGraph(graphId);
+ if (graph == null) {
+ throw new DataNotFoundException("Graph with id " + graphId + " not found");
+ }
+ String source = verificationBean.getSource();
+ String destination = verificationBean.getDestination();
+ String type = verificationBean.getType();
+ if (source == null || source.equals("")) {
+ throw new BadRequestException("Please specify the 'source' parameter in your request");
+ }
+ if (destination == null || destination.equals("")) {
+ throw new BadRequestException("Please specify the 'destination' parameter in your request");
+ }
+ if (type == null || type.equals("")) {
+ throw new BadRequestException("Please specify the 'type' parameter in your request");
+ }
+
+ Node sourceNode = graph.searchNodeByName(verificationBean.getSource());
+ Node destinationNode = graph.searchNodeByName(verificationBean.getDestination());
+
+ if (sourceNode == null) {
+ throw new BadRequestException("The 'source' parameter '" + source + "' is not valid, please insert the name of an existing node");
+ }
+ if (destinationNode == null) {
+ throw new BadRequestException("The 'destination' parameter '" + destination + "' is not valid, please insert the name of an existing node");
+ }
+ if ((!type.equals("reachability")) && (!type.equals("isolation")) && (!type.equals("traversal"))) {
+ throw new BadRequestException("The 'type' parameter '"+ type
+ + "' is not valid: valid types are: 'reachability', 'isolation' and 'traversal'");
+ }
+
+ Verification v = null;
+ String middlebox;
+ Node middleboxNode;
+ switch (type) {
+ case "reachability":
+ v = reachabilityVerification(graph, sourceNode, destinationNode);
+ break;
+ case "isolation":
+ middlebox = verificationBean.getMiddlebox();
+ if (middlebox == null || middlebox.equals("")) {
+ throw new BadRequestException("Please specify the 'middlebox' parameter in your request");
+ }
+
+ middleboxNode = graph.searchNodeByName(middlebox);
+ if (middleboxNode == null) {
+ throw new BadRequestException("The 'middlebox' parameter '" + middlebox + "' is not valid, please insert the name of an existing node");
+ }
+ if (middleboxNode.getFunctional_type().equals("endpoint")) {
+ throw new BadRequestException("'"+ middlebox
+ + "' is of type 'endpoint', please choose a valid middlebox");
+ }
+ v = isolationVerification(graph, sourceNode, destinationNode, middleboxNode);
+ break;
+ case "traversal":
+ middlebox = verificationBean.getMiddlebox();
+ if (middlebox == null || middlebox.equals("")) {
+ throw new BadRequestException("Please specify the 'middlebox' parameter in your request");
+ }
+
+ middleboxNode = graph.searchNodeByName(middlebox);
+ if (middleboxNode == null) {
+ throw new BadRequestException("The 'middlebox' parameter '" + middlebox + "' is not valid, please insert the name of an existing node");
+ }
+ if (middleboxNode.getFunctional_type().equals("endpoint")) {
+ throw new BadRequestException("'"+ middlebox
+ + "' is of type 'endpoint', please choose a valid middlebox");
+ }
+ v = traversalVerification(graph, sourceNode, destinationNode, middleboxNode);
+ break;
+ default:
+ break;
+ }
+ return v;
+ }
+
+ private Verification isolationVerification(Graph graph, Node sourceNode, Node destinationNode, Node middleboxNode) throws MyInvalidDirectionException {
+ Long time_isolation=(long) 0;
+ Calendar cal_isolation = Calendar.getInstance();
+ Date start_time_isolation = cal_isolation.getTime();
+ Paths paths = getPaths(graph, sourceNode, destinationNode);
+ if (paths.getPath().size() == 0) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+
+ List<List<String>> sanitizedPaths = sanitizePaths(paths);
+ List<Test> tests = extractTestsFromPaths(graph, sanitizedPaths, "UNKNWON");
+
+ //printListsOfStrings("sanitizedPaths", sanitizedPaths);
+
+ if (sanitizedPaths.isEmpty()) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+ extractPathsWithoutMiddlebox(sanitizedPaths, middleboxNode.getName());
+
+ if (sanitizedPaths.isEmpty()) {
+ return new Verification("UNSAT",
+ tests,
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "' which no traverse middlebox '"
+ + middleboxNode.getName() + "'. See below all the available paths.");
+ }
+
+ //printListsOfStrings("Paths with middlebox '" + middleboxNode.getName() + "'", sanitizedPaths);
+
+ Map<Integer, GeneratorSolver> scenarios=createScenarios(sanitizedPaths, graph);
+
+ tests = run(graph, scenarios, sourceNode.getName(), destinationNode.getName());
+ Verification isolation=evaluateIsolationResults(tests, sourceNode.getName(),
+ destinationNode.getName(),
+ middleboxNode.getName());
+ Calendar cal_isolation_stop = Calendar.getInstance();
+ time_isolation = time_isolation +(cal_isolation_stop.getTime().getTime() - start_time_isolation.getTime());
+ vlogger.logger.info("Time to check reachability policy: " + time_isolation);
+ //System.out.println("Time to check reachability policy: " + time_isolation);
+ return isolation;
+ }
+
+ private List<Test> extractTestsFromPaths(Graph graph, List<List<String>> paths, String result) {
+ List<Test> tests = new ArrayList<Test>();
+ for (List<String> path : paths) {
+ List<Node> nodes = new ArrayList<Node>();
+ for (String nodeName : path) {
+ nodes.add(graph.searchNodeByName(nodeName));
+ }
+ tests.add(new Test(nodes, result));
+ }
+ return tests;
+ }
+
+ private Verification evaluateIsolationResults(List<Test> tests, String source, String destination,
+ String middlebox) {
+ Verification v = new Verification();
+ boolean isSat = false;
+ int unsatCounter = 0;
+ for (Test t : tests) {
+ v.getTests().add(t);
+ if (t.getResult().equals("SAT")) {
+ isSat = true;
+ }
+ else if (t.getResult().equals("UNKNOWN")) {
+ v.setResult("UNKNOWN");
+ v.setComment("Isolation property with source '"+ source + "', destination '" + destination
+ + "' and middlebox '" + middlebox + "' is UNKNOWN because although '" + source
+ + "' cannot reach '" + middlebox + "' in any path from '" + source + "' to '"
+ + destination + "' which traverses middlebox '" + middlebox
+ + "' at least one reachability test between '" + source + "' and '" + middlebox
+ + "' returned UNKNOWN (see below all the paths that have been checked)");
+ }
+ else if (t.getResult().equals("UNSAT")) {
+ unsatCounter++;
+ }
+ }
+ if (isSat) {
+ v.setResult("SAT");
+ v.setComment("Isolation property with source '"+ source + "', destination '" + destination
+ + "' and middlebox '" + middlebox + "' is SATISFIED because reachability between '" + source
+ + "' and '" + middlebox + "' is UNSATISFIED in all paths between '" + source + "' and '"
+ + destination + "' which traverse middlebox '" + middlebox
+ + "' (see below all the paths that have been checked)");
+
+ }
+ else if (unsatCounter == tests.size()) {
+ v.setResult("UNSAT");
+ v.setComment("Isolation property with source '"+ source + "', destination '" + destination
+ + "' and middlebox '" + middlebox + "' is UNSATISFIED because reachability between '"
+ + source + "' and '" + middlebox + "' is SATISFIED in at least one path between '" + source
+ + "' and '" + destination + "' which traverses middlebox '" + middlebox
+ + "' (see below all the paths that have been checked)");
+ }
+ return v;
+ }
+
+ private void extractPathsWithMiddlebox(List<List<String>> sanitizedPaths, String middleboxName) {
+ List<List<String>> pathsToBeRemoved = new ArrayList<List<String>>();
+ for (List<String> path : sanitizedPaths) {
+ boolean middleboxFound = false;
+ for (String node : path) {
+ if (node.equals(middleboxName)) {
+ middleboxFound = true;
+ break;
+ }
+ }
+ if (!middleboxFound) {
+ pathsToBeRemoved.add(path);
+ }
+ }
+ for (List<String> path : pathsToBeRemoved) {
+ sanitizedPaths.remove(path);
+ }
+
+ }
+
+ private void extractPathsWithoutMiddlebox(List<List<String>> sanitizedPaths, String middleboxName) {
+ List<List<String>> pathsToBeRemoved = new ArrayList<List<String>>();
+ for (List<String> path : sanitizedPaths) {
+ boolean middleboxFound = false;
+ for (String node : path) {
+ if (node.equals(middleboxName)) {
+ middleboxFound = true;
+ break;
+ }
+ }
+ if (middleboxFound) {
+ pathsToBeRemoved.add(path);
+ }
+ }
+ for (List<String> path : pathsToBeRemoved) {
+ sanitizedPaths.remove(path);
+ }
+ }
+
+ private Verification traversalVerification(Graph graph, Node sourceNode, Node destinationNode, Node middleboxNode) throws MyInvalidDirectionException {
+ Long time_traversal=(long) 0;
+ Calendar cal_traversal = Calendar.getInstance();
+ Date start_time_traversal = cal_traversal.getTime();
+ Paths paths = getPaths(graph, sourceNode, destinationNode);
+ if (paths.getPath().size() == 0) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+
+ List<List<String>> pathsBetweenSourceAndDestination = sanitizePaths(paths);
+
+ //printListsOfStrings("Paths", pathsBetweenSourceAndDestination);
+
+ if (pathsBetweenSourceAndDestination.isEmpty()) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+
+ List<Test> tests = extractTestsFromPaths(graph, pathsBetweenSourceAndDestination, "UNKNOWN");
+
+ List<List<String>> pathsWithMiddlebox = new ArrayList<List<String>>();
+ for (List<String> path : pathsBetweenSourceAndDestination) {
+ pathsWithMiddlebox.add(path);
+ }
+
+ extractPathsWithMiddlebox(pathsWithMiddlebox, middleboxNode.getName());
+
+ if (pathsWithMiddlebox.isEmpty()) {
+ return new Verification("UNSAT",
+ tests,
+ "There are no paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "' which traverse middlebox '"
+ + middleboxNode.getName() + "'. See below all the available paths");
+ }
+
+ //printListsOfStrings("Paths with middlebox '" + middleboxNode.getName() + "'", pathsWithMiddlebox);
+
+ Map<Integer, GeneratorSolver> scenarios=createScenarios(pathsWithMiddlebox, graph);
+
+ tests = run(graph, scenarios, sourceNode.getName(), destinationNode.getName());
+
+ for (Test t : tests) {
+ if (t.getResult().equals("UNSAT")) {
+ return new Verification("UNSAT",
+ tests,
+ "There is at least a path between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "' traversing middlebox '"
+ + middleboxNode.getName() + "' where '" + sourceNode.getName()
+ + "' cannot reach '" + destinationNode.getName()
+ + "'. See below the paths that have been checked");
+ }
+ if (t.getResult().equals("UNKNOWN")) {
+ return new Verification("UNKNOWN",
+ tests,
+ "There is at least a path between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "' traversing middlebox '"
+ + middleboxNode.getName() + "' where it is not guaranteed that '"
+ + sourceNode.getName() + "' can effectively reach '"
+ + destinationNode.getName()
+ + "'. See below the paths that have been checked");
+ }
+ }
+
+ extractPathsWithoutMiddlebox(pathsBetweenSourceAndDestination, middleboxNode.getName());
+ printListsOfStrings("Paths without middlebox '" + middleboxNode.getName() + "'", pathsBetweenSourceAndDestination);
+
+ if (pathsBetweenSourceAndDestination.isEmpty()) {
+ return new Verification("SAT",
+ tests,
+ "All the paths between node '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "' traverse middlebox '"
+ + middleboxNode.getName() + "'");
+ }
+
+
+ Map<Integer, GeneratorSolver> scenarios2=createScenarios( pathsBetweenSourceAndDestination, graph);
+
+ tests = run(graph, scenarios2, sourceNode.getName(), destinationNode.getName());
+
+ Verification traversal= evaluateTraversalResults(tests,
+ sourceNode.getName(),
+ destinationNode.getName(),
+ middleboxNode.getName());
+
+ Calendar cal_traversal_stop = Calendar.getInstance();
+ time_traversal = time_traversal +(cal_traversal_stop.getTime().getTime() - start_time_traversal.getTime());
+ vlogger.logger.info("Time to check traversal policy: " + time_traversal);
+ //System.out.println("Time to check traversal policy: " + time_traversal);
+ return traversal;
+ }
+
+ private Verification evaluateTraversalResults(List<Test> tests, String source, String destination,
+ String middlebox) {
+ Verification v = new Verification();
+ boolean isSat = false;
+ int unsatCounter = 0;
+ for (Test t : tests) {
+ v.getTests().add(t);
+
+ if (t.getResult().equals("SAT")) {
+ isSat = true;
+ }
+ else if (t.getResult().equals("UNKNOWN")) {
+ v.setResult("UNKNWON");
+ v.setComment("There is at least one path from '"+ source + "' to '" + destination
+ + "' that doesn't traverse middlebox '" + middlebox
+ + "' (see below all the paths that have been checked)");
+ }
+ else if (t.getResult().equals("UNSAT")) {
+ unsatCounter++;
+ }
+ }
+ if (isSat) {
+ v.setResult("UNSAT");
+ v.setComment("There is at least one path from '"+ source + "' to '" + destination
+ + "' that doesn't traverse middlebox '" + middlebox
+ + "' (see below all the paths that have been checked)");
+ }
+ else if (unsatCounter == tests.size()) {
+ v.setResult("SAT");
+ v.setComment("The only available paths from '"+ source + "' to '" + destination
+ + "' are those that traverse middlebox '" + middlebox
+ + "' (see below the alternative paths that have been checked and are unusable)");
+ }
+ return v;
+ }
+
+ private Verification reachabilityVerification(Graph graph, Node sourceNode, Node destinationNode) throws MyInvalidDirectionException {
+ Long time_reachability=(long) 0;
+ Calendar cal_reachability = Calendar.getInstance();
+ Date start_time_reachability = cal_reachability.getTime();
+
+ Paths paths = getPaths(graph, sourceNode, destinationNode);
+
+ if (paths.getPath().size() == 0) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+
+ List<List<String>> sanitizedPaths = sanitizePaths(paths);
+
+ printListsOfStrings("Paths", sanitizedPaths);
+
+ if (sanitizedPaths.isEmpty()) {
+ return new Verification("UNSAT",
+ "There are no available paths between '"+ sourceNode.getName() + "' and '"
+ + destinationNode.getName() + "'");
+ }
+
+ Map<Integer, GeneratorSolver> scenarios=createScenarios(sanitizedPaths, graph);
+
+ List<Test> tests = run(graph, scenarios, sourceNode.getName(), destinationNode.getName());
+
+ Calendar cal_reachability_after_run = Calendar.getInstance();
+ time_reachability = time_reachability +(cal_reachability_after_run.getTime().getTime() - start_time_reachability.getTime());
+ vlogger.logger.info("Time reachability after run: " + time_reachability);
+ //System.out.println("Time reachability after run: " + time_reachability);
+
+ Verification reachability= evaluateReachabilityResult(tests, sourceNode.getName(), destinationNode.getName());
+
+ Calendar cal_reachability_stop = Calendar.getInstance();
+ time_reachability = time_reachability +(cal_reachability_stop.getTime().getTime() - start_time_reachability.getTime());
+ vlogger.logger.info("Time to check reachability policy: " + time_reachability);
+ //System.out.println("Time to check reachability policy: " + time_reachability);
+
+ return reachability;
+ }
+
+ private List<Test> run(Graph graph, Map<Integer, GeneratorSolver> scenarios, String src, String dst) {
+ List<Test> tests = new ArrayList<Test>();
+ String result;
+
+ //estimation time
+ //Long time=(long) 0;
+ //Calendar cal = Calendar.getInstance();
+ //Date start_time = cal.getTime();
+
+ for(Map.Entry<Integer, GeneratorSolver> t : scenarios.entrySet()){
+
+ result=t.getValue().run(src, dst);
+
+ List<Node> path = new ArrayList<Node>();
+ for (String nodeString : t.getValue().getPaths()) {
+ Node node = graph.searchNodeByName(nodeString);
+ path.add(node);
+ }
+ Test test = new Test(path, result);
+ tests.add(test);
+ }
+
+ //Calendar cal2 = Calendar.getInstance();
+ //time = time +(cal2.getTime().getTime() - start_time.getTime());
+ //System.out.println("Time occur to run: " + time);
+
+ return tests;
+ }
+
+ private Map<Integer, GeneratorSolver> createScenarios(List<List<String>> sanitizedPaths, Graph graph) {
+ int index=0;
+ Map<Integer, GeneratorSolver> scenarios=new HashMap<Integer, GeneratorSolver>();
+ for(List<String> s : sanitizedPaths){
+ Scenario tmp=new Scenario(graph, s);
+ tmp.createScenario();
+ GeneratorSolver gs=new GeneratorSolver(tmp, s);
+ gs.genSolver();
+ scenarios.put(index++, gs);
+ }
+ return scenarios;
+ }
+
+ private Verification evaluateReachabilityResult(List<Test> tests, String source, String destination) {
+ Verification v = new Verification();
+ boolean sat = false;
+ int unsat = 0;
+ for (Test t : tests) {
+
+ if (t.getResult().equals("SAT")) {
+ sat = true;
+ }
+
+ else if (t.getResult().equals("UNKNOWN")) {
+ v.setResult("UNKNWON");
+ v.setComment("Reachability from '"+ source + "' to '" + destination
+ + "' is unknown. See all the checked paths below");
+
+ }
+ else if (t.getResult().equals("UNSAT")) {
+ unsat++;
+ }
+ v.getTests().add(t);
+ }
+ if (sat) {
+ v.setResult("SAT");
+ v.setComment("There is at least one path '"+ source + "' can use to reach '" + destination
+ + "'. See all the available paths below");
+
+ }
+ else if (unsat == tests.size()) {
+ v.setResult("UNSAT");
+ v.setComment("There isn't any path '"+ source + "' can use to reach '" + destination
+ + "'. See all the checked paths below");
+
+ }
+
+ return v;
+ }
+
+ public List<List<Node>> getPaths(long graphId, String source, String destination) throws JsonParseException, JsonMappingException, JAXBException, IOException, MyInvalidDirectionException {
+ if (graphId < 0) {
+ throw new ForbiddenException("Illegal graph id: " + graphId);
+ }
+ GraphService graphService = new GraphService();
+ Graph graph = graphService.getGraph(graphId);
+ if (graph == null) {
+ throw new DataNotFoundException("Graph with id " + graphId + " not found");
+ }
+
+ if (source == null || source.equals("")) {
+ throw new BadRequestException("Please specify the 'source' parameter in your request");
+ }
+ if (destination == null || destination.equals("")) {
+ throw new BadRequestException("Please specify the 'destination' parameter in your request");
+ }
+
+ Node sourceNode = graph.searchNodeByName(source);
+ Node destinationNode = graph.searchNodeByName(destination);
+
+ if (sourceNode == null) {
+ throw new BadRequestException("The 'source' parameter '" + source + "' is not valid, please insert the name of an existing node");
+ }
+ if (destinationNode == null) {
+ throw new BadRequestException("The 'destination' parameter '" + destination + "' is not valid, please insert the name of an existing node");
+ }
+
+ Paths all_paths = getPaths(graph, sourceNode, destinationNode);
+
+ if (all_paths.getPath().size() == 0) {
+ vlogger.logger.info("No path available");
+ //System.out.println("No path available");
+ return null;
+ }
+
+ List<List<String>> sanitizedPaths = sanitizePaths(all_paths);
+
+ printListsOfStrings("Paths", sanitizedPaths);
+
+ if (sanitizedPaths.isEmpty()) {
+ return null;
+ }
+
+ List<List<Node>> paths=new ArrayList<List<Node>>();
+ List<Node> p= new ArrayList<Node>();
+
+ for(int i=0; i<sanitizedPaths.size(); i++){
+ List<String> name=sanitizedPaths.get(i);
+ for(int j=0; j<name.size(); j++){
+ Node n=graph.searchNodeByName(name.get(j));
+ if(n!=null)
+ p.add(j, n);
+ }
+ if(!p.isEmpty())
+ paths.add(i, p);
+ }
+
+ if(!paths.isEmpty())
+ return paths;
+ else
+ return null;
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/service/VerigraphLogger.java b/verigraph/src/it/polito/verigraph/service/VerigraphLogger.java
new file mode 100644
index 0000000..b819538
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/service/VerigraphLogger.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * 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.verigraph.service;
+
+import java.io.IOException;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.FileHandler;
+import java.util.logging.Formatter;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogManager;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+
+public class VerigraphLogger {
+ static private FileHandler fileTxt;
+ static private SimpleFormatter formatterTxt;
+ private static VerigraphLogger verigraphlogger= new VerigraphLogger();
+ public static Logger logger;
+
+ private VerigraphLogger() {
+
+ // suppress the logging output to the console
+ /*Logger rootLogger = Logger.getLogger("");
+ Handler[] handlers = rootLogger.getHandlers();
+ if (handlers[0] instanceof ConsoleHandler) {
+ rootLogger.removeHandler(handlers[0]);
+ }*/
+
+ /*Logger globalLogger = Logger.getLogger("");
+ Handler[] handlers = globalLogger.getHandlers();
+ for(Handler handler : handlers) {
+ globalLogger.removeHandler(handler);
+ }*/
+
+ LogManager.getLogManager().reset();
+ // get the global logger to configure it
+ logger = Logger.getLogger(VerigraphLogger.class.getName());
+ // logger.setUseParentHandlers(false);
+ logger.setLevel(Level.INFO);
+ try {
+ if(System.getProperty("catalina.home") != null)
+ fileTxt = new FileHandler(System.getProperty("catalina.home")+"/logs/verigraph_log.txt");
+ else fileTxt= new FileHandler("verigraph_log.txt");
+
+ } catch (SecurityException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ // create a TXT formatter
+ formatterTxt = new SimpleFormatter();
+ fileTxt.setFormatter(formatterTxt);
+ logger.addHandler(fileTxt);
+
+ }
+
+ public static VerigraphLogger getVerigraphlogger(){
+ return verigraphlogger;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/solver/GeneratorSolver.java b/verigraph/src/it/polito/verigraph/solver/GeneratorSolver.java
new file mode 100644
index 0000000..61e8210
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/solver/GeneratorSolver.java
@@ -0,0 +1,441 @@
+/*******************************************************************************
+ * 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.verigraph.solver;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Logger;
+
+import com.microsoft.z3.BoolExpr;
+import com.microsoft.z3.Context;
+import com.microsoft.z3.DatatypeExpr;
+import com.microsoft.z3.Expr;
+import com.microsoft.z3.FuncDecl;
+import com.microsoft.z3.IntExpr;
+import com.microsoft.z3.Solver;
+import com.microsoft.z3.Sort;
+import com.microsoft.z3.Status;
+import com.microsoft.z3.Z3Exception;
+
+import it.polito.neo4j.manager.Neo4jLibrary;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.mcnet.components.Checker;
+import it.polito.verigraph.mcnet.components.IsolationResult;
+import it.polito.verigraph.mcnet.components.NetContext;
+import it.polito.verigraph.mcnet.components.Network;
+import it.polito.verigraph.mcnet.components.NetworkObject;
+import it.polito.verigraph.mcnet.components.Tuple;
+import it.polito.verigraph.mcnet.netobjs.AclFirewall;
+import it.polito.verigraph.mcnet.netobjs.EndHost;
+import it.polito.verigraph.mcnet.netobjs.PacketModel;
+import it.polito.verigraph.mcnet.netobjs.PolitoAntispam;
+import it.polito.verigraph.mcnet.netobjs.PolitoCache;
+import it.polito.verigraph.mcnet.netobjs.PolitoEndHost;
+import it.polito.verigraph.mcnet.netobjs.PolitoFieldModifier;
+import it.polito.verigraph.mcnet.netobjs.PolitoIDS;
+import it.polito.verigraph.mcnet.netobjs.PolitoMailClient;
+import it.polito.verigraph.mcnet.netobjs.PolitoMailServer;
+import it.polito.verigraph.mcnet.netobjs.PolitoNat;
+import it.polito.verigraph.mcnet.netobjs.PolitoVpnAccess;
+import it.polito.verigraph.mcnet.netobjs.PolitoVpnExit;
+import it.polito.verigraph.mcnet.netobjs.PolitoWebClient;
+import it.polito.verigraph.mcnet.netobjs.PolitoWebServer;
+import it.polito.verigraph.service.VerigraphLogger;
+
+public class GeneratorSolver{
+ Scenario scenario;
+ Context ctx;
+ Network net;
+ NetContext nctx;
+ List<BoolExpr> constraints = new ArrayList<BoolExpr>();
+ public Checker check;
+ Map<String, Object> mo=new HashMap<String, Object>();
+ List<String> path=new ArrayList<String>();
+ //private final static Logger LOGGER = Logger.getLogger(VerigraphLogger.class.getName());
+ public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+
+ public List<String> getPaths(){
+ if(path!=null)
+ return path;
+ else
+ return null;
+ }
+
+ public GeneratorSolver(Scenario tmp, List<String> s){
+ this.scenario=tmp;
+ this.path=s;
+ }
+
+ public void resetZ3() throws Z3Exception{
+ HashMap<String, String> cfg = new HashMap<String, String>();
+ cfg.put("model", "true");
+ ctx = new Context(cfg);
+ }
+
+ public String run(String src, String dst){
+ IsolationResult result;
+ result=check.checkIsolationProperty((NetworkObject)mo.get(src), (NetworkObject)mo.get(dst));
+ String res=new String();
+
+ if (result.result == Status.UNSATISFIABLE){
+ res="UNSAT"; // Nodes a and b are isolated
+ }else if(result.result == Status.SATISFIABLE){
+ res= "SAT";
+ }else if(result.result == Status.UNKNOWN){
+ res= "UNKNOWN";
+ }
+ return res;
+ }
+
+ public void genSolver() {
+ resetZ3();
+ /*List<String> names=new ArrayList<String>();
+ List<String> addresses=new ArrayList<String>();
+ for(Map.Entry<String, Map<String, String>> a : scenario.chn.entrySet()){
+ String name=a.getKey();
+ Map<String, String> nodo=a.getValue();
+ String address=nodo.get("address");
+ names.add(name);
+ addresses.add(address);
+ }*/
+
+ //String name_nctx=listToArguments(scenario.nodes_names);
+ //String type_nctx=listToArguments(scenario.nodes_addresses);
+
+ //String name_nctx=listToArguments(names);
+ //String type_nctx=listToArguments(addresses);
+
+ String[] name_nctx=listToStringArguments(scenario.nodes_names);
+ String[] address_nctx=listToStringArguments(scenario.nodes_addresses);
+
+ nctx = new NetContext (ctx, name_nctx, address_nctx);
+ net = new Network (ctx,new Object[]{nctx});
+
+ //classes creation mcnet.objects: Map<name_node, obj created>
+ for(int i=0; i<scenario.nodes_names.size(); i++){
+ if(scenario.nodes_names.get(i)!=null){
+ //mo.put(scenario.nodes_names.get(i),setDevice(scenario.nodes_names.get(i), ctx, nctx, net));
+ //setDevice(scenario.nodes_names.get(i), ctx, nctx, net, mo);
+ setDevice(scenario.nodes_names.get(i));
+ }
+ }
+
+ //setMapping
+ ArrayList<Tuple<NetworkObject,ArrayList<DatatypeExpr>>> adm = new ArrayList<Tuple<NetworkObject,ArrayList<DatatypeExpr>>>();
+ doMappings(adm, mo);
+ //System.out.println("adm: " + adm);
+ net.setAddressMappings(adm);
+ //setRouting
+ Map<String, List<Tuple<DatatypeExpr,NetworkObject>>> ro=new HashMap<String,List<Tuple<DatatypeExpr,NetworkObject>>>();
+ doRouting(ro, mo);
+ //configureDevice
+ configureDevice();
+ check = new Checker(ctx,nctx,net);
+ }
+
+ private void setDevice(String name) {
+ Map<String, String> value=scenario.chn.get(name);
+ String type=value.get("functional_type");
+
+ if(type.compareTo("endhost")==0){
+ PolitoEndHost endhost=new PolitoEndHost(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, endhost);
+ }else if(type.compareTo("cache")==0){
+ PolitoCache cache=new PolitoCache(ctx, new Object[] { nctx.nm.get(name), net, nctx });
+ mo.put(name, cache);
+ }else if(type.compareTo("antispam")==0){
+ PolitoAntispam antispam=new PolitoAntispam(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, antispam);
+ }else if(type.compareTo("fieldmodifier")==0){
+ PolitoFieldModifier fieldmodifier=new PolitoFieldModifier(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, fieldmodifier);
+ }else if(type.compareTo("mailclient")==0){
+ String conf=(scenario.config_obj.get(name)).get("mailserver");
+ PolitoMailClient mailclient=new PolitoMailClient(ctx, new Object[]{nctx.nm.get(name), net, nctx, nctx.am.get(conf)});
+ mo.put(name, mailclient);
+ }else if(type.compareTo("mailserver")==0){
+ PolitoMailServer mailserver=new PolitoMailServer(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, mailserver);
+ }else if(type.compareTo("nat")==0){
+ PolitoNat nat=new PolitoNat(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, nat);
+ }else if(type.compareTo("vpnaccess")==0){
+ PolitoVpnAccess vpnaccess=new PolitoVpnAccess(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, vpnaccess);
+ }else if(type.compareTo("vpnexit")==0){
+ PolitoVpnExit vpnexit=new PolitoVpnExit(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, vpnexit);
+ }else if(type.compareTo("webserver")==0){
+ PolitoWebServer webserver=new PolitoWebServer(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, webserver);
+ }else if(type.compareTo("webclient")==0){
+ String conf=(scenario.config_obj.get(name)).get("webserver");
+ PolitoWebClient webclient=new PolitoWebClient(ctx, new Object[]{nctx.nm.get(name), net, nctx, nctx.am.get(conf)});
+ mo.put(name, webclient);
+ }else if(type.compareTo("dpi")==0){
+ PolitoIDS dpi=new PolitoIDS(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, dpi);
+ }else if(type.compareTo("endpoint")==0){
+ EndHost endpoint=new EndHost(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, endpoint);
+ }else if(type.compareTo("firewall")==0){
+ AclFirewall firewall=new AclFirewall(ctx, new Object[]{nctx.nm.get(name), net, nctx});
+ mo.put(name, firewall);
+ }
+ }
+
+ private void configureDevice() {
+ vlogger.logger.info("Configuration service");
+ //System.out.println("Configuration Device");
+ for(Map.Entry<String,Object> cd : mo.entrySet()){
+ String name=cd.getKey();
+ String type=(scenario.chn.get(name)).get("functional_type");
+ String address=(scenario.chn.get(name)).get("address");
+ Object model=cd.getValue();
+ if(model instanceof PolitoEndHost){
+ Map<String, String> packet=scenario.config_obj.get(name);
+ if(packet!=null){
+ PacketModel pModel = new PacketModel();
+ if(packet.get("body")!=null){
+ pModel.setBody(String.valueOf(packet.get("body")).hashCode());
+ }
+ if(packet.get("destination")!=null){
+ pModel.setIp_dest(nctx.am.get(packet.get("destination")));
+ }
+ if(packet.get("sequence")!=null){
+ pModel.setSeq(String.valueOf(packet.get("sequence")).hashCode());
+ }
+ if(packet.get("email_from")!=null){
+ pModel.setEmailFrom(String.valueOf(packet.get("email_from")).hashCode());
+ }
+ if(packet.get("url")!=null){
+ pModel.setUrl(String.valueOf(packet.get("url")).hashCode());
+ }
+ if(packet.get("options")!=null){
+ pModel.setOptions(String.valueOf(packet.get("options")).hashCode());
+ }
+ if(packet.get("protocol")!=null){
+ String proto=packet.get("protocol");
+ if(proto.compareTo("HTTP_REQUEST")==0)
+ pModel.setProto(nctx.HTTP_REQUEST);
+ else if(proto.compareTo("HTTP_RESPONSE")==0)
+ pModel.setProto(nctx.HTTP_RESPONSE);
+ else if(proto.compareTo("POP3_REQUEST")==0)
+ pModel.setProto(nctx.POP3_REQUEST);
+ else if(proto.compareTo("POP3_RESPONSE")==0)
+ pModel.setProto(nctx.POP3_RESPONSE);
+ }
+ ((PolitoEndHost)cd.getValue()).installEndHost(pModel);
+ }
+ else{
+ vlogger.logger.info("Configuration endhost "+name+"empty");
+ }
+ }else if(model instanceof PolitoCache){
+
+ List<String> list_tmp=scenario.config_array.get(name);
+ for(int i=0; i<list_tmp.size(); i++){
+ if(!scenario.nodes_addresses.contains(list_tmp.get(i)))
+ list_tmp.remove(i);
+ }
+ List<String> list=trimIp(list_tmp);
+ if(list!=null){
+ PolitoCache cache=(PolitoCache)cd.getValue();
+ NetworkObject [] array_no=listToNetworkArguments(list);
+ ((PolitoCache)cd.getValue()).installCache(array_no);
+ }
+ else{
+ vlogger.logger.info("Cache "+name+" empty");
+ }
+ }else if(model instanceof PolitoAntispam){
+ List<String> list_tmp=scenario.config_array.get(name);
+ List<String> list=trimIp(list_tmp);
+ if(list!=null){
+ PolitoAntispam antispam=(PolitoAntispam)cd.getValue();
+ int[] blackList=listToIntArguments(list);
+ ((PolitoAntispam)cd.getValue()).installAntispam(blackList);
+ }
+ else{
+ vlogger.logger.info("Antispam "+name+" empty");
+ }
+ }else if(model instanceof PolitoFieldModifier){
+ ((PolitoFieldModifier)cd.getValue()).installFieldModifier();
+ }else if(model instanceof PolitoMailClient){
+ //the rules are inserted in the init method
+ continue;
+ }else if(model instanceof PolitoMailServer){
+ //the rules are inserted in the init method
+ continue;
+ }else if(model instanceof PolitoNat){
+ List<String> list=scenario.config_array.get(name);
+ if(!list.isEmpty()){
+ ArrayList<DatatypeExpr> ia = new ArrayList<DatatypeExpr>();
+ for(String s : list){
+ if(scenario.nodes_addresses.contains(s)){
+ ia.add(nctx.am.get(s));
+ }
+ }
+ ((PolitoNat)cd.getValue()).natModel(nctx.am.get(address));
+ ((PolitoNat)cd.getValue()).setInternalAddress(ia);
+ }
+ else{
+ vlogger.logger.info("Nat "+name+" empty");
+ }
+ }else if(model instanceof PolitoVpnAccess){
+ Map<String, String> vpnexit=scenario.config_obj.get(name);
+ if(vpnexit!=null){
+ for(Map.Entry<String, String> a : vpnexit.entrySet())
+ ((PolitoVpnAccess)cd.getValue()).vpnAccessModel(nctx.am.get(address), nctx.am.get(a.getValue()));
+ }
+ else{
+ vlogger.logger.info("Vpnacces "+name+" empty");
+ }
+ }else if(model instanceof PolitoVpnExit){
+ Map<String, String> vpnaccess=scenario.config_obj.get(name);
+ if(vpnaccess!=null){
+ for(Map.Entry<String, String> a : vpnaccess.entrySet())
+ ((PolitoVpnExit)cd.getValue()).vpnExitModel(nctx.am.get(address), nctx.am.get(a.getValue()));
+ }
+ else{
+ vlogger.logger.info("Vpnexit "+name+" empty");
+ }
+
+ }else if(model instanceof PolitoWebServer){
+ //the rules are inserted in the init method
+ continue;
+
+ }else if(model instanceof PolitoWebClient){
+ //the rules are inserted in the init method
+ continue;
+
+ }else if(model instanceof PolitoIDS){
+ List<String> list=scenario.config_array.get(name);
+ if(!list.isEmpty()){
+ PolitoIDS dpi=(PolitoIDS)cd.getValue();
+ int[] blackList=listToIntArguments(list);
+ ((PolitoIDS)cd.getValue()).installIDS(blackList);
+ }
+ else{
+ vlogger.logger.info("Dpi "+name+" empty");
+ }
+ }else if(model instanceof EndHost){
+ //the rules are inserted in the init method
+ continue;
+ }else if(model instanceof AclFirewall){
+ Map<String, String> acls=scenario.config_obj.get(name);
+ ArrayList<Tuple<DatatypeExpr,DatatypeExpr>> acl = new ArrayList<Tuple<DatatypeExpr,DatatypeExpr>>();
+
+ if(!acls.isEmpty()){
+ for(Map.Entry<String, String> a : acls.entrySet()){
+ String dest=a.getKey();
+ String src=a.getValue();
+
+ if(scenario.nodes_addresses.contains("ip_"+dest) && scenario.nodes_addresses.contains("ip_"+src)){
+ acl.add(new Tuple<DatatypeExpr,DatatypeExpr>(nctx.am.get("ip_"+dest),nctx.am.get("ip_"+src)));
+
+ }
+ }
+ ((AclFirewall)cd.getValue()).addAcls(acl);
+
+ }
+ else{
+ vlogger.logger.info("Acls firewall "+name+" empty");
+ }
+ }
+ else
+ vlogger.logger.info("No configuration added");
+ }
+ }
+
+ private List<String> trimIp(List<String> list) {
+ List<String> result=new ArrayList<String>();
+ for(String s : list){
+ if(s.length()>3){
+ if(s.substring(0, 3).compareTo("ip_")==0)
+ result.add(s.substring(3));
+ else
+ result.add(s);
+ }
+ }
+ return result;
+ }
+
+ private void doRouting(Map<String, List<Tuple<DatatypeExpr, NetworkObject>>> ro, Map<String, Object> mo) {
+ for(String nodes : scenario.nodes_names){
+ Object obj=mo.get(nodes);
+ if(obj!=null){
+ ArrayList<Tuple<DatatypeExpr,NetworkObject>> rt = new ArrayList<Tuple<DatatypeExpr,NetworkObject>>();
+ Map<String, String> route=scenario.routing.get(nodes);
+ for(Map.Entry<String,String> r : route.entrySet()){
+ String dest=r.getKey();
+ NetworkObject next_hop=(NetworkObject)mo.get(r.getValue());
+ rt.add(new Tuple<DatatypeExpr,NetworkObject>(nctx.am.get(dest), next_hop));
+ }
+ net.routingTable((NetworkObject)obj, rt);
+ net.attach((NetworkObject)obj);
+ ro.put(nodes, rt);
+ }
+ }
+ }
+
+ private void doMappings(ArrayList<Tuple<NetworkObject, ArrayList<DatatypeExpr>>> adm, Map<String, Object> mo) {
+ for(Map.Entry<String, Object> obj : mo.entrySet()){
+ String name=obj.getKey().toString();
+ Object model=obj.getValue();
+ ArrayList<DatatypeExpr> al = new ArrayList<DatatypeExpr>();
+ al.add(nctx.am.get((scenario.chn.get(name)).get("address")));
+ adm.add(new Tuple<>((NetworkObject)(model),al));
+ }
+ }
+
+ //function Arguments:
+ private String listToArguments(List<String> nodes_names) {
+ StringBuffer result=new StringBuffer();
+ for(int i=0; i<nodes_names.size(); i++){
+ if(i==nodes_names.size()-1){
+ result.append("\"" + nodes_names.get(i) + "\"");
+ }
+ else{
+ result.append("\"" + nodes_names.get(i) + "\"");
+ result.append(", ");
+ }
+ }
+ return result.toString();
+ }
+ private NetworkObject[] listToNetworkArguments(List<String> arg){
+ NetworkObject[] o= new NetworkObject[arg.size()];
+ for(int i=0; i<arg.size(); i++){
+ if(arg.get(i)!=null)
+ o[i]= nctx.nm.get(arg.get(i));
+ }
+ return o;
+ }
+
+ private String[] listToStringArguments(List<String> arg){
+ String[] o= new String[arg.size()];
+ for(int i=0; i<arg.size(); i++){
+ if(arg.get(i)!=null)
+ o[i]= arg.get(i);
+ }
+ return o;
+ }
+
+ private int[] listToIntArguments(List<String> arg) {
+ int[] o= new int[arg.size()];
+ for(int i=0; i<arg.size(); i++){
+ if(arg.get(i)!=null)
+ o[i]= String.valueOf(arg.get(i)).hashCode();
+ }
+ return o;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/solver/Scenario.java b/verigraph/src/it/polito/verigraph/solver/Scenario.java
new file mode 100644
index 0000000..6536b61
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/solver/Scenario.java
@@ -0,0 +1,557 @@
+/*******************************************************************************
+ * 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.verigraph.solver;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import com.fasterxml.jackson.core.JsonGenerationException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import it.polito.verigraph.exception.DataNotFoundException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.service.VerigraphLogger;
+
+public class Scenario {
+ Graph graph;
+ List<String> path=new ArrayList<String>();
+ public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
+ Map<String, Map<String, String>> chn=new HashMap<String, Map<String, String>>();
+ Map<String, Map<String, String>> routing=new HashMap<String, Map<String, String>>();
+ //configurations node:
+ Map<String, Map<String, String>> config_obj=new HashMap<String, Map<String, String>>();
+ Map<String,List<String>> config_array=new HashMap<String, List<String>>();
+ //utility for netcontext:
+ List<String> nodes_names=new ArrayList<String>();
+ List<String> nodes_types=new ArrayList<String>();
+ List<String> nodes_addresses=new ArrayList<String>();
+
+ public Scenario(Graph graph, List<String> s) {
+
+ this.graph=graph;
+ this.path=s;
+ }
+
+ @SuppressWarnings("unchecked")
+ public void createScenario() {
+ List<Node> nodes=new ArrayList<Node>();
+
+ //nodes list creation
+ for(String s : path){
+ Node n=graph.searchNodeByName(s);
+ if(n==null){
+ vlogger.logger.info("The node "+n.getName()+" is not present in the graph");
+ //System.out.println("The node "+n.getName()+" is not present in the graph");
+ }
+ else{
+ nodes.add(n);
+ }
+ }
+
+ //for each node a map is created in order to insert the map in chn
+ for(int i=0; i<nodes.size(); i++){
+ String name=nodes.get(i).getName();
+ nodes_names.add(name);
+ String type=nodes.get(i).getFunctional_type().toLowerCase();
+ nodes_types.add(type);
+ nodes_addresses.add("ip_"+name);
+ JsonNode configuration=nodes.get(i).getConfiguration().getConfiguration();
+ //fill chn
+ Map<String, String> nodo=new HashMap<String, String>();
+ nodo.put("address", "ip_" + name);
+ nodo.put("functional_type", type);
+ chn.put(name, nodo);
+ //fill routing
+ Map<String, String> route=new HashMap<String, String>();
+ for(int k=i-1; ; k--){
+ if(k==-1)
+ break;
+ else{
+ String ip_dest="ip_"+nodes.get(k).getName();
+ String next_hop=nodes.get(i-1).getName();
+ route.put(ip_dest, next_hop);
+ }
+ }
+ for(int j=i+1; j<nodes.size(); j++){
+ String ip_dest="ip_"+nodes.get(j).getName();
+ String next_hop=nodes.get(i+1).getName();
+ route.put(ip_dest, next_hop);
+ }
+ routing.put(name, route);
+ //fill configuration
+ setConfiguration(name, type, configuration, config_obj, config_array);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void setConfiguration(String name, String type, JsonNode configuration,
+ Map<String, Map<String, String>> config_obj2, Map<String, List<String>> config_array2) {
+ String empty="[]";
+ switch(type.toUpperCase()){
+ case "FIREWALL":{
+ Map<String, String> map=new LinkedHashMap();
+
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ Map<String, String> map_tmp=new LinkedHashMap();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.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));
+ }
+
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Firewall "+name+" empty");
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "ANTISPAM":{
+ List<String> source=new ArrayList<String>();
+
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ try {
+ source = mapper.readValue(configuration.toString(), ArrayList.class);
+ } catch (JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Antispam "+name+" empty");
+ }
+ config_array.put(name, source);
+ break;
+ }
+ case "CACHE":{
+ List<String> resource=new ArrayList<String>();
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ try {
+ List<String> list_tmp=new ArrayList<String>();
+ list_tmp = mapper.readValue(configuration.toString(), ArrayList.class);
+ if(list_tmp!=null){
+ for(String s : list_tmp){
+ resource.add("ip_"+s);
+ }
+ }
+ } catch (JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Cache "+name+ " empty");
+ }
+ config_array.put(name, resource);
+ break;
+ }
+ case "DPI":{
+ List<String> notAllowed=new ArrayList<String>();
+
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ try {
+ notAllowed = mapper.readValue(configuration.toString(), ArrayList.class);
+ } catch (JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Dpi "+name+ " empty");
+ }
+ config_array.put(name, notAllowed);
+ break;
+ }
+ case "ENDHOST":{
+ Map<String, String> map=new LinkedHashMap();
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ Map<String, String> map_tmp=new LinkedHashMap();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.toString();
+ try{
+ map=mapper.readValue(input, java.util.LinkedHashMap.class);
+ String ip=map.get("destination");
+ if(ip!=null){
+ map.put("destination", "ip_"+ip);
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Endhost "+name+ " empty");
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "ENDPOINT":{
+ Map<String, String> map=new LinkedHashMap();
+ config_obj.put(name, map);
+ break;
+ }
+ case "FIELDMODIFIER":{
+ Map<String, String> map=new LinkedHashMap();
+
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+
+ if(!configuration.toString().isEmpty()){
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.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));
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ else{
+ vlogger.logger.info("Fieldmodifier "+name+ " empty");
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "MAILCLIENT":{
+ Map<String, String> map=new LinkedHashMap();
+ ObjectMapper mapper=new ObjectMapper();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.toString();
+ Map<String, String> map_tmp=new LinkedHashMap();
+ 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));
+ }
+ String ip=map.get("mailserver");
+ if(ip!=null){
+ map.put("mailserver", "ip_"+ip);
+ if(!path.contains(ip)){
+ if(!nodes_addresses.contains("ip_"+ip))
+ nodes_addresses.add("ip_"+ip);
+ }
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "MAILSERVER":{
+ Map<String, String> map=new LinkedHashMap();
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.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){
+ /*only one object*/
+ map.putAll(mapper.readValue(string, LinkedHashMap.class));
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Mailserver "+name+ " empty");
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "NAT":{
+ List<String> source=new ArrayList<String>();
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ List<String> list=new ArrayList<String>();
+ try {
+ list = mapper.readValue(configuration.toString(), ArrayList.class);
+ if(!list.isEmpty()){
+ for(String s : list){
+ source.add("ip_"+s);
+ }
+ }
+ } catch (JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ else{
+ vlogger.logger.info("Nat "+name+ " empty");
+ }
+ config_array.put(name, source);
+ break;
+ }
+ case "VPNACCESS":{
+ ObjectMapper mapper=new ObjectMapper();
+ Map<String, String> map=new LinkedHashMap();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.toString();
+ Map<String, String> map_tmp=new LinkedHashMap();
+ 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));
+ }
+ String ip=map.get("vpnexit");
+ if(ip!=null){
+ map.put("vpnexit", "ip_"+ip);
+ if(!path.contains(ip)){
+ if(!nodes_addresses.contains("ip_"+ip))
+ nodes_addresses.add("ip_"+ip);
+ }
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "VPNEXIT":{
+ ObjectMapper mapper=new ObjectMapper();
+ Map<String, String> map=new LinkedHashMap();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.toString();
+ Map<String, String> map_tmp=new LinkedHashMap();
+ 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){
+ /*only 1 string */
+ map_tmp.putAll(mapper.readValue(string, LinkedHashMap.class));
+ }
+ String ip=map.get("vpnaccess");
+ if(ip!=null){
+ map.put("vpnaccess", "ip_"+ip);
+ if(!path.contains(ip)){
+ if(!nodes_addresses.contains("ip_"+ip))
+ nodes_addresses.add("ip_"+ip);
+ }
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "WEBCLIENT":{
+ Map<String, String> map=new LinkedHashMap();
+ ObjectMapper mapper=new ObjectMapper();
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.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){
+ /*only 1 string */
+ map.putAll(mapper.readValue(string, LinkedHashMap.class));
+ }
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ case "WEBSERVER":{
+ Map<String, String> map=new LinkedHashMap();
+ if(!configuration.toString().equals(empty)){
+ ObjectMapper mapper=new ObjectMapper();
+ if(configuration.toString().equals(empty)){
+ break;
+ }else{
+ String input;
+ Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
+ if(matcher.find()){
+ input=matcher.group(1);
+ }else
+ input=configuration.toString();
+ try{
+ /*readValue reads only 1 value of 1 object*/
+ map=mapper.readValue(input, java.util.LinkedHashMap.class);
+ }catch(JsonGenerationException e) {
+ e.printStackTrace();
+ } catch (JsonMappingException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ else{
+ vlogger.logger.info("Webserver "+name+ " empty");
+ }
+ config_obj.put(name, map);
+ break;
+ }
+ default:{
+ throw new DataNotFoundException("The type "+type+ " is not valid");
+ }
+ }
+ }
+
+ private void checkConfiguration(List<String> source) {
+ for(int i=0; i<source.size(); i++){
+ if(!path.contains(source.get(i))){
+ if(!nodes_addresses.contains("ip_"+source.get(i)))
+ nodes_addresses.add("ip_"+source.get(i));
+ }
+ }
+ }
+
+ private void checkConfiguration(Map<String, String> map) {
+ Map<String, String> m=new HashMap<String, String>();
+ for(Map.Entry<String, String> a : map.entrySet()){
+ if(a.getKey()!=null){
+ if(!path.contains(a.getKey())){
+ if(!nodes_addresses.contains("ip_"+a.getKey()))
+ nodes_addresses.add("ip_"+a.getKey());
+ }
+ }
+ if(a.getValue()!=null){
+ if(!path.contains(a.getValue())){
+ if(!nodes_addresses.contains("ip_"+a.getValue()))
+ nodes_addresses.add("ip_"+a.getValue());
+ }
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/test/MultiThreadedTestCase.java b/verigraph/src/it/polito/verigraph/test/MultiThreadedTestCase.java
new file mode 100644
index 0000000..252932e
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/test/MultiThreadedTestCase.java
@@ -0,0 +1,201 @@
+/*******************************************************************************
+ * 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.verigraph.test;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import javax.ws.rs.core.Response;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import it.polito.verigraph.client.VerifyClient;
+import it.polito.verigraph.client.VerifyClientException;
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+
+public class MultiThreadedTestCase {
+
+ private void testUpdateGraphStatus(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ final VerifyClient verifyClient = new VerifyClient("http://localhost:8080/verigraph/api");
+
+ Response retrieveGraphResponse = verifyClient.retrieveGraph(1);
+ String responseString = retrieveGraphResponse.readEntity(String.class);
+ System.out.println(responseString);
+
+ Graph graph = new ObjectMapper().readValue(responseString, Graph.class);
+
+ UpdateGraph task = new UpdateGraph(verifyClient, 1, graph);
+
+ List<MultiThreadedTestCase.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<Response>> futures = executorService.invokeAll(tasks);
+ List<Integer> resultList = new ArrayList<Integer>(futures.size());
+
+ // Check for exceptions
+ for (Future<Response> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ resultList.add(future.get().getStatus());
+ }
+ // Validate the dimensions
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<Integer> expectedList = new ArrayList<Integer>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(200);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private void testUpdateGraph(final int threadCount) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ final VerifyClient verifyClient = new VerifyClient("http://localhost:8080/verigraph/api");
+
+ Response retrieveGraphResponse = verifyClient.retrieveGraph(2L);
+ String responseString = retrieveGraphResponse.readEntity(String.class);
+ System.out.println(responseString);
+
+ Graph graph = new ObjectMapper().readValue(responseString, Graph.class);
+
+ Node nodeToEdit = graph.getNodes().get(1L);
+ nodeToEdit.setFunctional_type("endpoint");
+ nodeToEdit.setConfiguration(new Configuration(nodeToEdit.getName(), "", new ObjectMapper().createArrayNode()));
+
+ String graphAsString = new ObjectMapper().writeValueAsString(graph);
+ System.out.println(graphAsString);
+
+ UpdateGraph task = new UpdateGraph(verifyClient, 2, graph);
+
+ List<MultiThreadedTestCase.UpdateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<Response>> futures = executorService.invokeAll(tasks);
+ List<String> resultList = new ArrayList<String>(futures.size());
+
+ // Check for exceptions
+ for (Future<Response> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ resultList.add(future.get().readEntity(String.class));
+ }
+ // Validate dimensions
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<String> expectedList = new ArrayList<String>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(graphAsString);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private void testCreateGraphStatus(final int threadCount, Graph graph) throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException {
+ final VerifyClient verifyClient = new VerifyClient("http://localhost:8080/verigraph/api");
+
+ CreateGraph task = new CreateGraph(verifyClient, graph);
+
+ List<MultiThreadedTestCase.CreateGraph> tasks = Collections.nCopies(threadCount, task);
+ ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+
+ List<Future<Response>> futures = executorService.invokeAll(tasks);
+ List<Integer> resultList = new ArrayList<Integer>(futures.size());
+
+ // Check for exceptions
+ for (Future<Response> future : futures) {
+ // Throws an exception if an exception was thrown by the task.
+ resultList.add(future.get().getStatus());
+ }
+ // Validate the IDs
+ Assert.assertEquals(threadCount, futures.size());
+
+ List<Integer> expectedList = new ArrayList<Integer>(threadCount);
+ for (int i = 1; i <= threadCount; i++) {
+ expectedList.add(201);
+ }
+ // Validate expected results
+ Assert.assertEquals(expectedList, resultList);
+ }
+
+ private int randInt(int min, int max){
+ Random rand = new Random();
+ int randomNum = rand.nextInt((max - min) + 1) + min;
+ return randomNum;
+ }
+
+ @Test
+ public void updateGraphStatusCheck() throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ testUpdateGraphStatus(64);
+ }
+
+ @Test
+ public void updateGraphResponseCheck() throws InterruptedException, ExecutionException, JsonParseException, JsonMappingException, IOException, VerifyClientException {
+ testUpdateGraph(16);
+ }
+
+ @Test
+ public void createGraphStatusCheck() throws JsonParseException, JsonMappingException, InterruptedException, ExecutionException, IOException {
+ Graph graph = new Graph();
+ testCreateGraphStatus(8, graph);
+ }
+
+ class UpdateGraph implements Callable<Response> {
+
+ private VerifyClient verifyClient;
+
+ private int graphId;
+
+ private Graph graph;
+
+ public UpdateGraph(VerifyClient verifyClient, int graphId, Graph graph) {
+ this.graphId = graphId;
+ this.graph = graph;
+ this.verifyClient = verifyClient;
+ }
+
+ @Override
+ public Response call() throws Exception {
+ Thread.sleep(randInt(0,2000));
+ Response updateGraphResponse = this.verifyClient.updateGraph(this.graphId, this.graph);
+ return updateGraphResponse;
+ }
+ }
+
+ class CreateGraph implements Callable<Response> {
+
+ private VerifyClient verifyClient;
+
+ private Graph graph;
+
+ public CreateGraph(VerifyClient verifyClient, Graph graph) {
+ this.graph = graph;
+ this.verifyClient = verifyClient;
+ }
+
+ @Override
+ public Response call() throws Exception {
+ Thread.sleep(randInt(0,2000));
+ return this.verifyClient.createGraph(this.graph);
+ }
+
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/test/Scalability.java b/verigraph/src/it/polito/verigraph/test/Scalability.java
new file mode 100644
index 0000000..5f9c4e9
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/test/Scalability.java
@@ -0,0 +1,413 @@
+/*******************************************************************************
+ * 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.verigraph.test;
+
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+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.verigraph.client.VerifyClient;
+import it.polito.verigraph.client.VerifyClientException;
+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.model.Verification;
+
+public class Scalability {
+
+ private VerifyClient client = new VerifyClient("http://localhost:8080/verigraph/api");
+
+ public static void main(String[] args) throws VerifyClientException {
+ Scalability s = new Scalability();
+
+ reachabilityTest(s, 10);
+ for(int i=50; i<=1000;i +=50)
+ reachabilityTest(s,i);
+
+// for(int i=50; i<=1000;i +=50)
+// isolationTest(s,i);
+
+// for(int i=50; i<=1000;i +=50)
+// traversalTest(s,i);
+ }
+
+ private static void reachabilityTest(Scalability s, int n) throws VerifyClientException {
+ System.out.printf("Reachability test with N=" + n + ": ");
+ printTimestamp();
+ Graph graph = generateNatScenario(n);
+ Graph createdGraph = s.client.createGraph(graph).readEntity(Graph.class);
+ Verification result = s.client.getReachability(createdGraph.getId(), "client", "server");
+ System.out.println("Test returned " + result.getResult());
+ System.out.printf("Finished reachability test with N=" + n + ": ");
+ printTimestamp();
+ System.out.println();
+ }
+
+ private static void isolationTest(Scalability s, int n) throws VerifyClientException {
+ System.out.printf("Isolation test with N=" + n + ": ");
+ printTimestamp();
+ Graph graph = generateNatScenario(n);
+ Graph createdGraph = s.client.createGraph(graph).readEntity(Graph.class);
+ Verification result = s.client.getIsolation(createdGraph.getId(), "client", "server", "firewall");
+ System.out.println("Test returned " + result.getResult());
+ System.out.printf("Finished isolation test with N=" + n + ": ");
+ printTimestamp();
+ System.out.println();
+ }
+
+ private static void traversalTest(Scalability s, int n) throws VerifyClientException {
+ System.out.printf("Traversal test with N=" + n + ": ");
+ printTimestamp();
+ Graph graph = generateNatScenario(n);
+ Graph createdGraph = s.client.createGraph(graph).readEntity(Graph.class);
+ Verification result = s.client.getTraversal(createdGraph.getId(), "client", "server", "firewall");
+ System.out.println("Test returned " + result.getResult());
+ //System.out.println("Result explanation: " + result.getComment());
+ System.out.printf("Finished traversal test with N=" + n + ": ");
+ printTimestamp();
+ System.out.println();
+ }
+
+ private static void printTimestamp() {
+ java.util.Date date= new java.util.Date();
+ System.out.println(new Timestamp(date.getTime()));
+ }
+
+ private static Graph generateNatScenario(int n) {
+ List<Node> nodes = new ArrayList<Node>();
+
+ Node client = new Node();
+ client.setName("client");
+ client.setFunctional_type("endhost");
+ ArrayNode clientConfigArray = new ObjectMapper().createArrayNode();
+ JsonNode clientConfig = new ObjectMapper().createObjectNode();
+ ((ObjectNode)clientConfig).put("url", "www.facebook.com");
+ ((ObjectNode)clientConfig).put("body", "word");
+ ((ObjectNode)clientConfig).put("destination","server");
+ ((ObjectNode)clientConfig).put("protocol", "HTTP_REQUEST");
+ clientConfigArray.add(clientConfig);
+ client.setConfiguration(new Configuration(client.getName(),"", clientConfigArray));
+
+ Map<Long, Neighbour> clientNeighbours = new HashMap<Long, Neighbour>();
+ clientNeighbours.put(1L, new Neighbour(1L, "nat1"));
+ client.setNeighbours(clientNeighbours );
+ //add client to list
+ nodes.add(client);
+
+ for(int i=0; i< n;i++){
+ Node nat = new Node();
+ nat.setId(i+1);
+ nat.setName("nat" + (i+1));
+ nat.setFunctional_type("nat");
+ ArrayNode configArray = new ObjectMapper().createArrayNode();
+
+ Map<Long, Neighbour> natNeighbours = new HashMap<Long, Neighbour>();
+
+ //set left neighbour for each node except the first
+ if(nat.getId() != 1){
+ natNeighbours.put(1L, new Neighbour(1L, "nat" + i));
+ configArray.add("client");
+ for (int j=1; j <= i; j++){
+ configArray.add("nat" + j);
+ }
+ }
+ //first nat: set only client as neighbour and natted node
+ else{
+ natNeighbours.put(1L, new Neighbour(1L, "client"));
+ configArray.add("client");
+ }
+ //set right neighbour for each node except the last
+ if(nat.getId() != n){
+ natNeighbours.put(2L, new Neighbour(1L, "nat" + (i+2)));
+ }
+ //last nat: set server as neighbour
+ else{
+ natNeighbours.put(2L, new Neighbour(1L, "server"));
+ }
+
+ nat.setNeighbours(natNeighbours);
+ nat.setConfiguration(new Configuration(nat.getName(),"", configArray));
+
+ //add nat to list
+ nodes.add(nat);
+ }
+
+ Node server = new Node();
+ server.setName("server");
+ server.setFunctional_type("webserver");
+ ArrayNode serverConfigArray = new ObjectMapper().createArrayNode();
+ server.setConfiguration(new Configuration(server.getName(),"", serverConfigArray));
+
+ Map<Long, Neighbour> serverNeighbours = new HashMap<Long, Neighbour>();
+ serverNeighbours.put(1L, new Neighbour(1L, "nat" + (n)));
+ server.setNeighbours(serverNeighbours );
+
+ //add server to list
+ nodes.add(server);
+
+ //create graph
+ Graph g = new Graph();
+ Map<Long, Node> graphNodes = new HashMap<Long, Node>();
+ long index = 1L;
+ for (Node node : nodes){
+ graphNodes.put(index, node);
+ index++;
+ }
+ g.setNodes(graphNodes);
+
+ return g;
+ }
+
+ private static Graph generateFirewallScenario(int n) {
+ List<Node> nodes = new ArrayList<Node>();
+
+ Node client = new Node();
+ client.setName("client");
+ client.setFunctional_type("endhost");
+ ArrayNode clientConfigArray = new ObjectMapper().createArrayNode();
+ JsonNode clientConfig = new ObjectMapper().createObjectNode();
+ ((ObjectNode)clientConfig).put("url", "www.facebook.com");
+ ((ObjectNode)clientConfig).put("body", "word");
+ ((ObjectNode)clientConfig).put("destination","server");
+ ((ObjectNode)clientConfig).put("protocol", "HTTP_REQUEST");
+ clientConfigArray.add(clientConfig);
+ client.setConfiguration(new Configuration(client.getName(),"", clientConfigArray));
+
+ Map<Long, Neighbour> clientNeighbours = new HashMap<Long, Neighbour>();
+ clientNeighbours.put(1L, new Neighbour(1L, "firewall1"));
+ client.setNeighbours(clientNeighbours );
+ //add client to list
+ nodes.add(client);
+
+ for(int i=0; i< n;i++){
+ Node firewall = new Node();
+ firewall.setId(i+1);
+ firewall.setName("firewall" + (i+1));
+ firewall.setFunctional_type("firewall");
+ ArrayNode configArray = new ObjectMapper().createArrayNode();
+
+ Map<Long, Neighbour> natNeighbours = new HashMap<Long, Neighbour>();
+
+ //set left neighbour for each node except the first
+ if(firewall.getId() != 1){
+ natNeighbours.put(1L, new Neighbour(1L, "firewall" + i));
+ }
+ //first firewall: set only client as neighbour and natted node
+ else{
+ natNeighbours.put(1L, new Neighbour(1L, "client"));
+ }
+ //set right neighbour for each node except the last
+ if(firewall.getId() != n){
+ natNeighbours.put(2L, new Neighbour(1L, "firewall" + (i+2)));
+ }
+ //last firewall: set server as neighbour
+ else{
+ natNeighbours.put(2L, new Neighbour(1L, "server"));
+ }
+
+ firewall.setNeighbours(natNeighbours);
+ firewall.setConfiguration(new Configuration(firewall.getName(),"", configArray));
+
+ //add nat to list
+ nodes.add(firewall);
+ }
+
+ Node server = new Node();
+ server.setName("server");
+ server.setFunctional_type("webserver");
+ ArrayNode serverConfigArray = new ObjectMapper().createArrayNode();
+ server.setConfiguration(new Configuration(server.getName(),"", serverConfigArray));
+
+ Map<Long, Neighbour> serverNeighbours = new HashMap<Long, Neighbour>();
+ serverNeighbours.put(1L, new Neighbour(1L, "firewall" + (n)));
+ server.setNeighbours(serverNeighbours );
+
+ //add server to list
+ nodes.add(server);
+
+ //create graph
+ Graph g = new Graph();
+ Map<Long, Node> graphNodes = new HashMap<Long, Node>();
+ long index = 1L;
+ for (Node node : nodes){
+ graphNodes.put(index, node);
+ index++;
+ }
+ g.setNodes(graphNodes);
+
+ return g;
+ }
+
+ private static Graph generateScenario(int n) {
+ List<Node> nodes = new ArrayList<Node>();
+
+ Node firewall = new Node();
+ firewall.setName("firewall");
+ firewall.setFunctional_type("firewall");
+ ArrayNode firewallConfigArray = new ObjectMapper().createArrayNode();
+ Map<Long, Neighbour> firewallNeighbours = new HashMap<Long, Neighbour>();
+
+ for (int i=0; i < n; i++){
+ if(i!=0){
+ JsonNode firewallEntry = new ObjectMapper().createObjectNode();
+ ((ObjectNode) firewallEntry).put("server", "client" + (i+1));
+ firewallConfigArray.add(firewallEntry);
+ }
+ firewallNeighbours.put(new Long(i+1), new Neighbour(new Long(i+1), "client" + (i+1)));
+ }
+
+ firewallNeighbours.put(new Long(n+1), new Neighbour(new Long(n+1), "server"));
+
+ firewall.setConfiguration(new Configuration(firewall.getName(),"", firewallConfigArray));
+
+
+ firewall.setNeighbours(firewallNeighbours );
+ //add client to list
+ nodes.add(firewall);
+
+ for(int i=0; i< n;i++){
+ Node client = new Node();
+ client.setId(i+1);
+ client.setName("client" + (i+1));
+ client.setFunctional_type("endhost");
+ ArrayNode clientConfigArray = new ObjectMapper().createArrayNode();
+ JsonNode clientConfig = new ObjectMapper().createObjectNode();
+ ((ObjectNode)clientConfig).put("url", "www.facebook.com");
+ ((ObjectNode)clientConfig).put("body", "word");
+ ((ObjectNode)clientConfig).put("destination","server");
+ ((ObjectNode)clientConfig).put("protocol", "HTTP_REQUEST");
+ clientConfigArray.add(clientConfig);
+
+ Map<Long, Neighbour> clientNeighbours = new HashMap<Long, Neighbour>();
+
+ clientNeighbours.put(1L, new Neighbour(1L, "firewall"));
+
+ client.setNeighbours(clientNeighbours);
+ client.setConfiguration(new Configuration(client.getName(),"", clientConfigArray));
+
+ //add client to list
+ nodes.add(client);
+ }
+
+ Node server = new Node();
+ server.setName("server");
+ server.setFunctional_type("webserver");
+ ArrayNode serverConfigArray = new ObjectMapper().createArrayNode();
+ server.setConfiguration(new Configuration(server.getName(),"", serverConfigArray));
+
+ Map<Long, Neighbour> serverNeighbours = new HashMap<Long, Neighbour>();
+ serverNeighbours.put(1L, new Neighbour(1L, "firewall"));
+ server.setNeighbours(serverNeighbours );
+
+ //add server to list
+ nodes.add(server);
+
+ //create graph
+ Graph g = new Graph();
+ Map<Long, Node> graphNodes = new HashMap<Long, Node>();
+ long index = 1L;
+ for (Node node : nodes){
+ graphNodes.put(index, node);
+ index++;
+ }
+ g.setNodes(graphNodes);
+
+ return g;
+ }
+
+ private static Graph generateDpiScenario(int n) {
+ List<Node> nodes = new ArrayList<Node>();
+
+ Node client = new Node();
+ client.setName("client");
+ client.setFunctional_type("endhost");
+ ArrayNode clientConfigArray = new ObjectMapper().createArrayNode();
+ JsonNode clientConfig = new ObjectMapper().createObjectNode();
+ ((ObjectNode)clientConfig).put("url", "www.facebook.com");
+ ((ObjectNode)clientConfig).put("body", "word");
+ ((ObjectNode)clientConfig).put("destination","server");
+ ((ObjectNode)clientConfig).put("protocol", "HTTP_REQUEST");
+ clientConfigArray.add(clientConfig);
+ client.setConfiguration(new Configuration(client.getName(),"", clientConfigArray));
+
+ Map<Long, Neighbour> clientNeighbours = new HashMap<Long, Neighbour>();
+ clientNeighbours.put(1L, new Neighbour(1L, "dpi1"));
+ client.setNeighbours(clientNeighbours );
+ //add client to list
+ nodes.add(client);
+
+ for(int i=0; i< n;i++){
+ Node dpi = new Node();
+ dpi.setId(i+1);
+ dpi.setName("dpi" + (i+1));
+ dpi.setFunctional_type("dpi");
+ ArrayNode configArray = new ObjectMapper().createArrayNode();
+ configArray.add("drug");
+
+ Map<Long, Neighbour> natNeighbours = new HashMap<Long, Neighbour>();
+
+ //set left neighbour for each node except the first
+ if(dpi.getId() != 1){
+ natNeighbours.put(1L, new Neighbour(1L, "dpi" + i));
+ }
+ //first firewall: set only client as neighbour and natted node
+ else{
+ natNeighbours.put(1L, new Neighbour(1L, "client"));
+ }
+ //set right neighbour for each node except the last
+ if(dpi.getId() != n){
+ natNeighbours.put(2L, new Neighbour(1L, "dpi" + (i+2)));
+ }
+ //last firewall: set server as neighbour
+ else{
+ natNeighbours.put(2L, new Neighbour(1L, "server"));
+ }
+
+ dpi.setNeighbours(natNeighbours);
+ dpi.setConfiguration(new Configuration(dpi.getName(),"", configArray));
+
+ //add nat to list
+ nodes.add(dpi);
+ }
+
+ Node server = new Node();
+ server.setName("server");
+ server.setFunctional_type("webserver");
+ ArrayNode serverConfigArray = new ObjectMapper().createArrayNode();
+ server.setConfiguration(new Configuration(server.getName(),"", serverConfigArray));
+
+ Map<Long, Neighbour> serverNeighbours = new HashMap<Long, Neighbour>();
+ serverNeighbours.put(1L, new Neighbour(1L, "dpi" + (n)));
+ server.setNeighbours(serverNeighbours );
+
+ //add server to list
+ nodes.add(server);
+
+ //create graph
+ Graph g = new Graph();
+ Map<Long, Node> graphNodes = new HashMap<Long, Node>();
+ long index = 1L;
+ for (Node node : nodes){
+ graphNodes.put(index, node);
+ index++;
+ }
+ g.setNodes(graphNodes);
+
+ return g;
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/test/TestCase.java b/verigraph/src/it/polito/verigraph/test/TestCase.java
new file mode 100644
index 0000000..0cf14ca
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/test/TestCase.java
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * 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.verigraph.test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+
+import it.polito.verigraph.model.Graph;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonPropertyOrder({ "id", "name", "description", "policy_url_parameters", "result", "graph" })
+public class TestCase {
+
+ @JsonProperty("id")
+ private Integer id;
+
+ @JsonProperty("name")
+ private String name;
+
+ @JsonProperty("description")
+ private String description;
+
+ @JsonProperty("policy_url_parameters")
+ private ArrayList<String> policyUrlParameters;
+
+ @JsonProperty("results")
+ private ArrayList<String> results;
+
+ @JsonProperty("graph")
+ private Graph graph;
+
+ @JsonIgnore
+ private Map<String, Object>additionalProperties= new HashMap<String, Object>();
+
+ /**
+ *
+ * @return The id
+ */
+ @JsonProperty("id")
+ public Integer getId() {
+ return id;
+ }
+
+ /**
+ *
+ * @param id
+ * The id
+ */
+ @JsonProperty("id")
+ public void setId(Integer id) {
+ this.id = id;
+ }
+
+ /**
+ *
+ * @return The name
+ */
+ @JsonProperty("name")
+ public String getName() {
+ return name;
+ }
+
+ /**
+ *
+ * @param name
+ * The name
+ */
+ @JsonProperty("name")
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ /**
+ *
+ * @return The description
+ */
+ @JsonProperty("description")
+ public String getDescription() {
+ return description;
+ }
+
+ /**
+ *
+ * @param description
+ * The description
+ */
+ @JsonProperty("description")
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ /**
+ *
+ * @return The policyUrlParameters
+ */
+ @JsonProperty("policy_url_parameters")
+ public List<String> getPolicyUrlParameters() {
+ return policyUrlParameters;
+ }
+
+ /**
+ *
+ * @param policyUrlParameters
+ * The policy_url_parameters
+ */
+ @JsonProperty("policy_url_parameters")
+ public void setPolicyUrlParameters(List<String> policyUrlParameters) {
+ if (this.policyUrlParameters == null)
+ this.policyUrlParameters = new ArrayList<String>();
+
+ this.policyUrlParameters.addAll(policyUrlParameters);
+ }
+
+ /**
+ *
+ * @return The result
+ */
+ @JsonProperty("results")
+ public List<String> getResults() {
+ return results;
+ }
+
+ /**
+ *
+ * @param result
+ * The result
+ */
+ @JsonProperty("results")
+ public void setResults(List<String> results) {
+ if (this.results == null)
+ this.results = new ArrayList<String>();
+ this.results.addAll(results);
+ }
+
+ /**
+ *
+ * @return The graph
+ */
+ @JsonProperty("graph")
+ public Graph getGraph() {
+ return graph;
+ }
+
+ /**
+ *
+ * @param graph
+ * The graph
+ */
+ @JsonProperty("graph")
+ public void setGraph(Graph graph) {
+ this.graph = graph;
+ }
+
+ @JsonAnyGetter
+ public Map<String, Object> getAdditionalProperties() {
+ return this.additionalProperties;
+ }
+
+ @JsonAnySetter
+ public void setAdditionalProperty(String name, Object value) {
+ this.additionalProperties.put(name, value);
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/test/TestExecutionException.java b/verigraph/src/it/polito/verigraph/test/TestExecutionException.java
new file mode 100644
index 0000000..384edd1
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/test/TestExecutionException.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * 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.verigraph.test;
+
+
+public class TestExecutionException extends Exception{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 4749065055436886197L;
+
+ public TestExecutionException(String message){
+ super(message);
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/test/Tester.java b/verigraph/src/it/polito/verigraph/test/Tester.java
new file mode 100644
index 0000000..5344e11
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/test/Tester.java
@@ -0,0 +1,230 @@
+/*******************************************************************************
+ * 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.verigraph.test;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.ResponseProcessingException;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.fge.jsonschema.core.exceptions.ProcessingException;
+import com.github.fge.jsonschema.main.JsonSchema;
+
+import it.polito.verigraph.client.VerifyClient;
+import it.polito.verigraph.client.VerifyClientException;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Verification;
+import it.polito.verigraph.service.ValidationUtils;
+
+public class Tester {
+
+ private File schema;
+
+ private List<File> testFiles= new ArrayList<File>();
+
+ private List<TestCase> testCases= new ArrayList<TestCase>();
+
+ private String target;
+
+ private VerifyClient verifyClient;
+
+ public Tester(String target, File schema, File folder)throws JsonParseException, JsonMappingException, IOException,
+ Exception {
+ init(target, schema, folder);
+ }
+
+ private void init(String target, File schema, File folder)throws JsonParseException, JsonMappingException,
+ IOException, Exception {
+ this.target = target;
+ this.verifyClient = new VerifyClient(this.target);
+ this.schema = schema;
+ this.testFiles = getTests(folder);
+ this.testCases = getTestCases(this.testFiles);
+ }
+
+ public List<File> getTests(File folder) {
+ List<File> filesList = new ArrayList<File>();
+
+ System.out.println("Test folder set to '" + folder.getAbsolutePath() + "'");
+
+ File[] files = folder.listFiles(new FilenameFilter() {
+
+ @Override
+ public boolean accept(File dir, String name) {
+ return name.endsWith(".json");
+ }
+ });
+
+ for (File f : files) {
+ filesList.add(f);
+ System.out.println("File '" + f.getName() + "' added to test files");
+ }
+
+ return filesList;
+ }
+
+ public List<TestCase> getTestCases(List<File> files)throws JsonParseException, JsonMappingException, IOException,
+ Exception {
+ List<TestCase> testCases = new ArrayList<TestCase>();
+
+ for (File file : files) {
+ validateTestFile(file);
+ try {
+ TestCase tc = new ObjectMapper().readValue(file, TestCase.class);
+ testCases.add(tc);
+ }
+ catch (Exception e) {
+ throw e;
+ }
+ }
+
+ return testCases;
+ }
+
+ private void runTestCases() throws VerifyClientException, TestExecutionException {
+ int counter = 0;
+ for (TestCase tc : this.testCases) {
+ List<String> results = runTestCase(tc);
+ Iterator<String> iter = tc.getResults().iterator();
+ for(String result : results){
+ if (iter.hasNext()){
+ if( !result.equals(iter.next()))
+ throw new TestExecutionException("Error running test given in file '"+ this.testFiles.get(counter).getName()
+ + "'. Test returned '" + result + "' instead of '" + tc.getResults() + "'.");
+ else
+ System.out.println("Test given in file '"+ this.testFiles.get(counter).getName() + "' returned '"
+ + result + "' as expected");
+ } else throw new TestExecutionException("Error running test given in file '"+ this.testFiles.get(counter).getName()
+ + "'. Test returned '" + result + "' instead of '" + tc.getResults() + "'.");
+ }
+ counter++;
+ }
+ System.out.println("All tests PASSED");
+ }
+
+ private List<String> runTestCase(TestCase tc) throws VerifyClientException, TestExecutionException{
+ Client client = ClientBuilder.newClient();
+
+ List<String> results = new ArrayList<String>();
+
+ Graph graph = tc.getGraph();
+ Response response = null;
+ try{
+ response = this.verifyClient.createGraph(graph);
+ }
+ catch(ResponseProcessingException e){
+ throw new TestExecutionException("Response processing has failed: " + e.getResponse().readEntity(String.class));
+ }
+ catch(javax.ws.rs.ProcessingException e){
+ throw new TestExecutionException("HTTP request failed");
+ }
+ Graph createdGraph = response.readEntity(Graph.class);
+ for (String urlParams : tc.getPolicyUrlParameters()){
+ WebTarget target = client.target(this.target + "/graphs/" + createdGraph.getId() + "/policy" + urlParams);
+
+ response = target.request().get();
+ Verification verification = response.readEntity(Verification.class);
+ results.add(verification.getResult());
+ }
+ return results;
+ }
+
+ public void validateTestFile(File testFile) throws Exception {
+ JsonSchema schemaNode = null;
+ try {
+ schemaNode = ValidationUtils.getSchemaNode(schema);
+ }
+ catch (IOException e) {
+ throw new Exception("Unable to load '" + schema.getAbsolutePath() + "' schema file");
+ }
+ catch (ProcessingException e) {
+ throw new Exception("Unable to resolve '" + schema.getAbsolutePath() + "' schema file as a schema node");
+ }
+
+ JsonNode jsonNode;
+ try {
+ jsonNode = ValidationUtils.getJsonNode(testFile);
+ }
+ catch (IOException e) {
+ throw new Exception("Unable to load '" + testFile.getAbsolutePath() + "' as a json node");
+ }
+
+ try {
+ ValidationUtils.validateJson(schemaNode, jsonNode);
+ }
+ catch (ProcessingException e) {
+ throw new Exception("There were errors in the validation of file '"+ testFile.getAbsolutePath()
+ + "' against the json schema '" + schema.getAbsolutePath() + "': " + e.getMessage());
+
+ }
+ }
+
+ public static void main(String[] args)throws JsonParseException, JsonMappingException, IOException,
+ VerifyClientException, Exception {
+ String folderName = System.getProperty("user.dir") + "/tester/testcases";
+ File folder = new File(folderName);
+ if (!folder.exists()) {
+ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+ String s;
+ do{
+ System.out.println("Please enter the testcases folder path: ");
+ s = in.readLine();
+ if (isValidpath(s)){
+ folder = new File(s);
+ break;
+ }
+ }while (s != null && s.length() != 0);
+ if(s == null)
+ System.exit(0);
+ }
+ String schemaName = System.getProperty("user.dir") + "/tester/testcase_schema.json";
+ File schema = new File(schemaName);
+ if (!schema.exists()) {
+ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+ String s;
+ do{
+ System.out.println("Please enter the full path of 'testcase_schema.json': ");
+ s = in.readLine();
+ if (isValidpath(s)){
+ folder = new File(s);
+ break;
+ }
+ }while (s != null && s.length() != 0);
+ if(s == null)
+ System.exit(0);
+ }
+
+ Tester tester = new Tester("http://localhost:8080/verigraph/api", schema, folder);
+
+ tester.runTestCases();
+
+ }
+
+ private static boolean isValidpath(String s) {
+ if (s==null)
+ return false;
+ File file = new File(s);
+ return file.exists();
+ }
+
+}
diff --git a/verigraph/src/it/polito/verigraph/validation/DpiValidator.java b/verigraph/src/it/polito/verigraph/validation/DpiValidator.java
new file mode 100644
index 0000000..f3c1dfc
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/DpiValidator.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * 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.verigraph.validation;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.validation.exception.ValidationException;
+
+public class DpiValidator implements ValidationInterface {
+
+ public DpiValidator(){
+
+ }
+
+ private void validateKey(String key) throws ValidationException {
+ if (!key.matches("\\w+"))
+ throw new ValidationException("'" + key + "' is not a valid configuration string for a 'dpi'");
+ }
+
+ @Override
+ public void validate(Graph graph, Node node, Configuration configuration) throws ValidationException {
+
+ JsonNode conf = configuration.getConfiguration();
+
+ if (!conf.isArray()) {
+ throw new ValidationException("Configuration of a 'dpi' must be an array");
+ }
+ for (JsonNode key : conf) {
+ if (!key.isTextual())
+ throw new ValidationException("Configuration of a 'dpi' must be an array of strings");
+ validateKey(key.asText());
+ }
+ }
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/validation/EndhostValidator.java b/verigraph/src/it/polito/verigraph/validation/EndhostValidator.java
new file mode 100644
index 0000000..218e2cc
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/EndhostValidator.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * 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.verigraph.validation;
+
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.validation.exception.ValidationException;
+
+
+public class EndhostValidator implements ValidationInterface {
+
+ @Override
+ public void validate(Graph graph, Node node, Configuration configuration) throws ValidationException {
+
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/validation/ValidationInterface.java b/verigraph/src/it/polito/verigraph/validation/ValidationInterface.java
new file mode 100644
index 0000000..f5af892
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/ValidationInterface.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * 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.verigraph.validation;
+
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.validation.exception.ValidationException;
+
+public interface ValidationInterface {
+
+ void validate(Graph graph, Node node, Configuration configuration) throws ValidationException;
+
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/validation/VpnaccessValidator.java b/verigraph/src/it/polito/verigraph/validation/VpnaccessValidator.java
new file mode 100644
index 0000000..f7faa10
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/VpnaccessValidator.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * 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.verigraph.validation;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.validation.exception.ValidationException;
+
+public class VpnaccessValidator implements ValidationInterface {
+
+ @Override
+ public void validate(Graph graph, Node node, Configuration configuration) throws ValidationException {
+ JsonNode configurationNode = configuration.getConfiguration();
+
+ if (!configurationNode.isArray())
+ throw new ValidationException("configuration must be an array");
+
+ for (JsonNode object : configurationNode) {
+ JsonNode vpnexit = object.get("vpnexit");
+ if (!vpnexit.isTextual())
+ throw new ValidationException("value corresponding to the key 'vpnexit' must be a string");
+ validateObject(graph, node, vpnexit.asText());
+ }
+
+ }
+
+ private void validateObject(Graph g, Node node, String field) throws ValidationException {
+ boolean isValid = false;
+ for (Node n : g.getNodes().values()) {
+ if ((n.getFunctional_type().equals("vpnexit")) && (n.getName().equals(field)))
+ isValid = true;
+ }
+
+ if (!isValid)
+ throw new ValidationException("'"+ field + "' is not a valid value for the configuration of a type '"
+ + node.getFunctional_type()
+ + "'. Please use the name of an existing node of type 'vpnexit'.");
+
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/validation/VpnexitValidator.java b/verigraph/src/it/polito/verigraph/validation/VpnexitValidator.java
new file mode 100644
index 0000000..4bb249d
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/VpnexitValidator.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * 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.verigraph.validation;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+import it.polito.verigraph.model.Configuration;
+import it.polito.verigraph.model.Graph;
+import it.polito.verigraph.model.Node;
+import it.polito.verigraph.validation.exception.ValidationException;
+
+public class VpnexitValidator implements ValidationInterface {
+
+ @Override
+ public void validate(Graph graph, Node node, Configuration configuration) throws ValidationException {
+ JsonNode configurationNode = configuration.getConfiguration();
+
+ if (!configurationNode.isArray())
+ throw new ValidationException("configuration must be an array");
+
+ for (JsonNode object : configurationNode) {
+ JsonNode vpnexit = object.get("vpnaccess");
+ if (!vpnexit.isTextual())
+ throw new ValidationException("value corresponding to the key 'vpnaccess' must be a string");
+ validateObject(graph, node, vpnexit.asText());
+ }
+
+ }
+
+ private void validateObject(Graph g, Node node, String field) throws ValidationException {
+ boolean isValid = false;
+ for (Node n : g.getNodes().values()) {
+ if ((n.getFunctional_type().equals("vpnaccess")) && (n.getName().equals(field)))
+ isValid = true;
+ }
+
+ if (!isValid)
+ throw new ValidationException("'"+ field + "' is not a valid value for the configuration of a type '"
+ + node.getFunctional_type()
+ + "'. Please use the name of an existing node of type 'vpnaccess'.");
+
+ }
+} \ No newline at end of file
diff --git a/verigraph/src/it/polito/verigraph/validation/exception/ValidationException.java b/verigraph/src/it/polito/verigraph/validation/exception/ValidationException.java
new file mode 100644
index 0000000..5ad3406
--- /dev/null
+++ b/verigraph/src/it/polito/verigraph/validation/exception/ValidationException.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.verigraph.validation.exception;
+
+public class ValidationException extends Exception {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -8251271078519549101L;
+
+ private String message;
+
+ public ValidationException(String message){
+ //super(message);
+ this.message = message;
+ }
+
+ @Override
+ public String getMessage() {
+ return this.message;
+ }
+} \ No newline at end of file