summaryrefslogtreecommitdiffstats
path: root/verigraph/src/main/java/it/polito/grpc/Service.java
diff options
context:
space:
mode:
Diffstat (limited to 'verigraph/src/main/java/it/polito/grpc/Service.java')
-rw-r--r--verigraph/src/main/java/it/polito/grpc/Service.java462
1 files changed, 462 insertions, 0 deletions
diff --git a/verigraph/src/main/java/it/polito/grpc/Service.java b/verigraph/src/main/java/it/polito/grpc/Service.java
new file mode 100644
index 0000000..8a77d05
--- /dev/null
+++ b/verigraph/src/main/java/it/polito/grpc/Service.java
@@ -0,0 +1,462 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Politecnico di Torino and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Apache License, Version 2.0
+ * which accompanies this distribution, and is available at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *******************************************************************************/
+
+package it.polito.grpc;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.verigraph.ConfigurationGrpc;
+import io.grpc.verigraph.GetRequest;
+import io.grpc.verigraph.GraphGrpc;
+import io.grpc.verigraph.NeighbourGrpc;
+import io.grpc.verigraph.NewGraph;
+import io.grpc.verigraph.NewNeighbour;
+import io.grpc.verigraph.NewNode;
+import io.grpc.verigraph.NodeGrpc;
+import io.grpc.verigraph.Policy;
+import io.grpc.verigraph.RequestID;
+import io.grpc.verigraph.Status;
+import io.grpc.verigraph.VerificationGrpc;
+import io.grpc.verigraph.VerigraphGrpc;
+import it.polito.escape.verify.exception.BadRequestException;
+import it.polito.escape.verify.exception.DataNotFoundException;
+import it.polito.escape.verify.exception.ForbiddenException;
+import it.polito.escape.verify.model.Configuration;
+import it.polito.escape.verify.model.Graph;
+import it.polito.escape.verify.model.Neighbour;
+import it.polito.escape.verify.model.Node;
+import it.polito.escape.verify.model.Verification;
+import it.polito.escape.verify.resources.beans.VerificationBean;
+import it.polito.escape.verify.service.GraphService;
+import it.polito.escape.verify.service.NeighbourService;
+import it.polito.escape.verify.service.NodeService;
+import it.polito.escape.verify.service.VerificationService;
+
+public class Service {
+ /** Port on which the server should run. */
+ private static final Logger logger = Logger.getLogger(Service.class.getName());
+ private static final int port = 50051;
+ private static final String internalError = "Internal Server Error";
+ private Server server;
+ private GraphService graphService = new GraphService();
+ private VerificationService verificationService = new VerificationService();
+ private NodeService nodeService = new NodeService();
+ private NeighbourService neighboursService = new NeighbourService();
+
+ public Service(int port) {
+ this(ServerBuilder.forPort(port), port);
+ }
+
+ /** Create a RouteGuide server using serverBuilder as a base and features as data. */
+ public Service(ServerBuilder<?> serverBuilder, int port) {
+ server = serverBuilder.addService(new VerigraphImpl())
+ .build();
+ }
+
+ public void start() throws IOException {
+ server.start();
+ logger.info("Server started, listening on "+ port);
+ Runtime.getRuntime().addShutdownHook(new Thread() {
+ @Override
+ public void run() {
+ logger.info("*** Shutting down gRPC server since JVM is shutting down");
+ Service.this.stop();
+ logger.info("*** Server shut down");
+ }
+ });
+ }
+
+ public void stop() {
+ if (server != null) {
+ server.shutdown();
+ }
+ }
+
+ private void blockUntilShutdown() throws InterruptedException {
+ if (server != null) {
+ server.awaitTermination();
+ }
+ }
+
+ /** Main function to launch server from cmd. */
+ public static void main(String[] args) throws IOException, InterruptedException {
+ try{
+ Service server = new Service(port);
+ server.start();
+ server.blockUntilShutdown();
+ }
+ catch(Exception ex){
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ }
+
+ /**Here start method of my impementation*/
+ private class VerigraphImpl extends VerigraphGrpc.VerigraphImplBase{
+
+ /** Here start methods of GraphResource*/
+ @Override
+ public void getGraphs(GetRequest request, StreamObserver<GraphGrpc> responseObserver) {
+ try{
+ for(Graph item : graphService.getAllGraphs()) {
+ GraphGrpc gr = GrpcUtils.obtainGraph(item);
+ responseObserver.onNext(gr);
+ }
+ }catch(Exception ex){
+ GraphGrpc nr = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
+ NewGraph.Builder response = NewGraph.newBuilder();
+ try{
+ Graph graph = GrpcUtils.deriveGraph(request);
+ Graph newGraph = graphService.addGraph(graph);
+ response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
+ }catch(BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteGraph(RequestID request, StreamObserver<Status> responseObserver) {
+
+ Status.Builder response = Status.newBuilder();
+ try{
+ graphService.removeGraph(request.getIdGraph());
+ response.setSuccess(true);
+ }catch(ForbiddenException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ } catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getGraph(RequestID request, StreamObserver<GraphGrpc> responseObserver) {
+ try{
+ Graph graph = graphService.getGraph(request.getIdGraph());
+ GraphGrpc gr = GrpcUtils.obtainGraph(graph);
+ responseObserver.onNext(gr);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(grError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ GraphGrpc grError = GraphGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(grError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateGraph(GraphGrpc request, StreamObserver<NewGraph> responseObserver) {
+ NewGraph.Builder response = NewGraph.newBuilder();
+ try{
+ Graph graph = GrpcUtils.deriveGraph(request);
+ graph.setId(request.getId());
+ Graph newGraph = graphService.updateGraph(graph);
+ response.setSuccess(true).setGraph(GrpcUtils.obtainGraph(newGraph));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void verifyPolicy(Policy request, StreamObserver<VerificationGrpc> responseObserver) {
+
+ VerificationGrpc.Builder verification;
+ try{
+ //Convert request
+ VerificationBean verify = new VerificationBean();
+ verify.setDestination(request.getDestination());
+ verify.setSource(request.getSource());
+ verify.setType(request.getType().toString());
+ verify.setMiddlebox(request.getMiddlebox());
+
+ //Convert Response
+ Verification ver = verificationService.verify(request.getIdGraph(), verify);
+ verification = VerificationGrpc.newBuilder(GrpcUtils.obtainVerification(ver))
+ .setSuccessOfOperation(true);
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
+ .setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ } catch(Exception ex){
+ verification = VerificationGrpc.newBuilder().setSuccessOfOperation(false)
+ .setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(verification.build());
+ responseObserver.onCompleted();
+ }
+
+ /** Here start methods of NodeResource*/
+
+ @Override
+ public void getNodes(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
+ try{
+ for (Node item : nodeService.getAllNodes(request.getIdGraph())) {
+ NodeGrpc nr = GrpcUtils.obtainNode(item);
+ responseObserver.onNext(nr);
+ }
+ }catch(ForbiddenException | DataNotFoundException ex){
+ NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ } catch(Exception ex){
+ NodeGrpc nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
+ NewNode.Builder response = NewNode.newBuilder();
+ try{
+ Node node = GrpcUtils.deriveNode(request);
+ Node newNode = nodeService.addNode(request.getIdGraph(), node);
+ response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteNode(RequestID request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ nodeService.removeNode(request.getIdGraph(), request.getIdNode());
+ response.setSuccess(true);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getNode(RequestID request, StreamObserver<NodeGrpc> responseObserver) {
+ NodeGrpc nr;
+ try{
+ Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
+ nr= GrpcUtils.obtainNode(node);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ nr = NodeGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ nr = NodeGrpc.newBuilder().setErrorMessage(internalError).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(nr);
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateNode(NodeGrpc request, StreamObserver<NewNode> responseObserver) {
+ NewNode.Builder response = NewNode.newBuilder();
+ try{
+ Node node = GrpcUtils.deriveNode(request);
+ node.setId(request.getId());
+ Node newNode = nodeService.updateNode(request.getIdGraph(), node);
+ response.setSuccess(true).setNode(GrpcUtils.obtainNode(newNode));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void configureNode(ConfigurationGrpc request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ if (request.getIdGraph() <= 0) {
+ throw new ForbiddenException("Illegal graph id: " + request.getIdGraph());
+ }
+ if (request.getIdNode() <= 0) {
+ throw new ForbiddenException("Illegal node id: " + request.getIdNode());
+ }
+ Graph graph = new GraphService().getGraph(request.getIdGraph());
+ if (graph == null){
+ throw new BadRequestException("Graph with id " + request.getIdGraph() + " not found");
+ }
+ Node node = nodeService.getNode(request.getIdGraph(), request.getIdNode());
+ if (node == null){
+ throw new BadRequestException("Node with id " + request.getIdNode() + " not found in graph with id " + request.getIdGraph());
+ }
+ Configuration nodeConfiguration = GrpcUtils.deriveConfiguration(request);
+ Node nodeCopy = new Node();
+ nodeCopy.setId(node.getId());
+ nodeCopy.setName(node.getName());
+ nodeCopy.setFunctional_type(node.getFunctional_type());
+ Map<Long,Neighbour> nodes = new HashMap<Long,Neighbour>();
+ nodes.putAll(node.getNeighbours());
+ nodeCopy.setNeighbours(nodes);
+ nodeConfiguration.setId(nodeCopy.getName());
+ nodeCopy.setConfiguration(nodeConfiguration);
+
+ Graph graphCopy = new Graph();
+ graphCopy.setId(graph.getId());
+ graphCopy.setNodes(new HashMap<Long, Node>(graph.getNodes()));
+ graphCopy.getNodes().remove(node.getId());
+
+ NodeService.validateNode(graphCopy, nodeCopy);
+
+ graph.getNodes().put(request.getIdNode(), nodeCopy);
+ response.setSuccess(true);
+ }catch(ForbiddenException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(internalError);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ /** Here start methods of NeighbourResource*/
+ @Override
+ public void getNeighbours(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
+ try{
+ for(Neighbour item : neighboursService.getAllNeighbours(request.getIdGraph(), request.getIdNode())) {
+ NeighbourGrpc nr = GrpcUtils.obtainNeighbour(item);
+ responseObserver.onNext(nr);
+ }
+ }catch(ForbiddenException | DataNotFoundException ex){
+ NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ NeighbourGrpc nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
+ responseObserver.onNext(nr);
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void createNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
+ NewNeighbour.Builder response = NewNeighbour.newBuilder();
+ try{
+ Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
+ Neighbour newNeighbour = neighboursService.addNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
+ response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void deleteNeighbour(RequestID request, StreamObserver<Status> responseObserver) {
+ Status.Builder response = Status.newBuilder();
+ try{
+ neighboursService.removeNeighbour(request.getIdGraph(), request.getIdNode(), request.getIdNeighbour());
+ response.setSuccess(true);
+ }catch(ForbiddenException | DataNotFoundException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void getNeighbour(RequestID request, StreamObserver<NeighbourGrpc> responseObserver) {
+ NeighbourGrpc nr;
+ try{
+ Neighbour neighbour = neighboursService.getNeighbour(request.getIdGraph(),
+ request.getIdNode(), request.getIdNeighbour());
+ nr = GrpcUtils.obtainNeighbour(neighbour);
+
+ }catch(ForbiddenException | DataNotFoundException ex){
+ nr = NeighbourGrpc.newBuilder().setErrorMessage(ex.getMessage()).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ nr = NeighbourGrpc.newBuilder().setErrorMessage(internalError).build();
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(nr);
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void updateNeighbour(NeighbourGrpc request, StreamObserver<NewNeighbour> responseObserver) {
+ NewNeighbour.Builder response = NewNeighbour.newBuilder();
+ try{
+ Neighbour neighbour = GrpcUtils.deriveNeighbour(request);
+ neighbour.setId(request.getId());
+ Neighbour newNeighbour = neighboursService.updateNeighbour(request.getIdGraph(), request.getIdNode(), neighbour);
+ response.setSuccess(true).setNeighbour(GrpcUtils.obtainNeighbour(newNeighbour));
+ }catch(ForbiddenException | DataNotFoundException | BadRequestException ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }catch(Exception ex){
+ response.setSuccess(false).setErrorMessage(ex.getMessage());
+ logger.log(Level.WARNING, ex.getMessage());
+ }
+ responseObserver.onNext(response.build());
+ responseObserver.onCompleted();
+ }
+ }
+}