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
  19 import io.grpc.Server;
  20 import io.grpc.ServerBuilder;
  21 import io.grpc.stub.StreamObserver;
  22 import it.polito.verigraph.exception.BadRequestException;
  23 import it.polito.verigraph.exception.DataNotFoundException;
  24 import it.polito.verigraph.exception.ForbiddenException;
  25 import it.polito.verigraph.grpc.ConfigurationGrpc;
  26 import it.polito.verigraph.grpc.GetRequest;
  27 import it.polito.verigraph.grpc.GraphGrpc;
  28 import it.polito.verigraph.grpc.NeighbourGrpc;
  29 import it.polito.verigraph.grpc.NewGraph;
  30 import it.polito.verigraph.grpc.NewNeighbour;
  31 import it.polito.verigraph.grpc.NewNode;
  32 import it.polito.verigraph.grpc.NewTopologyTemplate;
  33 import it.polito.verigraph.grpc.NodeGrpc;
  34 import it.polito.verigraph.grpc.Policy;
  35 import it.polito.verigraph.grpc.RequestID;
  36 import it.polito.verigraph.grpc.Status;
  37 import it.polito.verigraph.grpc.TopologyTemplateGrpc;
  38 import it.polito.verigraph.grpc.ToscaPolicy;
  39 import it.polito.verigraph.grpc.ToscaRequestID;
  40 import it.polito.verigraph.grpc.ToscaVerificationGrpc;
  41 import it.polito.verigraph.grpc.VerificationGrpc;
  42 import it.polito.verigraph.grpc.VerigraphGrpc;
  43 import it.polito.verigraph.model.Configuration;
  44 import it.polito.verigraph.model.Graph;
  45 import it.polito.verigraph.model.Neighbour;
  46 import it.polito.verigraph.model.Node;
  47 import it.polito.verigraph.model.Verification;
  48 import it.polito.verigraph.resources.beans.VerificationBean;
  49 import it.polito.verigraph.service.GraphService;
  50 import it.polito.verigraph.service.NeighbourService;
  51 import it.polito.verigraph.service.NodeService;
  52 import it.polito.verigraph.service.VerificationService;
  53 import it.polito.verigraph.tosca.converter.grpc.GraphToGrpc;
  54 import it.polito.verigraph.tosca.converter.grpc.GrpcToGraph;
  55
  56 public class Service {
  57     /** Port on which the server should run. */
  58     private static final Logger logger = Logger.getLogger(Service.class.getName());
  59     private static final int port = 50051;
  60     private static final String internalError = "Internal Server Error";
  61     private Server server;
  62     private GraphService graphService= new GraphService();
  63     private VerificationService verificationService = new VerificationService();
  64     private NodeService nodeService = new NodeService();
  65     private NeighbourService neighboursService = new NeighbourService();
  66
  67     public Service(int port) {
  68         this(ServerBuilder.forPort(port), port);
  69     }
  70
  71     /** Create a RouteGuide server using serverBuilder as a base and features as data. */
  72     public Service(ServerBuilder<?> serverBuilder, int port) {
  73         server = serverBuilder.addService(new VerigraphImpl())
  74                 .build();
  75     }
  76
  77     public void start() throws IOException {
  78         FileHandler fileTxt = new FileHandler("grpc_server_log.txt");
  79         SimpleFormatter formatterTxt = new SimpleFormatter();
  80         fileTxt.setFormatter(formatterTxt);
  81         logger.addHandler(fileTxt);
  82         server.start();
  83         logger.info("Server started, listening on "+ port);
  84         Runtime.getRuntime().addShutdownHook(new Thread() {
  85             @Override
  86             public void run() {
  87                 logger.info("*** Shutting down gRPC server since JVM is shutting down");
  88                 Service.this.stop();
  89                 logger.info("*** Server shut down");
  90             }
  91         });
  92     }
  93
  94     public void stop() {
  95         if (server != null) {
  96             server.shutdown();
  97         }
  98     }
  99
 100     private void blockUntilShutdown() throws InterruptedException {
 101         if (server != null) {
 102             server.awaitTermination();
 103         }
 104     }
 105
 106     /** Main function to launch server from cmd. */
 107     public static void main(String[] args) throws IOException, InterruptedException {
 108         try{
 109             Service server = new Service(port);
 110             server.start();
 111             server.blockUntilShutdown();
 112         }
 113         catch(Exception ex){
 114             logger.log(Level.WARNING, ex.getMessage());
 115         }
 116     }
 117
 118     /** Here start methods */
 119     private class VerigraphImpl extends VerigraphGrpc.VerigraphImplBase{
 120
 121         /** Here start methods of GraphResource*/
 122         @Override
 123         public void getGraphs(GetRequest request, StreamObserver<GraphGrpc> responseObserver) {
 124             try{
 125                 for(Graph item : graphService.getAllGraphs()) {
 126                     GraphGrpc gr = GrpcUtils.obtainGraph(item);
 127                     responseObserver.onNext(gr);
 128                 }
 129             }catch(Exception ex){
 130                 GraphGrpc nr = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
 131                 responseObserver.onNext(nr);
 132                 logger.log(Level.WARNING, ex.getMessage());
 133             }
 134             responseObserver.onCompleted();
 135         }
 136
 137         @Override
 138         public void createGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
 139             NewGraph.Builder response = NewGraph.newBuilder();
 140             try{
 141                 Graph graph = GrpcUtils.deriveGraph(request);
 142                 Graph newGraph = graphService.addGraph(graph);
 143                 response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
 144             }catch(BadRequestException ex){
 145                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 146                 logger.log(Level.WARNING, ex.getClass().toString());
 147                 logger.log(Level.WARNING, ex.getMessage());
 148
 149             }
 150             catch(Exception ex){
 151                 response.setSuccess(false).setErrorMessage(internalError);
 152                 logger.log(Level.WARNING, ex.getClass().toString());
 153                 logger.log(Level.WARNING, ex.getMessage());
 154             }
 155             responseObserver.onNext(response.build());
 156             responseObserver.onCompleted();
 157         }
 158
 159         @Override
 160         public void deleteGraph(RequestID request, StreamObserver<Status> responseObserver) {
 161
 162             Status.Builder response = Status.newBuilder();
 163             try{
 164                 graphService.removeGraph(request.getIdGraph());
 165                 response.setSuccess(true);
 166             }catch(ForbiddenException ex){
 167                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 168                 logger.log(Level.WARNING, ex.getMessage());
 169             }catch(Exception ex){
 170                 response.setSuccess(false).setErrorMessage(internalError);
 171                 logger.log(Level.WARNING, ex.getMessage());
 172             }
 173             responseObserver.onNext(response.build());
 174             responseObserver.onCompleted();
 175         }
 176
 177         @Override
 178         public void getGraph(RequestID request, StreamObserver<GraphGrpc> responseObserver) {
 179             try{
 180                 Graph graph = graphService.getGraph(request.getIdGraph());
 181                 GraphGrpc gr = GrpcUtils.obtainGraph(graph);
 182                 responseObserver.onNext(gr);
 183             }catch(ForbiddenException | DataNotFoundException ex){
 184                 GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 185                 responseObserver.onNext(grError);
 186                 logger.log(Level.WARNING, ex.getMessage());
 187             }catch(Exception ex){
 188                 GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
 189                 responseObserver.onNext(grError);
 190                 logger.log(Level.WARNING, ex.getMessage());
 191             }
 192             responseObserver.onCompleted();
 193         }
 194
 195         @Override
 196         public void updateGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
 197             NewGraph.Builder response = NewGraph.newBuilder();
 198             try{
 199                 Graph graph = GrpcUtils.deriveGraph(request);
 200                 graph.setId(request.getId());
 201                 Graph newGraph = graphService.updateGraph(graph);
 202                 response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
 203             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 204                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 205                 logger.log(Level.WARNING, ex.getMessage());
 206             }catch(Exception ex){
 207                 response.setSuccess(false).setErrorMessage(internalError);
 208                 logger.log(Level.WARNING, ex.getMessage());
 209             }
 210             responseObserver.onNext(response.build());
 211             responseObserver.onCompleted();
 212         }
 213
 214         @Override
 215         public void verifyPolicy(Policy request, StreamObserver<VerificationGrpc> responseObserver) {
 216
 217             VerificationGrpc.Builder verification;
 218             try{
 219                 //Convert request
 220                 VerificationBean verify = new VerificationBean();
 221                 verify.setDestination(request.getDestination());
 222                 verify.setSource(request.getSource());
 223                 verify.setType(request.getType().toString());
 224                 verify.setMiddlebox(request.getMiddlebox());
 225
 226                 //Convert Response
 227                 Verification ver = verificationService.verify(request.getIdGraph(), verify);
 228                 verification = VerificationGrpc.newBuilder(GrpcUtils.obtainVerification(ver))
 229                         .setSuccessOfOperation(true);
 230             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 231                 verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
 232                         .setErrorMessage(ex.getMessage());
 233                 logger.log(Level.WARNING, ex.getMessage());
 234             }catch(Exception ex){
 235                 verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
 236                         .setErrorMessage(internalError);
 237                 logger.log(Level.WARNING, ex.getMessage());
 238             }
 239             responseObserver.onNext(verification.build());
 240             responseObserver.onCompleted();
 241         }
 242
 243         /** Here start methods of NodeResource*/
 244
 245         @Override
 246         public void getNodes(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
 247             try{
 248                 for (Node item : nodeService.getAllNodes(request.getIdGraph())) {
 249                     NodeGrpc nr = GrpcUtils.obtainNode(item);
 250                     responseObserver.onNext(nr);
 251                 }
 252             }catch(ForbiddenException | DataNotFoundException ex){
 253                 NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 254                 responseObserver.onNext(nr);
 255                 logger.log(Level.WARNING, ex.getMessage());
 256             }catch(Exception ex){
 257                 NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
 258                 responseObserver.onNext(nr);
 259                 logger.log(Level.WARNING, ex.getMessage());
 260             }
 261             responseObserver.onCompleted();
 262         }
 263
 264         @Override
 265         public void createNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
 266             NewNode.Builder response = NewNode.newBuilder();
 267             try{
 268                 Node node = GrpcUtils.deriveNode(request);
 269                 Node newNode = nodeService.addNode(request.getIdGraph(), node);
 270                 response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
 271             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 272                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 273                 logger.log(Level.WARNING, ex.getMessage());
 274             }catch(Exception ex){
 275                 response.setSuccess(false).setErrorMessage(internalError);
 276                 logger.log(Level.WARNING, ex.getMessage());
 277             }
 278             responseObserver.onNext(response.build());
 279             responseObserver.onCompleted();
 280         }
 281
 282         @Override
 283         public void deleteNode(RequestID request, StreamObserver<Status> responseObserver) {
 284             Status.Builder response = Status.newBuilder();
 285             try{
 286                 nodeService.removeNode(request.getIdGraph(), request.getIdNode());
 287                 response.setSuccess(true);
 288             }catch(ForbiddenException | DataNotFoundException ex){
 289                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 290                 logger.log(Level.WARNING, ex.getMessage());
 291             }catch(Exception ex){
 292                 response.setSuccess(false).setErrorMessage(internalError);
 293                 logger.log(Level.WARNING, ex.getMessage());
 294             }
 295             responseObserver.onNext(response.build());
 296             responseObserver.onCompleted();
 297         }
 298
 299         @Override
 300         public void getNode(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
 301             NodeGrpc nr;
 302             try{
 303                 Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
 304                 nr= GrpcUtils.obtainNode(node);
 305             }catch(ForbiddenException | DataNotFoundException ex){
 306                 nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 307                 logger.log(Level.WARNING, ex.getMessage());
 308             }catch(Exception ex){
 309                 nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
 310                 logger.log(Level.WARNING, ex.getMessage());
 311             }
 312             responseObserver.onNext(nr);
 313             responseObserver.onCompleted();
 314         }
 315
 316         @Override
 317         public void updateNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
 318             NewNode.Builder response = NewNode.newBuilder();            try{
 319                 Node node = GrpcUtils.deriveNode(request);
 320                 node.setId(request.getId());
 321                 Node newNode = nodeService.updateNode(request.getIdGraph(), node);
 322                 response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
 323             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 324                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 325                 logger.log(Level.WARNING, ex.getMessage());
 326             }catch(Exception ex){
 327                 response.setSuccess(false).setErrorMessage(internalError);
 328                 logger.log(Level.WARNING, ex.getMessage());
 329             }
 330             responseObserver.onNext(response.build());
 331             responseObserver.onCompleted();
 332         }
 333
 334         @Override
 335         public void configureNode(ConfigurationGrpc request, StreamObserver<Status> responseObserver) {
 336             Status.Builder response = Status.newBuilder();
 337             try{
 338                 if (request.getIdGraph() <= 0) {
 339                     throw new ForbiddenException("Illegal graph id: " + request.getIdGraph());
 340                 }
 341                 if (request.getIdNode() <= 0) {
 342                     throw new ForbiddenException("Illegal node id: " + request.getIdNode());
 343                 }
 344                 Graph graph = new GraphService().getGraph(request.getIdGraph());
 345                 if (graph == null){
 346                     throw new BadRequestException("Graph with id " + request.getIdGraph() + " not found");
 347                 }
 348                 Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
 349                 if (node == null){
 350                     throw new BadRequestException("Node with id " + request.getIdNode() +
 351                             " not found in graph with id " + request.getIdGraph());
 352                 }
 353                 Configuration nodeConfiguration = GrpcUtils.deriveConfiguration(request);
 354                 Node nodeCopy = new Node();
 355                 nodeCopy.setId(node.getId());
 356                 nodeCopy.setName(node.getName());
 357                 nodeCopy.setFunctional_type(node.getFunctional_type());
 358                 Map<Long,Neighbour> nodes = new HashMap<Long,Neighbour>();
 359                 nodes.putAll(node.getNeighbours());
 360                 nodeCopy.setNeighbours(nodes);
 361                 nodeConfiguration.setId(nodeCopy.getName());
 362                 nodeCopy.setConfiguration(nodeConfiguration);
 363                 Graph graphCopy = new Graph();
 364                 graphCopy.setId(graph.getId());
 365                 graphCopy.setNodes(new HashMap<Long, Node>(graph.getNodes()));
 366                 graphCopy.getNodes().remove(node.getId());
 367                 NodeService.validateNode(graphCopy, nodeCopy);
 368                 graph.getNodes().put(request.getIdNode(), nodeCopy);
 369                 response.setSuccess(true);
 370             }catch(ForbiddenException | BadRequestException ex){
 371                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 372                 logger.log(Level.WARNING, ex.getMessage());
 373             }catch(Exception ex){
 374                 response.setSuccess(false).setErrorMessage(internalError);
 375                 logger.log(Level.WARNING, ex.getMessage());
 376             }
 377             responseObserver.onNext(response.build());
 378             responseObserver.onCompleted();
 379         }
 380
 381         /** Here start methods of NeighbourResource*/
 382         @Override
 383         public void getNeighbours(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
 384             try{
 385                 for(Neighbour item : neighboursService.getAllNeighbours(request.getIdGraph(), request.getIdNode())) {
 386                     NeighbourGrpc nr = GrpcUtils.obtainNeighbour(item);
 387                     responseObserver.onNext(nr);
 388                 }
 389             }catch(ForbiddenException | DataNotFoundException ex){
 390                 NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 391                 responseObserver.onNext(nr);
 392                 logger.log(Level.WARNING, ex.getMessage());
 393             }catch(Exception ex){
 394                 NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
 395                 responseObserver.onNext(nr);
 396                 logger.log(Level.WARNING, ex.getMessage());
 397             }                      responseObserver.onCompleted();
 398         }
 399
 400         @Override
 401         public void createNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
 402             NewNeighbour.Builder response = NewNeighbour.newBuilder();
 403             try{
 404                 Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
 405                 Neighbour newNeighbour = neighboursService.addNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
 406                 response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
 407             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 408                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 409                 logger.log(Level.WARNING, ex.getMessage());
 410             }catch(Exception ex){
 411                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 412                 logger.log(Level.WARNING, ex.getMessage());
 413             }
 414             responseObserver.onNext(response.build());
 415             responseObserver.onCompleted();
 416         }
 417
 418         @Override
 419         public void deleteNeighbour(RequestID request, StreamObserver<Status> responseObserver) {
 420             Status.Builder response = Status.newBuilder();
 421             try{
 422                 neighboursService.removeNeighbour(request.getIdGraph(), request.getIdNode(), request.getIdNeighbour());
 423                 response.setSuccess(true);
 424             }catch(ForbiddenException | DataNotFoundException ex){
 425                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 426                 logger.log(Level.WARNING, ex.getMessage());
 427             }catch(Exception ex){
 428                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 429                 logger.log(Level.WARNING, ex.getMessage());
 430             }
 431             responseObserver.onNext(response.build());
 432             responseObserver.onCompleted();
 433         }
 434
 435         @Override
 436         public void getNeighbour(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
 437             NeighbourGrpc nr;
 438             try{
 439                 Neighbour neighbour = neighboursService.getNeighbour(request.getIdGraph(),
 440                         request.getIdNode(), request.getIdNeighbour());
 441                 nr = GrpcUtils.obtainNeighbour(neighbour);
 442
 443             }catch(ForbiddenException | DataNotFoundException ex){
 444                 nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 445                 logger.log(Level.WARNING, ex.getMessage());
 446             }catch(Exception ex){
 447                 nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
 448                 logger.log(Level.WARNING, ex.getMessage());
 449             }
 450             responseObserver.onNext(nr);
 451             responseObserver.onCompleted();
 452         }
 453
 454         @Override
 455         public void updateNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
 456             NewNeighbour.Builder response = NewNeighbour.newBuilder();
 457             try{
 458                 Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
 459                 neighbour.setId(request.getId());
 460                 Neighbour newNeighbour = neighboursService.updateNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
 461                 response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
 462             }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 463                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 464                 logger.log(Level.WARNING, ex.getMessage());
 465             }catch(Exception ex){
 466                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 467                 logger.log(Level.WARNING, ex.getMessage());
 468             }
 469             responseObserver.onNext(response.build());
 470             responseObserver.onCompleted();
 471         }
 472
 473         /** Here start methods of TOSCA gRPC server */             @Override
 474         public void getTopologyTemplates (GetRequest request, StreamObserver<TopologyTemplateGrpc> responseObserver) {
 475             boolean not_correct = false;
 476             try {
 477                 for(Graph item : graphService.getAllGraphs()) {
 478                     TopologyTemplateGrpc topol = GraphToGrpc.obtainTopologyTemplate(item);
 479                     responseObserver.onNext(topol);
 480                 }
 481             } catch(Exception ex){
 482                 logger.log(Level.WARNING, ex.getMessage());
 483                 not_correct = true;
 484             }
 485             if(not_correct)
 486                 responseObserver.onNext(TopologyTemplateGrpc.newBuilder()
 487                         .setErrorMessage("Internal Server Error while retrieving TopologyTemplate").build());
 488             responseObserver.onCompleted();
 489         }
 490
 491         @Override
 492         public void getTopologyTemplate (ToscaRequestID request, StreamObserver<TopologyTemplateGrpc> responseObserver) {
 493             try {
 494                 Long graphID = Long.valueOf(request.getIdTopologyTemplate());
 495                 //this method will throw a NumberFormatException in case the ID is not representable as a long
 496                 Graph graph = graphService.getGraph(graphID);
 497                 TopologyTemplateGrpc topol = GraphToGrpc.obtainTopologyTemplate(graph);
 498                 responseObserver.onNext(topol);
 499             } catch(ForbiddenException | DataNotFoundException ex) {
 500                 TopologyTemplateGrpc topolError = TopologyTemplateGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
 501                 responseObserver.onNext(topolError);
 502                 logger.log(Level.WARNING, ex.getMessage());
 503             } catch(NumberFormatException ex) {
 504                 TopologyTemplateGrpc topolError = TopologyTemplateGrpc.newBuilder()
 505                         .setErrorMessage("The TopologyTemplate ID must be a long value.").build();
 506                 responseObserver.onNext(topolError);
 507                 logger.log(Level.WARNING, ex.getMessage());
 508             } catch(Exception ex) {
 509                 TopologyTemplateGrpc topolError = TopologyTemplateGrpc.newBuilder().setErrorMessage(internalError).build();
 510                 responseObserver.onNext(topolError);
 511                 logger.log(Level.WARNING, ex.getMessage());
 512             }
 513             responseObserver.onCompleted();
 514         }
 515
 516         @Override
 517         public void createTopologyTemplate (TopologyTemplateGrpc request, StreamObserver<NewTopologyTemplate> responseObserver) {
 518             NewTopologyTemplate.Builder response = NewTopologyTemplate.newBuilder();
 519             try{
 520                 Graph graph = GrpcToGraph.deriveGraph(request);
 521                 Graph newGraph = graphService.addGraph(graph);
 522                 response.setSuccess(true).setTopologyTemplate(GraphToGrpc.obtainTopologyTemplate(newGraph));
 523                 } catch(BadRequestException ex) {
 524                 ex.printStackTrace();
 525                 response.setSuccess(false).setErrorMessage("Provided invalid request to the service.");
 526                 logger.log(Level.WARNING, ex.getClass().toString());
 527                 logger.log(Level.WARNING, ex.getMessage());
 528             } catch(Exception ex) {
 529                 ex.printStackTrace();
 530                 response.setSuccess(false).setErrorMessage(internalError);
 531                 logger.log(Level.WARNING, ex.getClass().toString());
 532                 logger.log(Level.WARNING, ex.getMessage());
 533             }
 534             responseObserver.onNext(response.build());
 535             responseObserver.onCompleted();
 536         }
 537
 538
 539         @Override
 540         public void updateTopologyTemplate (TopologyTemplateGrpc request, StreamObserver<NewTopologyTemplate> responseObserver) {
 541             NewTopologyTemplate.Builder response = NewTopologyTemplate.newBuilder();
 542             try{
 543                 Graph graph = GrpcToGraph.deriveGraph(request);
 544                 Graph newGraph = graphService.updateGraph(graph);
 545                 response.setSuccess(true).setTopologyTemplate(GraphToGrpc.obtainTopologyTemplate(newGraph));
 546             } catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
 547                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 548                 logger.log(Level.WARNING, ex.getMessage());
 549             } catch(Exception ex){
 550                 response.setSuccess(false).setErrorMessage(internalError);
 551                 logger.log(Level.WARNING, ex.getMessage());
 552             }
 553             responseObserver.onNext(response.build());
 554             responseObserver.onCompleted();
 555         }
 556
 557
 558         @Override
 559         public void deleteTopologyTemplate (ToscaRequestID request, StreamObserver<Status> responseObserver) {
 560             Status.Builder response = Status.newBuilder();
 561             Long graphID = null;
 562             try{
 563                 graphID = Long.valueOf(request.getIdTopologyTemplate());
 564                 //this method will throw a NumberFormatException in case the ID is not representable as a long
 565                 graphService.removeGraph(graphID);
 566                 response.setSuccess(true);
 567             } catch(ForbiddenException | DataNotFoundException ex) {
 568                 response.setSuccess(false).setErrorMessage(ex.getMessage());
 569                 logger.log(Level.WARNING, ex.getMessage());
 570             } catch(NumberFormatException ex) {
 571                 response.setSuccess(false).setErrorMessage("The TopologyTemplate ID must be a long value.");
 572                 logger.log(Level.WARNING, ex.getMessage());
 573             } catch(Exception ex) {
 574                 response.setSuccess(false).setErrorMessage(internalError);
 575                 logger.log(Level.WARNING, ex.getMessage());
 576             }
 577             responseObserver.onNext(response.build());
 578             responseObserver.onCompleted();
 579         }
 580
 581
 582         @Override
 583         public void verifyToscaPolicy(ToscaPolicy request, StreamObserver<ToscaVerificationGrpc> responseObserver) {
 584             try{
 585                 //Convert request
 586                 VerificationBean verify = new VerificationBean();
 587                 verify.setDestination(request.getDestination());
 588                 verify.setSource(request.getSource());
 589                 verify.setType(request.getType().toString());
 590                 verify.setMiddlebox(request.getMiddlebox());
 591
 592                 //Convert Response
 593                 Long graphID = Long.valueOf(request.getIdTopologyTemplate());
 594                 //this method will throw a NumberFormatException in case the ID is not representable as a long
 595                 Verification ver = verificationService.verify(graphID, verify);
 596                 responseObserver.onNext(GraphToGrpc.obtainToscaVerification(ver));
 597             } catch(ForbiddenException | DataNotFoundException | BadRequestException ex) {
 598                 ToscaVerificationGrpc verError = ToscaVerificationGrpc.newBuilder().setSuccessOfOperation(false)
 599                         .setErrorMessage(ex.getMessage()).build();
 600                 responseObserver.onNext(verError);
 601                 logger.log(Level.WARNING, ex.getMessage());
 602             } catch(NumberFormatException ex) {
 603                 ToscaVerificationGrpc verError = ToscaVerificationGrpc.newBuilder().setSuccessOfOperation(false)
 604                         .setErrorMessage("The TopologyTemplate ID must be a long value.").build();
 605                 responseObserver.onNext(verError);
 606                 logger.log(Level.WARNING, ex.getMessage());
 607             } catch(Exception ex) {
 608                 ToscaVerificationGrpc verError = ToscaVerificationGrpc.newBuilder().setSuccessOfOperation(false)
 609                         .setErrorMessage(internalError).build();
 610                 responseObserver.onNext(verError);
 611                 logger.log(Level.WARNING, ex.getMessage());
 612             }                     responseObserver.onCompleted();
 613         }
 614
 615
 616     }
 617 }