Initial version of code

Author: cer

LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2016 Eventuate, Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.adoc

@@ -0,0 +1,164 @@
+= FTGO example application
+
+This is the example code for my book https://www.manning.com/books/microservice-patterns[Microservice patterns].
+
+== Please note
+
+* The code is still work in progress
+* It primarily illustrates the technical aspects of the microservice architecture and so the business logic is minimal
+* The documentation is sparse/non-existent and you will need to look in the book
+* The application consists of many services and so requires a lot of memory. It runs well, for example, on a 16MB Macbook pro.
+* The application's services and the infrastructure services, such as MySQL and Apache Kafka, are deployed using Docker containers.
+
+== Got questions
+
+Please post a message to the https://forums.manning.com/forums/microservice-patterns[book's discussion forum] or create a github issue.
+I'll do my best to help you.
+
+== Application architecture
+
+Not surprisingly, this application has a microservice architecture.
+There are the following services:
+
+* link:./ftgo-consumer-service[ftgo-consumer-service] - the `Consumer Service`
+* link:./ftgo-restaurant-service[ftgo-restaurant-service] - the `Restaurant Service`
+* link:./ftgo-order-service[ftgo-order-service] - the `Order Service`
+* link:./ftgo-restaurant-order-service[ftgo-restaurant-order-service] - the `Restaurant Order Service`
+* link:./ftgo-accounting-service[ftgo-accounting-service] - the `Accounting Service`
+* link:./ftgo-order-history-service[ftgo-order-history-service] - a `Order History Service`, which is a CQRS view
+* link:./ftgo-api-gateway[ftgo-api-gateway] - the API gateway
+
+== Service design
+
+Key points:
+
+* A service consists of a single Gradle module.
+For example, `ftgo-order-service` implements the `Order Service`
+* A service is a Spring Boot application
+* A service has a Swagger UI `http://.../swagger-ui.html`. See `open-swagger-uis.sh`
+* A service typically consists of the following packages:
+** domain - domain logic including aggregates
+** messaging - messaging adapters
+** web - Spring MVC controllers (HTTP adapters)
+** main - the main application
+* The services use the following other frameworks
+** `Eventuate Tram` framework - implements transactional messaging
+** `Eventuate Tram Saga` framework - implements sagas
+** `Eventuate Client framework` - implements event sourcing
+
+== Chapter by chapter
+
+This section maps the chapters to the code.
+
+=== Chapter 3 Inter-process communication in a microservice architecture
+
+* The services have a REST API
+* The services also communicate using the Apache Kafka message broker via the `Eventuate Tram` framework
+
+=== Chapter 4 Managing transactions with sagas
+
+The link:./ftgo-order-service[ftgo-order-service] uses sagas to maintain data consistency:
+
+* link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/sagas/createorder/CreateOrderSaga.java[CreateOrderSaga]
+* link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/sagas/cancelorder/CancelOrderSaga.java[CancelOrderSaga]
+* link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/sagas/reviseorder/ReviseOrderSaga.java[ReviseOrderSaga]
+
+The services that participate in these sagas define the following command handlers:
+
+* `Accounting Service` link:./ftgo-accounting-service/src/main/java/net/chrisrichardson/ftgo/accountingservice/messaging/AccountingServiceCommandHandler.java[AccountingServiceCommandHandler]
+* `Consumer Service` link:./ftgo-consumer-service/src/main/java/net/chrisrichardson/ftgo/consumerservice/domain/ConsumerServiceCommandHandlers.java[ConsumerServiceCommandHandlers]
+* `Restaurant Order Service` link:./ftgo-restaurant-order-service/src/main/java/net/chrisrichardson/ftgo/restaurantorderservice/messagehandlers/RestaurantOrderServiceCommandHandler.java[RestaurantOrderServiceCommandHandler]
+* `Order Service` link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/service/OrderCommandHandlers.java[OrderCommandHandlers]
+
+
+
+=== Chapter 5 Designing business logic in a microservice architecture
+
+All the services' business logic is implemented using Domain-Driven design aggregates.
+
+* `Accounting Service`
+** link:./ftgo-accounting-service/src/main/java/net/chrisrichardson/ftgo/accountingservice/domain/Account.java[`Account`] aggregate in the link:./ftgo-accounting-service[ftgo-accounting-service]
+* `Consumer Service`
+**  link:./ftgo-consumer-service/src/main/java/net/chrisrichardson/ftgo/consumerservice/domain/Consumer.java[Consumer]
+* `Order Service`
+** link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/domain/Order.java[Order]
+** link:./ftgo-order-service/src/main/java/net/chrisrichardson/ftgo/orderservice/domain/Restaurant.java[Restaurant]
+* `Restaurant Order Service`
+**  link:./ftgo-restaurant-order-service/src/main/java/net/chrisrichardson/ftgo/restaurantorderservice/domain/Restaurant.java[Restaurant]
+** link:./ftgo-restaurant-order-service/src/main/java/net/chrisrichardson/ftgo/restaurantorderservice/domain/RestaurantOrder.java[RestaurantOrder]
+* `Restaurant Service`
+** link:./ftgo-restaurant-service/src/main/java/net/chrisrichardson/ftgo/restaurantservice/domain/Restaurant.java[Restaurant]
+
+
+=== Chapter 6 Developing business logic with event sourcing
+
+* The link:./ftgo-accounting-service/src/main/java/net/chrisrichardson/ftgo/accountingservice/domain/Account.java[`Account`] aggregate in the link:./ftgo-accounting-service[ftgo-accounting-service] is implemented using event sourcing
+
+=== Chapter 7 Implementing queries in a microservice architecture
+
+* link:./ftgo-order-history-service[ftgo-order-history-service] is an example of a CQRS view
+* link:./ftgo-api-gateway[ftgo-api-gateway] uses API composition to implement the REST endpoint for retrieving the order history
+
+=== Chapter 8 External API patterns
+
+* link:./ftgo-api-gateway[ftgo-api-gateway] is the API gateway
+
+
+== Building and running the application
+
+=== Pre-requisites
+
+* Java 8
+* Docker and Docker Compose
+* Internet access so that Gradle and Docker can download dependencies and container images
+* The link:./ftgo-order-history-service[ftgo-order-history-service] uses AWS DynamoDB and so requires an access key and secret.
+
+=== Building
+
+Build the services using this command:
+
+```
+./gradlew assemble
+```
+
+=== Setting environment variables
+
+To run the application you must set the `DOCKER_HOST_IP` environment variable to the IP address of where the Docker containers are running:
+
+* Docker toolbox/Virtual machine - IP address of the virtual machine
+* Docker for Windows/Mac/Linux - IP address of your laptop/desktop
+
+Please do NOT set it to the (unresolvable) hostname of your machine, `localhost` or `127.0.0.1`.
+
+You must also set the AWS environment variables.
+
+=== Running the application
+
+Run the application using this command:
+
+```
+docker-compose up -d
+```
+
+This can take a while
+
+=== Using the application
+
+Use the services Swagger UIs to invoke the services.
+
+* Create consumer - `http://${DOCKER_HOST_IP?}:8081/swagger-ui.html`
+* Create a restaurant - `http://${DOCKER_HOST_IP?}:8084/swagger-ui.html`
+* Create an order - `http://${DOCKER_HOST_IP?}:8082/swagger-ui.html`
+* View the order - `http://${DOCKER_HOST_IP?}:8082/swagger-ui.html`
+* View the order history -  `http://${DOCKER_HOST_IP?}:8086/swagger-ui.html`
+
+You can also access the application via the `API Gateway` at `http://${DOCKER_HOST_IP?}:8087`.
+However, currently it  doesn't have a Swagger UI so you will have to use `curl`, for example.
+
+=== Stopping the application
+
+Stop the application using this command:
+
+```
+docker-compose down -v
+```

