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

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