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