TODO.txt

@@ -0,0 +1,67 @@
+eventuate client
+
+sync repo ignores interceptor
+error handling ignores options interceptor
+
+tram:
+
+// TODO accidentally returned new Success() and message handler was fine
+* mysql image
+* logging of sending reply
+* in-memory: sending message to channel with no subscribers = error?
+* default channel mapping bean
+* varags publish domain event
+* channel mapping needs to be pushed to lowest-level - messageproducer, messageconsumer
+* trameventspublisherconfiguration.class, // todo  => tramdomaineventpublisherconfiguration?
+
+exceptions during event delivery don't cause rollback of transaction that records duplicate?
+
+sagas
+
+* mysql image
+* logging of sending reply
+* logging of sagas actions
+
+
+--------------------------------
+
+ftgo - big
+
+what functionality:
+
+* Cancel ORder
+* Revise order
+
+CQRS:
+
+* Order events,
+* Other events
+
+API Gateway
+
+* composition
+
+----
+
+* separate schemas for the services
+** tram needs to use an explicit schema
+
+* actual create order request - stupid stuff right now: passing in prices.
+** order request should have menuitemid and pricing - need to ask a service to price the order.
+*** self (duplicate), ros (preparation - not pricing), rs (ok - except we discussed the need to offload), new orderpricingservice
+** do we need to start at the beginning of ordering?? shopping cart?
+
+** saga method throws exception, reported by kafkamessageprocessor, eventuatekafkaconsumer  appears to have processed the record. what is the expected behavior??? who stops processing?
+
+** define constants for channels, ?? restaurantorderservice
+@transactional
+
+
+ftgo - misc
+
+* serialization of money
+* jpa mapping of enum - e.g. orderstate as name rather than integer
+
+misc
+
+* need static checking of serializability

