Designing process flows with #Baker

Bekir Oguz
Merlijn van Ittersum
Designing process flows with
#Baker
Amsterdam.Scala Meetup
September 2017

It is hard to develop complex orchestration APIs
6

We need a cleaner way to allow design changes in complex APIs
8
Example: initial design of the API
A B C D E
1 2 3 4 5

A B C D E
1 2 3 4 5
9
Example: API after one design change

A B C D E
1 2 3 4 5
10
Example: API after ten design changes

11
Example: API after ten design changes
A B C D E
1 2 3 4 5

Open Kinder- / Jongerenrekening Open Groei Groter rekening Another Product
Verify customer rules Verify customer rules Verify customer rules
Register individual Register individual Register Individual
Send a present Send a present Not applicable
Send a message to the customer Send a message to the customer Send a message to the customer
Open a payments account Open a savings account Open a payments account
Enable billing Enable billing Assign package
There is more need for reuse between teams
12

Baker is a Scala library that simplifies the development of complex orchestration logic.
What? Baker!
github.com/ing-bank/baker

Intermediate
Languagevalidate
compile
execute
Baker runtime

Recipe
Event
Ingredient
Interaction

Defining ingredients
17
case class CustomerInfo(name: String, address: String, email: String)
// ingredients
val customerInfo = Ingredient[CustomerInfo]("customerInfo")
val trackingId = Ingredient[String]("trackingId")
val order = Ingredient[String]("order")

Defining events
18
// events
val goodsShipped = Event("GoodsShipped", trackingId)
val orderPlaced = Event("OrderPlaced", order)
val paymentMade = Event("PaymentMade")
val valid = Event("Valid")
val sorry = Event("Sorry")

Defining interactions
19
// interactions
val validateOrder = Interaction(
name = "ValidateOrder",
inputIngredients = order,
output = FiresOneOfEvents(valid, sorry)
)
val shipGoods = Interaction(
name = "ShipGoods",
inputIngredients = Ingredients(goods, customerInfo),
output = FiresOneOfEvents(goodsShipped)
)

Defining a recipe
20
// recipe
val webShopRecipe: Recipe =
Recipe("WebShop")
.withInteractions(
validateOrder,
manufactureGoods
.withRequiredEvents(valid, paymentMade),
shipGoods,
sendInvoice
.withRequiredEvent(goodsShipped)
)
.withSensoryEvents(
customerInfoReceived,
orderPlaced,
paymentMade)

Compile the recipe
21
// compiles the recipe
val compiledRecipe = RecipeCompiler.compileRecipe(webShopRecipe)
// list of validation errors
val errors: Seq[String] = compiledRecipe.validationErrors
// .dot (graphviz notation) representation
val visualization: String = compiledRecipe.getRecipeVisualization

A Baker instance can be created from the valid recipe.
It takes care of the execution of the recipe.
The only thing left is to provide sensory events to Baker!
Baker runtime
23

Initializing Baker instance
24
You can create a new Baker instance by providing the recipe and implementations of the
interactions:
val compiledRecipe = RecipeCompiler.compileRecipe(webShopRecipe)
val validateOrderImpl = validateOrder implement {
(order: String) => {
// Some logic here
valid.instance() // or maybe invalid event to be returned
}
}
val implementations =
Seq(validateOrderImpl, manufactureGoodsImpl, sendInvoiceImpl, shipGoodsImpl)
val baker = new Baker(compiledRecipe, implementations)

For each client request you do the following:
Firing events
25
val processId = UUID.randomUUID().toString
baker.bake(processId)
baker.handleEvent(processId, orderPlaced.instance(testOrder))
baker.handleEvent(processId, paymentMade.instance())
baker.handleEvent(processId, customerInfoReceived.instance(testCustomerInfoData))
val actualIngredients: Map[String, Any] = baker.getIngredients(processId)
val actualEvents: Seq[RuntimeEvent] = baker.events(processId)

1. It is hard to develop complex orchestration APIs
2. We need a cleaner way to allow design changes in complex APIs
3. There is more need for reuse between teams
Does Baker help with the Why?
42

With Baker, you think about what you want, not about the order.
Baker can validate the recipe for you.
Clear insight in the current model by visualising the recipe.
43

Baker links the interactions when compiling the recipe.
If interactions are added, removed or changed, Baker will update the model accordingly.
44

Baker links the interactions when compiling the recipe.
If interactions are added, removed or changed, Baker will update the model accordingly.
The possibility to share interactions, ingredients and events between recipes allows for
much more reuse of code among teams.
45

Baker is powered by
47
PetriNet

Process logic is isolated in an Akka actor, this gives us the following benefits:
• Event sourcing through persistent actors
• Supporting many data stores, i.e. cassandra
• Distributing actors with Cluster Sharding
Akka
48

On creation of the Baker instance, the recipe is compiled into a Petri net.
A Petri net is a mathematical model that can be used for reasoning about concurrency.
This Petri net is then used to determine when & what interactions to execute.
PetriNet
49

Execution Semantics: Token passing
50
t1 t2 t3

51
t1 t2 t3

52
t1 t2 t3

53
t1 t2 t3

Execution Semantics: Concurrency
54
t1
t3
t4
t5
t2

55
t1
t3
t4
t5
t2
Choice

56
t1
t3
t4
t5
t2
Parallel split

57
t1
t3
t4
t5
t2
Parallel paths

58
t1
t3
t4
t5
t2
Parallel paths

59
t1
t3
t4
t5
t2
synchronization

• Simple, uses only a few concepts and components
• Exact mathematical definition of execution semantics
• Intuitive graphical notation
• Well-developed mathematical theory for process analysis
Advantages
60

Path traversal time
64
Average traversal time: 10 seconds
A
B

Identifying bottlenecks
65
Takes 70% of the time
A
B

Path prediction
66
83%
17%
A
B

68
Features
Recipe
Developer friendly Java/Scala dsl
Runtime

69
Features
Recipe
Compile-time recipe validation
Runtime

70
Features
Recipe
Type safety
Runtime

71
Features
Recipe
Type safety
Runtime
Execution of the recipe, powered by
akka and petrinet model

72
Features
Recipe
Type safety
Runtime
Persisted state through event sourcing

73
Features
Recipe
Type safety
Runtime
Data encryption

74
Features
Recipe
Type safety
Runtime
Data encryption
Automatic retries on technical failures

75
Features
Recipe
Type safety
Runtime
Data encryption
Automatic retries on technical failures
Parallel execution of paths

Property Based Testing
77
val recipeGen: Gen[Recipe] = for {
name <- nameGen
sensoryEvents <- Gen.listOf(eventGen) suchThat (_.nonEmpty)
interactions <- interactionsGen(sensoryEvents) suchThat (_.nonEmpty)
} yield Recipe(name)
//turn the lists into var args
.withSensoryEvents(sensoryEvents: _*)
.withInteractions(interactions.toList: _*)

Property Based Testing
78
forAll(recipeGen) { recipe =>
val validations = ValidationSettings(
allowCycles = false,
allowNonExecutableInteractions = false)
val compiledRecipe = RecipeCompiler.compileRecipe(recipe, validations)
if (compiledRecipe.validationErrors.nonEmpty) {
logRecipeStats(recipe)
logCompiledRecipeStats(compiledRecipe)
}
compiledRecipe.validationErrors.isEmpty
}

Designing process flows with #Baker

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Designing process flows with #Baker

Semelhante a Designing process flows with #Baker (20)

Último

Último (20)

Designing process flows with #Baker

Notas do Editor