summaryrefslogtreecommitdiffstats
path: root/verigraph/src/it/polito/neo4j/translator
diff options
context:
space:
mode:
Diffstat (limited to 'verigraph/src/it/polito/neo4j/translator')
-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
3 files changed, 979 insertions, 0 deletions
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;