verigraph/src/it/polito/verigraph/grpc/server/Service.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.HashMap;
  13 import java.util.Map;
  14 import java.util.logging.FileHandler;
  15 import java.util.logging.Level;
  16 import java.util.logging.Logger;
  17 import java.util.logging.SimpleFormatter;
  18 import io.grpc.Server;
  19 import io.grpc.ServerBuilder;
  20 import io.grpc.stub.StreamObserver;
  21 import it.polito.verigraph.grpc.ConfigurationGrpc;
  22 import it.polito.verigraph.grpc.GetRequest;
  23 import it.polito.verigraph.grpc.GraphGrpc;
  24 import it.polito.verigraph.grpc.NeighbourGrpc;
  25 import it.polito.verigraph.grpc.NewGraph;
  26 import it.polito.verigraph.grpc.NewNeighbour;
  27 import it.polito.verigraph.grpc.NewNode;
  28 import it.polito.verigraph.grpc.NodeGrpc;
  29 import it.polito.verigraph.grpc.Policy;
  30 import it.polito.verigraph.grpc.RequestID;
  31 import it.polito.verigraph.grpc.Status;
  32 import it.polito.verigraph.grpc.VerificationGrpc;
  33 import it.polito.verigraph.grpc.VerigraphGrpc;
  34 import it.polito.verigraph.exception.BadRequestException;
  35 import it.polito.verigraph.exception.DataNotFoundException;
  36 import it.polito.verigraph.exception.ForbiddenException;
  37 import it.polito.verigraph.model.Configuration;
  38 import it.polito.verigraph.model.Graph;
  39 import it.polito.verigraph.model.Neighbour;
  40 import it.polito.verigraph.model.Node;
  41 import it.polito.verigraph.model.Verification;
  42 import it.polito.verigraph.resources.beans.VerificationBean;
  43 import it.polito.verigraph.service.GraphService;
  44 import it.polito.verigraph.service.NeighbourService;
  45 import it.polito.verigraph.service.NodeService;
  46 import it.polito.verigraph.service.VerificationService;
  47
  48 public class Service {
  49     /** Port on which the server should run. */
  50     private static final Logger logger = Logger.getLogger(Service.class.getName());
  51     private static final int port = 50051;
  52     private static final String internalError = "Internal Server Error";
  53     private Server server;
  54     private GraphService graphService= new GraphService();
  55     private VerificationService verificationService = new VerificationService();
  56     private NodeService nodeService = new NodeService();
  57     private NeighbourService neighboursService = new NeighbourService();
  58
  59     public Service(int port) {
  60         this(ServerBuilder.forPort(port), port);
  61     }
  62
  63     /** Create a RouteGuide server using serverBuilder as a base and features as data. */
  64     public Service(ServerBuilder<?> serverBuilder, int port) {
  65         server = serverBuilder.addService(new VerigraphImpl())
  66                 .build();
  67     }
  68
  69     public void start() throws IOException {
  70         FileHandler fileTxt = new FileHandler("grpc_server_log.txt");
  71         SimpleFormatter formatterTxt = new SimpleFormatter();
  72         fileTxt.setFormatter(formatterTxt);
  73         logger.addHandler(fileTxt);
  74         server.start();
  75         logger.info("Server started, listening on "+ port);
  76         Runtime.getRuntime().addShutdownHook(new Thread() {
  77             @Override
  78             public void run() {
  79                 logger.info("*** Shutting down gRPC server since JVM is shutting down");
  80                 Service.this.stop();
  81                 logger.info("*** Server shut down");
  82             }
  83         });
  84     }
  85
  86     public void stop() {
  87         if (server != null) {
  88             server.shutdown();
  89         }
  90     }
  91
  92     private void blockUntilShutdown() throws InterruptedException {
  93         if (server != null) {
  94             server.awaitTermination();
  95         }
  96     }
  97
  98     /** Main function to launch server from cmd. */
  99     public static void main(String[] args) throws IOException, InterruptedException {
 100         try{
 101             Service server = new Service(port);
 102             server.start();
 103             server.blockUntilShutdown();
 104         }
 105         catch(Exception ex){
 106             logger.log(Level.WARNING, ex.getMessage());
 107         }
 108     }
 109
 110     /**Here start method of my implementation*/
 111     private class VerigraphImpl extends VerigraphGrpc.VerigraphImplBase{
 112
 113         /** Here start methods of GraphResource*/
 114         @Override
 115         public void getGraphs(GetRequest request, StreamObserver<GraphGrpc> responseObserver) {
 116             try{
 117                 for(Graph item : graphService.getAllGraphs()) {
 118                     GraphGrpc gr = GrpcUtils.obtainGraph(item);
 119                     responseObserver.onNext(gr);
 120                 }
 121             }catch(Exception ex){
 122                 GraphGrpc nr = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
 123                 responseObserver.onNext(nr);
 124                 logger.log(Level.WARNING, ex.getMessage());
 125             }
 126             responseObserver.onCompleted();
 127         }
 128
 129         @Override
 130         public void createGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
 131             NewGraph.Builder response = NewGraph.newBuilder();
 132             try{
 133                 Graph graph = GrpcUtils.deriveGraph(request);
 134                 Graph newGraph = graphService.addGraph(graph);
 135                 response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
 136             }catch(BadRequestException ex){
 137                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 138                 logger.log(Level.WARNING, ex.getClass().toString());
 139                 logger.log(Level.WARNING, ex.getMessage());
 140
 141             }
 142             catch(Exception ex){
 143                 response.setSuccess(false).setErrorMessage(internalError);
 144                 logger.log(Level.WARNING, ex.getClass().toString());
 145                 logger.log(Level.WARNING, ex.getMessage());
 146             }
 147             responseObserver.onNext(response.build());
 148             responseObserver.onCompleted();
 149         }
 150
 151         @Override
 152         public void deleteGraph(RequestID request, StreamObserver<Status> responseObserver) {
 153
 154             Status.Builder response = Status.newBuilder();
 155             try{
 156                 graphService.removeGraph(request.getIdGraph());
 157                 response.setSuccess(true);
 158             }catch(ForbiddenException ex){
 159                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 160                 logger.log(Level.WARNING, ex.getMessage());
 161             }catch(Exception ex){
 162                 response.setSuccess(false).setErrorMessage(internalError);
 163                 logger.log(Level.WARNING, ex.getMessage());
 164             }
 165             responseObserver.onNext(response.build());
 166             responseObserver.onCompleted();
 167         }
 168
 169         @Override
 170         public void getGraph(RequestID request, StreamObserver<GraphGrpc> responseObserver) {
 171             try{
 172                 Graph graph = graphService.getGraph(request.getIdGraph());
 173                 GraphGrpc gr = GrpcUtils.obtainGraph(graph);
 174                 responseObserver.onNext(gr);
 175             }catch(ForbiddenException | DataNotFoundException ex){
 176                 GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 177                 responseObserver.onNext(grError);
 178                 logger.log(Level.WARNING, ex.getMessage());
 179             }catch(Exception ex){
 180                 GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
 181                 responseObserver.onNext(grError);
 182                 logger.log(Level.WARNING, ex.getMessage());
 183             }
 184             responseObserver.onCompleted();
 185         }
 186
 187         @Override
 188         public void updateGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
 189             NewGraph.Builder response = NewGraph.newBuilder();
 190             try{
 191                 Graph graph = GrpcUtils.deriveGraph(request);
 192                 graph.setId(request.getId());
 193                 Graph newGraph = graphService.updateGraph(graph);
 194                 response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
 195             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 196                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 197                 logger.log(Level.WARNING, ex.getMessage());
 198             }catch(Exception ex){
 199                 response.setSuccess(false).setErrorMessage(internalError);
 200                 logger.log(Level.WARNING, ex.getMessage());
 201             }
 202             responseObserver.onNext(response.build());
 203             responseObserver.onCompleted();
 204         }
 205
 206         @Override
 207         public void verifyPolicy(Policy request, StreamObserver<VerificationGrpc> responseObserver) {
 208
 209             VerificationGrpc.Builder verification;
 210             try{
 211                 //Convert request
 212                 VerificationBean verify = new VerificationBean();
 213                 verify.setDestination(request.getDestination());
 214                 verify.setSource(request.getSource());
 215                 verify.setType(request.getType().toString());
 216                 verify.setMiddlebox(request.getMiddlebox());
 217
 218                 //Convert Response
 219                 Verification ver = verificationService.verify(request.getIdGraph(), verify);
 220                 verification = VerificationGrpc.newBuilder(GrpcUtils.obtainVerification(ver))
 221                         .setSuccessOfOperation(true);
 222             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 223                 verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
 224                         .setErrorMessage(ex.getMessage());
 225                 logger.log(Level.WARNING, ex.getMessage());
 226             }catch(Exception ex){
 227                 verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
 228                         .setErrorMessage(internalError);
 229                 logger.log(Level.WARNING, ex.getMessage());
 230             }
 231             responseObserver.onNext(verification.build());
 232             responseObserver.onCompleted();
 233         }
 234
 235         /** Here start methods of NodeResource*/
 236
 237         @Override
 238         public void getNodes(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
 239             try{
 240                 for (Node item : nodeService.getAllNodes(request.getIdGraph())) {
 241                     NodeGrpc nr = GrpcUtils.obtainNode(item);
 242                     responseObserver.onNext(nr);
 243                 }
 244             }catch(ForbiddenException | DataNotFoundException ex){
 245                 NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 246                 responseObserver.onNext(nr);
 247                 logger.log(Level.WARNING, ex.getMessage());
 248             }catch(Exception ex){
 249                 NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
 250                 responseObserver.onNext(nr);
 251                 logger.log(Level.WARNING, ex.getMessage());
 252             }
 253             responseObserver.onCompleted();
 254         }
 255
 256         @Override
 257         public void createNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
 258             NewNode.Builder response = NewNode.newBuilder();
 259             try{
 260                 Node node = GrpcUtils.deriveNode(request);
 261                 Node newNode = nodeService.addNode(request.getIdGraph(), node);
 262                 response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
 263             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 264                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 265                 logger.log(Level.WARNING, ex.getMessage());
 266             }catch(Exception ex){
 267                 response.setSuccess(false).setErrorMessage(internalError);
 268                 logger.log(Level.WARNING, ex.getMessage());
 269             }
 270             responseObserver.onNext(response.build());
 271             responseObserver.onCompleted();
 272         }
 273
 274         @Override
 275         public void deleteNode(RequestID request, StreamObserver<Status> responseObserver) {
 276             Status.Builder response = Status.newBuilder();
 277             try{
 278                 nodeService.removeNode(request.getIdGraph(), request.getIdNode());
 279                 response.setSuccess(true);
 280             }catch(ForbiddenException | DataNotFoundException ex){
 281                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 282                 logger.log(Level.WARNING, ex.getMessage());
 283             }catch(Exception ex){
 284                 response.setSuccess(false).setErrorMessage(internalError);
 285                 logger.log(Level.WARNING, ex.getMessage());
 286             }
 287             responseObserver.onNext(response.build());
 288             responseObserver.onCompleted();
 289         }
 290
 291         @Override
 292         public void getNode(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
 293             NodeGrpc nr;
 294             try{
 295                 Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
 296                 nr= GrpcUtils.obtainNode(node);
 297             }catch(ForbiddenException | DataNotFoundException ex){
 298                 nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 299                 logger.log(Level.WARNING, ex.getMessage());
 300             }catch(Exception ex){
 301                 nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
 302                 logger.log(Level.WARNING, ex.getMessage());
 303             }
 304             responseObserver.onNext(nr);
 305             responseObserver.onCompleted();
 306         }
 307
 308         @Override
 309         public void updateNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
 310             NewNode.Builder response = NewNode.newBuilder();
 311             try{
 312                 Node node = GrpcUtils.deriveNode(request);
 313                 node.setId(request.getId());
 314                 Node newNode = nodeService.updateNode(request.getIdGraph(), node);
 315                 response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
 316             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 317                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 318                 logger.log(Level.WARNING, ex.getMessage());
 319             }catch(Exception ex){
 320                 response.setSuccess(false).setErrorMessage(internalError);
 321                 logger.log(Level.WARNING, ex.getMessage());
 322             }
 323             responseObserver.onNext(response.build());
 324             responseObserver.onCompleted();
 325         }
 326
 327         @Override
 328         public void configureNode(ConfigurationGrpc request, StreamObserver<Status> responseObserver) {
 329             Status.Builder response = Status.newBuilder();
 330             try{
 331                 if (request.getIdGraph() <= 0) {
 332                     throw new ForbiddenException("Illegal graph id: " + request.getIdGraph());
 333                 }
 334                 if (request.getIdNode() <= 0) {
 335                     throw new ForbiddenException("Illegal node id: " + request.getIdNode());
 336                 }
 337                 Graph graph = new GraphService().getGraph(request.getIdGraph());
 338                 if (graph == null){
 339                     throw new BadRequestException("Graph with id " + request.getIdGraph() + " not found");
 340                 }
 341                 Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
 342                 if (node == null){
 343                     throw new BadRequestException("Node with id " + request.getIdNode() + " not found in graph with id " + request.getIdGraph());
 344                 }
 345                 Configuration nodeConfiguration = GrpcUtils.deriveConfiguration(request);
 346                 Node nodeCopy = new Node();
 347                 nodeCopy.setId(node.getId());
 348                 nodeCopy.setName(node.getName());
 349                 nodeCopy.setFunctional_type(node.getFunctional_type());
 350                 Map<Long,Neighbour> nodes = new HashMap<Long,Neighbour>();
 351                 nodes.putAll(node.getNeighbours());
 352                 nodeCopy.setNeighbours(nodes);
 353                 nodeConfiguration.setId(nodeCopy.getName());
 354                 nodeCopy.setConfiguration(nodeConfiguration);
 355                 Graph graphCopy = new Graph();
 356                 graphCopy.setId(graph.getId());
 357                 graphCopy.setNodes(new HashMap<Long, Node>(graph.getNodes()));
 358                 graphCopy.getNodes().remove(node.getId());
 359                 NodeService.validateNode(graphCopy, nodeCopy);
 360                 graph.getNodes().put(request.getIdNode(), nodeCopy);
 361                 response.setSuccess(true);
 362             }catch(ForbiddenException | BadRequestException ex){
 363                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 364                 logger.log(Level.WARNING, ex.getMessage());
 365             }catch(Exception ex){
 366                 response.setSuccess(false).setErrorMessage(internalError);
 367                 logger.log(Level.WARNING, ex.getMessage());
 368             }
 369             responseObserver.onNext(response.build());
 370             responseObserver.onCompleted();
 371         }
 372
 373         /** Here start methods of NeighbourResource*/
 374         @Override
 375         public void getNeighbours(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
 376             try{
 377                 for(Neighbour item : neighboursService.getAllNeighbours(request.getIdGraph(), request.getIdNode())) {
 378                     NeighbourGrpc nr = GrpcUtils.obtainNeighbour(item);
 379                     responseObserver.onNext(nr);
 380                 }
 381             }catch(ForbiddenException | DataNotFoundException ex){
 382                 NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 383                 responseObserver.onNext(nr);
 384                 logger.log(Level.WARNING, ex.getMessage());
 385             }catch(Exception ex){
 386                 NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
 387                 responseObserver.onNext(nr);
 388                 logger.log(Level.WARNING, ex.getMessage());
 389             }
 390             responseObserver.onCompleted();
 391         }
 392
 393         @Override
 394         public void createNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
 395             NewNeighbour.Builder response = NewNeighbour.newBuilder();
 396             try{
 397                 Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
 398                 Neighbour newNeighbour = neighboursService.addNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
 399                 response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
 400             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 401                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 402                 logger.log(Level.WARNING, ex.getMessage());
 403             }catch(Exception ex){
 404                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 405                 logger.log(Level.WARNING, ex.getMessage());
 406             }
 407             responseObserver.onNext(response.build());
 408             responseObserver.onCompleted();
 409         }
 410
 411         @Override
 412         public void deleteNeighbour(RequestID request, StreamObserver<Status> responseObserver) {
 413             Status.Builder response = Status.newBuilder();
 414             try{
 415                 neighboursService.removeNeighbour(request.getIdGraph(), request.getIdNode(), request.getIdNeighbour());
 416                 response.setSuccess(true);
 417             }catch(ForbiddenException | DataNotFoundException ex){
 418                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 419                 logger.log(Level.WARNING, ex.getMessage());
 420             }catch(Exception ex){
 421                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 422                 logger.log(Level.WARNING, ex.getMessage());
 423             }
 424             responseObserver.onNext(response.build());
 425             responseObserver.onCompleted();
 426         }
 427
 428         @Override
 429         public void getNeighbour(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
 430             NeighbourGrpc nr;
 431             try{
 432                 Neighbour neighbour = neighboursService.getNeighbour(request.getIdGraph(),
 433                         request.getIdNode(), request.getIdNeighbour());
 434                 nr = GrpcUtils.obtainNeighbour(neighbour);
 435
 436             }catch(ForbiddenException | DataNotFoundException ex){
 437                 nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 438                 logger.log(Level.WARNING, ex.getMessage());
 439             }catch(Exception ex){
 440                 nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
 441                 logger.log(Level.WARNING, ex.getMessage());
 442             }
 443             responseObserver.onNext(nr);
 444             responseObserver.onCompleted();
 445         }
 446
 447         @Override
 448         public void updateNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
 449             NewNeighbour.Builder response = NewNeighbour.newBuilder();
 450             try{
 451                 Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
 452                 neighbour.setId(request.getId());
 453                 Neighbour newNeighbour = neighboursService.updateNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
 454                 response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
 455             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 456                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 457                 logger.log(Level.WARNING, ex.getMessage());
 458             }catch(Exception ex){
 459                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 460                 logger.log(Level.WARNING, ex.getMessage());
 461             }
 462             responseObserver.onNext(response.build());
 463             responseObserver.onCompleted();
 464         }
 465     }
 466 }