Added gRPC example

Author: cer

ftgo-end-to-end-tests/src/test/java/net/chrisrichardson/ftgo/endtoendtests/EndToEndTests.java

@@ -145,7 +145,7 @@ private void reviseOrder(int orderId) {
             body(new ReviseOrderRequest(Collections.singletonMap(CHICKED_VINDALOO_MENU_ITEM_ID, revisedQuantityOfChickenVindaloo)))
             .contentType("application/json").
             when().
-            put(orderBaseUrl(Integer.toString(orderId))).
+            post(orderBaseUrl(Integer.toString(orderId), "revise")).
             then().
             statusCode(200);
   }

ftgo-order-service/build.gradle

@@ -11,13 +11,15 @@ buildscript {
         classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
         classpath "org.springframework.cloud:spring-cloud-contract-gradle-plugin:2.0.0.M7"
         classpath "com.avast.gradle:gradle-docker-compose-plugin:$dockerComposePluginVersion"
+        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.0'
     }
 }
 
 apply plugin: 'org.springframework.boot'
 apply plugin: "io.spring.dependency-management"
 apply plugin: 'spring-cloud-contract'
 apply plugin: 'docker-compose'
+apply plugin: 'com.google.protobuf'
 
 apply plugin: IntegrationTestsPlugin
 apply plugin: ComponentTestsPlugin
