verigraph/src/it/polito/verigraph/grpc/server/GrpcUtils.java

   1 /*******************************************************************************
   2  * Copyright (c) 2017 Politecnico di Torino and others.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Apache License, Version 2.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *******************************************************************************/
   9 package it.polito.verigraph.grpc.server;
  10
  11 import java.io.IOException;
  12 import java.util.Map;
  13 import java.util.logging.Level;
  14 import java.util.logging.Logger;
  15 import com.fasterxml.jackson.databind.JsonNode;
  16 import com.fasterxml.jackson.databind.ObjectMapper;
  17 import com.google.common.base.Splitter;
  18 import it.polito.verigraph.grpc.ConfigurationGrpc;
  19 import it.polito.verigraph.grpc.GraphGrpc;
  20 import it.polito.verigraph.grpc.NeighbourGrpc;
  21 import it.polito.verigraph.grpc.NodeGrpc;
  22 import it.polito.verigraph.grpc.TestGrpc;
  23 import it.polito.verigraph.grpc.VerificationGrpc;
  24 import it.polito.verigraph.grpc.NodeGrpc.FunctionalType;
  25 import it.polito.verigraph.model.Configuration;
  26 import it.polito.verigraph.model.Graph;
  27 import it.polito.verigraph.model.Neighbour;
  28 import it.polito.verigraph.model.Node;
  29 import it.polito.verigraph.model.Test;
  30 import it.polito.verigraph.model.Verification;
  31
  32 public class GrpcUtils {
  33     private static final Logger logger = Logger.getLogger(GrpcUtils.class.getName());
  34
  35     public static NeighbourGrpc obtainNeighbour(Neighbour ne){
  36         return NeighbourGrpc.newBuilder()
  37                 .setId(ne.getId())
  38                 .setName(ne.getName())
  39                 .build();
  40     }
  41
  42     public static Neighbour deriveNeighbour(NeighbourGrpc request) {
  43         //id is not present
  44         Neighbour ne = new Neighbour();
  45         ne.setName(request.getName());
  46         return ne;
  47     }
  48
  49     public static ConfigurationGrpc obtainConfiguration(Configuration conf){
  50         return ConfigurationGrpc.newBuilder()
  51                 .setId(conf.getId())
  52                 .setDescription(conf.getDescription())
  53                 .setConfiguration(conf.getConfiguration().toString())
  54                 .build();
  55     }
  56
  57     public static Configuration deriveConfiguration(ConfigurationGrpc request) {
  58         Configuration conf = new Configuration();
  59         conf.setId(request.getId());
  60         conf.setDescription(request.getDescription());
  61         ObjectMapper mapper = new ObjectMapper();
  62         JsonNode rootNode = null;
  63         try {
  64             if ("".equals(request.getConfiguration()))
  65                 rootNode=mapper.readTree("[]");
  66             else
  67                 rootNode = mapper.readTree(request.getConfiguration());
  68         } catch (IOException e) {
  69             logger.log(Level.WARNING, e.getMessage());
  70         }
  71         conf.setConfiguration(rootNode);
  72         return conf;
  73     }
  74
  75     public static NodeGrpc obtainNode(Node node) {
  76         NodeGrpc.Builder nr = NodeGrpc.newBuilder();
  77         nr.setId(node.getId());
  78         nr.setName(node.getName());
  79         nr.setFunctionalType(FunctionalType.valueOf(node.getFunctional_type()));
  80         for(Neighbour neighbour:node.getNeighbours().values()){
  81             NeighbourGrpc ng = obtainNeighbour(neighbour);
  82             nr.addNeighbour(ng);
  83         }
  84         nr.setConfiguration(obtainConfiguration(node.getConfiguration()));
  85         return nr.build();
  86     }
  87
  88     public static Node deriveNode(NodeGrpc request) {
  89         //id is not present
  90         Node node = new Node();
  91         node.setName(request.getName());
  92         node.setFunctional_type(request.getFunctionalType().toString());
  93         Configuration conf = deriveConfiguration(request.getConfiguration());
  94         node.setConfiguration(conf);
  95
  96         Map<Long,Neighbour> neighours = node.getNeighbours();
  97         long i = 1;
  98         for(NeighbourGrpc neighbour:request.getNeighbourList()){
  99             Neighbour ng = deriveNeighbour(neighbour);
 100             neighours.put(i++, ng);
 101         }
 102
 103         return node;
 104     }
 105
 106     public static GraphGrpc obtainGraph(Graph graph){
 107         GraphGrpc.Builder gr = GraphGrpc.newBuilder();
 108         gr.setId(graph.getId());
 109         for(Node node:graph.getNodes().values()){
 110             NodeGrpc ng = obtainNode(node);
 111             gr.addNode(ng);
 112         }
 113         return gr.build();
 114     }
 115
 116     public static Graph deriveGraph(GraphGrpc request) {
 117         //id is not present
 118         Graph graph = new Graph();
 119
 120         long i=1;
 121         Map<Long, Node> nodes= graph.getNodes();
 122         for(NodeGrpc node:request.getNodeList()){
 123             Node ng = deriveNode(node);
 124             nodes.put(i++, ng);
 125         }
 126
 127         return graph;
 128     }
 129
 130     public static VerificationGrpc obtainVerification(Verification verify){
 131         VerificationGrpc.Builder ver = VerificationGrpc.newBuilder();
 132         ver.setComment(verify.getComment());
 133         ver.setResult(verify.getResult());
 134         for(Test test:verify.getTests()){
 135             TestGrpc.Builder tst = TestGrpc.newBuilder().setResult(test.getResult());
 136             for(Node node:test.getPath()){
 137                 NodeGrpc ng = obtainNode(node);
 138                 tst.addNode(ng);
 139             }
 140             ver.addTest(tst);
 141         }
 142         return ver.build();
 143     }
 144
 145     /**Intended for string that begins with "?"
 146      * */
 147     public static Map<String,String> getParamGivenString(String str){
 148         String string = str.substring(1);
 149         final Map<String, String> map = Splitter.on('&').trimResults().withKeyValueSeparator("=").
 150                 split(string);
 151         return map;
 152     }
 153 }