build-and-restart-service.sh

@@ -0,0 +1,10 @@
+#! /bin/bash -e
+
+SNX=${1}
+SN=${SNX//-/}
+
+
+./gradlew :${SNX?}:assemble
+docker-compose build ${SN?}
+docker-compose up -d ${SN?}
+docker-compose logs -f ${SN?}

build-and-test-all.sh

@@ -0,0 +1,15 @@
+#! /bin/bash -e
+
+
+docker-compose down -v
+docker-compose up -d --build eventuatelocalcdcservice tramcdcservice
+
+./gradlew -x :ftgo-end-to-end-tests:test build
+
+docker-compose up -d --build
+
+./wait-for-services.sh
+
+./gradlew :ftgo-end-to-end-tests:cleanTest :ftgo-end-to-end-tests:test
+
+docker-compose down -v

build.gradle

@@ -0,0 +1,25 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath "org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}"
+    }
+}
+
+
+subprojects {
+
+    apply plugin: "java"
+
+    repositories {
+        mavenCentral()
+        jcenter()
+        maven {
+            url "https://dl.bintray.com/eventuateio-oss/eventuate-maven-release"
+        }
+        eventuateMavenRepoUrl.split(',').each { repoUrl -> maven { url repoUrl } }
+    }
+
+}
+

common-swagger/build.gradle

@@ -0,0 +1,4 @@
+dependencies {
+    compile "io.springfox:springfox-swagger2:2.3.0"
+    compile "io.springfox:springfox-swagger-ui:2.3.0"
+}

common-swagger/src/main/java/net/chrisrichardson/eventstore/examples/customersandorders/commonswagger/CommonSwaggerConfiguration.java

@@ -0,0 +1,43 @@
+package net.chrisrichardson.eventstore.examples.customersandorders.commonswagger;
+
+import com.fasterxml.classmate.TypeResolver;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.context.request.async.DeferredResult;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.schema.WildcardType;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+import java.util.concurrent.CompletableFuture;
+
+import static springfox.documentation.schema.AlternateTypeRules.newRule;
+
+@Configuration
+@EnableSwagger2
+public class CommonSwaggerConfiguration {
+
+    @Bean
+    public Docket api() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                .select()
+                .apis(RequestHandlerSelectors.basePackage("net.chrisrichardson.ftgo"))
+                .build()
+                .pathMapping("/")
+                .genericModelSubstitutes(ResponseEntity.class, CompletableFuture.class)
+                .alternateTypeRules(
+                        newRule(typeResolver.resolve(DeferredResult.class,
+                                        typeResolver.resolve(ResponseEntity.class, WildcardType.class)),
+                                typeResolver.resolve(WildcardType.class))
+                )
+                .useDefaultResponseMessages(false)
+                ;
+    }
+
+    @Autowired
+    private TypeResolver typeResolver;
+
+}