@@ -69,13 +71,37 @@ dockerCompose {
 componentTest.dependsOn(componentTestsComposeUp)
 integrationTest.dependsOn(integrationTestsComposeUp)
 
-repositories {
-    maven {
-        url 'http://oss.jfrog.org/oss-snapshot-local/'
+protobuf {
+    protoc {
+        // Download from repositories
+        artifact = 'com.google.protobuf:protoc:3.0.0'
     }
+    plugins {
+        grpc {
+            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
+        }
+    }
+    generateProtoTasks {
+        all()*.plugins {
+            grpc {
+                // To generate deprecated interfaces and static bindService method,
+                // turn the enable_deprecated option to true below:
+                option 'enable_deprecated=false'
+            }
+        }
+    }
+}
 
+apply plugin: 'idea'
+
+idea {
+    module {
+        sourceDirs += file("${projectDir}/build/generated/source/proto/main/java");
+        sourceDirs += file("${projectDir}/build/generated/source/proto/main/grpc");
+    }
 }
 
+
 dependencies {
 
 
@@ -103,6 +129,10 @@ dependencies {
     compile "org.springframework.boot:spring-boot-starter-web:$springBootVersion"
     compile 'javax.el:javax.el-api:2.2.5'
 
+    compile "io.grpc:grpc-netty:${grpcVersion}"
+    compile "io.grpc:grpc-protobuf:${grpcVersion}"
+    compile "io.grpc:grpc-stub:${grpcVersion}"
+
     testCompile "io.eventuate.util:eventuate-util-test:$eventuateUtilVersion"
     testCompile "io.eventuate.tram.core:eventuate-tram-test-util:$eventuateTramVersion"
 

ftgo-order-service/src/integration-test/java/net/chrisrichardson/ftgo/orderservice/grpc/OrderServiceClient.java

@@ -0,0 +1,46 @@
+package net.chrisrichardson.ftgo.orderservice.grpc;
+
+
+import io.grpc.*;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+import java.util.stream.IntStream;
+
+import net.chrisrichardson.ftgo.orderservice.web.MenuItemIdAndQuantity;
+
+public class OrderServiceClient {
+  private static final Logger logger = Logger.getLogger(OrderServiceClient.class.getName());
+
+  private final ManagedChannel channel;
+  private final OrderServiceGrpc.OrderServiceBlockingStub clientStub;
+
+  public OrderServiceClient(String host, int port) {
+    channel = ManagedChannelBuilder.forAddress(host, port)
+            .usePlaintext()
+            .build();
+    clientStub = OrderServiceGrpc.newBlockingStub(channel);
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  public long createOrder(long consumerId, long restaurantId, List<MenuItemIdAndQuantity> lineItems) {
+    CreateOrderRequest.Builder builder = CreateOrderRequest.newBuilder()
+            .setConsumerId(consumerId)
+            .setRestaurantId(restaurantId);
+    CreateOrderRequest request = builder
+            .build();
+    IntStream.range(0, lineItems.size()).forEach(idx -> {
+      MenuItemIdAndQuantity li = lineItems.get(idx);
+      builder.setLineItems(idx, LineItem.newBuilder().setQuantity(li.getQuantity()).setMenuItemId(li.getMenuItemId()).build());
+    });
+    CreateOrderReply response;
+      response = clientStub.createOrder(request);
+    return response.getOrderId();
+  }
+
+
+}

ftgo-order-service/src/integration-test/java/net/chrisrichardson/ftgo/orderservice/grpc/OrderServiceGrpIntegrationTest.java

@@ -0,0 +1,39 @@
+package net.chrisrichardson.ftgo.orderservice.grpc;
+
+
+import net.chrisrichardson.ftgo.orderservice.domain.Order;
+import net.chrisrichardson.ftgo.orderservice.domain.OrderJpaTestConfiguration;
+import net.chrisrichardson.ftgo.orderservice.domain.OrderService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = OrderServiceGrpIntegrationTestConfiguration.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
+public class OrderServiceGrpIntegrationTest {
+
+  @Autowired
+  private OrderService orderService;
+
+  @Test
+  public void shouldCreateOrder() {
+
+    Order order = new Order(1, 2, Collections.emptyList());
+    order.setId(101L);
+
+    when(orderService.createOrder(1, 2, Collections.emptyList())).thenReturn(order);
+    OrderServiceClient client = new OrderServiceClient("localhost", 50051);
+
+    long orderId = client.createOrder(1, 2, Collections.emptyList());
+
+    assertEquals(101L, orderId);
+
+  }
+}

ftgo-order-service/src/integration-test/java/net/chrisrichardson/ftgo/orderservice/grpc/OrderServiceGrpIntegrationTestConfiguration.java

@@ -0,0 +1,18 @@
+package net.chrisrichardson.ftgo.orderservice.grpc;
+
+import net.chrisrichardson.ftgo.orderservice.domain.OrderService;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+import static org.mockito.Mockito.mock;
+
+@Configuration
+@Import(GrpcConfiguration.class)
+public class OrderServiceGrpIntegrationTestConfiguration {
+
+  @Bean
+  public OrderService orderService() {
+    return mock(OrderService.class);
+  }
+}

ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/grpc/GrpcConfiguration.java

@@ -0,0 +1,14 @@
+package net.chrisrichardson.ftgo.orderservice.grpc;
+
+import net.chrisrichardson.ftgo.orderservice.domain.OrderService;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class GrpcConfiguration {
+
+  @Bean
+  public OrderServiceServer helloWorldServer(OrderService orderService) {
+    return new OrderServiceServer(orderService);
+  }
+}

ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/grpc/OrderServiceServer.java

@@ -0,0 +1,75 @@
+package net.chrisrichardson.ftgo.orderservice.grpc;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import net.chrisrichardson.ftgo.orderservice.domain.Order;
+import net.chrisrichardson.ftgo.orderservice.domain.OrderService;
+import net.chrisrichardson.ftgo.orderservice.web.MenuItemIdAndQuantity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.io.IOException;
+
+import static java.util.stream.Collectors.toList;
+
+public class OrderServiceServer {
+  private static final Logger logger = LoggerFactory.getLogger(OrderServiceServer.class);
+
+  private int port = 50051;
+  private Server server;
+  private OrderService orderService;
+
+  public OrderServiceServer(OrderService orderService) {
+    this.orderService = orderService;
+  }
+
+  @PostConstruct
+  public void start() throws IOException {
+    server = ServerBuilder.forPort(port)
+            .addService(new OrderServiceImpl())
+            .build()
+            .start();
+    logger.info("Server started, listening on " + port);
+  }
+
+  @PreDestroy
+  public void stop() {
+    if (server != null) {
+      logger.info("*** shutting down gRPC server since JVM is shutting down");
+      server.shutdown();
+      logger.info("*** server shut down");
+    }
+  }
+
+
+  private class OrderServiceImpl extends OrderServiceGrpc.OrderServiceImplBase {
+
+    @Override
+    public void createOrder(CreateOrderRequest req, StreamObserver<CreateOrderReply> responseObserver) {
+      Order order = orderService.createOrder(req.getConsumerId(),
+              req.getRestaurantId(),
+              req.getLineItemsList().stream().map(x -> new MenuItemIdAndQuantity(x.getMenuItemId(), x.getQuantity())).collect(toList())
+      );
+      CreateOrderReply reply = CreateOrderReply.newBuilder().setOrderId(order.getId()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void cancelOrder(CancelOrderRequest req, StreamObserver<CancelOrderReply> responseObserver) {
+      CancelOrderReply reply = CancelOrderReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void reviseOrder(ReviseOrderRequest req, StreamObserver<ReviseOrderReply> responseObserver) {
+      ReviseOrderReply reply = ReviseOrderReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}

ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/main/OrderServiceMain.java

@@ -4,6 +4,7 @@
 import io.eventuate.tram.commands.common.ChannelMapping;
 import io.eventuate.tram.commands.common.DefaultChannelMapping;
 import net.chrisrichardson.eventstore.examples.customersandorders.commonswagger.CommonSwaggerConfiguration;
+import net.chrisrichardson.ftgo.orderservice.grpc.GrpcConfiguration;
 import net.chrisrichardson.ftgo.orderservice.messaging.OrderServiceMessagingConfiguration;
 import net.chrisrichardson.ftgo.orderservice.service.OrderCommandHandlersConfiguration;
 import net.chrisrichardson.ftgo.orderservice.web.OrderWebConfiguration;
@@ -14,7 +15,7 @@
 
 @SpringBootApplication
 @Import({OrderWebConfiguration.class, OrderCommandHandlersConfiguration.class,  OrderServiceMessagingConfiguration.class,
-        TramJdbcKafkaConfiguration.class, CommonSwaggerConfiguration.class})
+        TramJdbcKafkaConfiguration.class, CommonSwaggerConfiguration.class, GrpcConfiguration.class})
 public class OrderServiceMain {
 
   @Bean

ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/web/OrderController.java

@@ -60,9 +60,7 @@ public ResponseEntity<GetOrderResponse> cancel(@PathVariable long orderId) {
     }
   }
 
-  // TODO implement revise order endpoint
-
-  @RequestMapping(path = "/{orderId}", method = RequestMethod.PUT)
+  @RequestMapping(path = "/{orderId}/revise", method = RequestMethod.POST)
   public ResponseEntity<GetOrderResponse> revise(@PathVariable long orderId, @RequestBody ReviseOrderRequest request) {
     try {
       Order order = orderService.reviseOrder(orderId, new OrderRevision(Optional.empty(), request.getRevisedLineItemQuantities()));

ftgo-order-service/src/main/proto/OrderService.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "net.chrisrichardson.ftgo.orderservice.grpc";
+option java_outer_classname = "OrderServiceProto";
+option objc_class_prefix = "OS";
+
+package orderservice;
+
+service OrderService {
+  rpc createOrder(CreateOrderRequest) returns (CreateOrderReply) {}
+  rpc cancelOrder(CancelOrderRequest) returns (CancelOrderReply) {}
+  rpc reviseOrder(ReviseOrderRequest) returns (ReviseOrderReply) {}
+}
+
+message CreateOrderRequest {
+  int64 restaurantId = 1;
+  int64 consumerId = 2;
+  repeated LineItem lineItems = 3;
+}
+
+message LineItem {
+    string menuItemId = 1;
+    int32 quantity = 2;
+}
+
+
+message CreateOrderReply {
+  int64 orderId = 1;
+}
+
+message CancelOrderRequest {
+  string name = 1;
+}
+
+message CancelOrderReply {
+  string message = 1;
+}
+
+message ReviseOrderRequest {
+  string name = 1;
+}
+
+message ReviseOrderReply {
+  string message = 1;
+}