Iteratees for building a distributed cash-flow system

Talk given @ ScalaIO. How to combine, Scala Streams, Iteratees, Akka actors and Akka Cluster to build a distributed cash-flow computation system.

Transcript

1. Les iteratees, ce n’est pas que pour l’I/O
2. ME @xbucchiotty https://github.com/xbucchiotty http://blog.xebia.fr/author/xbucchiotty
3. Build a testable, composable and scalable cash-flow system
4. Stream API Iteratees Akka actor Akka cluster Step 4 Step 1 Step 2 Step 3
5. Use case Financial debt management
6. initial = 1000 € duration = 5 years fixed interets rate = 5% Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € 1000 €
7. initial = 1000 € duration = 5 years fixed interets rate = 5% Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € 1000 € date = last date + (1 year)
8. initial = 1000 € duration = 5 years fixed interets rate = 5% Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € 1000 € amort = initial / duration
9. initial = 1000 € duration = 5 years fixed interets rate = 5% Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € 1000 € outstanding = last oustanding - amort
10. initial = 1000 € duration = 5 years fixed interets rate = 5% Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € 1000 € interests = last outstanding * rate
11. val f = (last: Row) => new Row { def date = last.date + (1 year) def amortization = last amortization def outstanding = last.outstanding - amortization def interests = last.outstanding * fixedRate }
12. Step 1 Stream API
13. Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 €
14. Date Amort Interests Outstanding 2013-01-01 200 € 50 € 800 € 2014-01-01 200 € 40 € 600 € 2015-01-01 200 € 30 € 400 € 2016-01-01 200 € 20 € 200 € 2017-01-01 200 € 10 € 0 € first f(first) f(f(first))
15. case class Loan( ... ) { def first: Row def f:(Row => Row) def rows = Stream.iterate(first)(f) .take(duration) }
16. case class Portfolio(loans: Seq[Loan]) { def rows = loans.stream.flatMap(_.rows) }
17. 3450 € Total Date Amort Interests Total paid 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € Loan 1 Loan 2 Loan 3
18. // Produce rows val totalPaid = portfolio.rows // Transform rows to amount .map(row => row.interests + row.amortization) //Consume amount .foldLeft(0 EUR)(_ + _)
19. // Produce rows val totalPaid = portfolio.rows // Transform rows to amount .map(row => row.interests + row.amortization) //Consume amount .foldLeft(0 EUR)(_ + _) type RowProducer = Iterable[Row] type RowTransformer[T] = (Row=>T) type AmountConsumer[T] = (Iterable[Amount]=>T)
20. //Loan Stream.iterate(first)(f) take duration //Porfolio loans => loans flatMap (loan => loan.rows) RowProducer (Iterable[Row]) + on demand computation - sequential computation
21. object RowTransformer { val totalPaid = (row: Row) => row.interests + row.amortization } + function composition - type limited to «map» RowTransformer (Row => T)
22. object AmountConsumer { def sum = (rows: Iterable[Amount]) => rows.foldLeft(Amount(0, EUR))(_ + _) } AmountConsumer (Iterable[Amount] => T) + function composition - synchronism
23. val totalPaid = AmountConsumer.sum( portfolio.rows .map(RowTransformer.totalPaid) )
24. Stream API Step 1 5000 loans 50 rows ~ 560 ms
25. On demand computation Function composition Sequential computation Synchronism Transformation limited to «map» Pros Cons
26. Step 2 Iteratees
27. Integrating Play iteratees libraryDependencies ++= Seq( "com.typesafe.play" %% "play-iteratees" % "2.2.0-RC2" )
28. Enumerator Iteratee Producer Input Status Consumer
29. Enumerator Iteratee Input Status Iteratees are immutable Asynchronous by design Type safe
30. Enumerator enumerate and interleave
31. case class Loan(initial: Amount, duration: Int, rowIt: RowIt) { def rows(implicit ctx: ExecutionContext) = Stream.iterate(first)(f).take(duration) } Data producer Enumerator.enumerate( )
32. case class Portfolio(loans: Seq[Loansan]) { def rows(implicit ctx: ExecutionContext) = } producers can be combined Enumerator.interleave(loans.map(_.rows))
33. 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € Date Amort Interests Total paid 2013-01-01 200 € 50 € 250 € 2014-01-01 200 € 40 € 240 € 2015-01-01 200 € 30 € 230 € 2016-01-01 200 € 20 € 220 € 2017-01-01 200 € 10 € 210 € 3450 € Total
34. Iteratee Consumer as a state machine
35. Iteratees consume Input
36. object Input { case class El[+E](e: E) case object Empty case object EOF }
37. and propagates a state
38. object Step { case class Done[+A, E] (a: A, remaining: Input[E]) case class Cont[E, +A] (k: Input[E] => Iteratee[E, A]) case class Error[E] (msg: String, input: Input[E]) }
39. Enumerator Iteratee def step = ... val count = 0 Input El(...) Status Continue Iteratee def step = ... val count = 1 computes
40. Iteratee def step = ... val count = 1 Iteratee def step = ... val count = 1 Enumerator Input EOF Status Done computes
41. Iteratee def step = ... val count = 1 Enumerator Input El(...) Status Error Iteratee def step = ... val error = "Runtime Error" computes
42. val last: RowConsumer[Option[Row]] = { def step(last: Option[Row]): K[Row,Option[Row]]= { case Input.Empty => Cont(step(last)) case Input.EOF => Done(last, Input.EOF) case Input.El(e) => Cont(step(Some(e))) } Cont(step(Option.empty[Row])) }
43. object AmountConsumer { val sum: AmountConsumer[Amount] = } (rows: Iterable[Amount]) => rows.foldLeft(Amount(0, EUR))(_ + _)
44. object AmountConsumer { val sum: AmountConsumer[Amount] = } Iteratee.fold[Amount, Amount] (Amount(0, EUR))(_ + _)
45. import RowTransformer.totalPaid import AmountConsumer.sum val totalPaidComputation: Future[Amount] = portfolio.rows.run(sum)
46. import RowTransformer.totalPaid import AmountConsumer.sum val totalPaidComputation: Future[Amount] = portfolio.rows |>>> sum
47. Enumeratee map and filter
48. Enumerator Iteratee Producer Input Status Consumer
49. Enumerator Iteratee Producer Input[A] Status Consumer Enumerator Transformation Input[B]
50. Data transformation object RowTransformer { val totalPaid = Enumeratee.map[Row](row => row.interests + row.amortization ) }
51. def until(date: DateMidnight) = Enumeratee.filter[Row]( row => !row.date.isAfter(date) ) Data filtering
52. type RowProducer = Iterable[Row] type RowProducer = Enumerator[Row] type AmountConsumer[T] = (Iterable[Amount]=>T) type RowTransformer[T] = (Row=>T) type RowTransformer[T] = Enumeratee[Row, T] type AmountConsumer[T] = Iteratee[Amount, T]
53. Futures are composable map, flatMap, filter onComplete, onSuccess, onError, recover
54. // Produce rows val totalPaidComputation: Future[Amount] = portfolio.rows &> totalPaid |>>> sum // Blocking the thread to wait for the result val totalPaid = Await.result( totalPaidComputation, atMost = defaultTimeout) totalPaid should equal(3480 EUR)
55. We still have function composition and prepares the code for asynchronism
56. //Loan Stream.iterate(first)(f) take duration //Porfolio loans => loans flatMap (loan => loan.rows) RowProducer //Loan Enumerator.enumerate( Stream.iterate(first)(f).take(duration) ) //Porfolio Enumerator.interleave(loans.map(_.rows))
57. RowProducer //Loan Enumerator.enumerate( Stream.iterate(first)(f).take(duration) ) //Porfolio Enumerator.interleave(loans.map(_.rows)) + on demand computation + parallel computation
58. val totalPaid = (row: Row) => row.interests + row.amortization RowTransformer val totalPaid = Enumeratee.map[Row](row => row.interests + row.amortization )
59. RowTransformer + Function composition + map, filter, ... val totalPaid = Enumeratee.map[Row](row => row.interests + row.amortization )
60. AmountConsumer def sum = rows => rows.foldLeft(Amount(0, EUR))(_ + _) def sum = Iteratee.fold[Amount, Amount] (Amount(0, EUR))(_ + _)
61. AmountConsumer + Function composition + Asynchronism def sum = Iteratee.fold[Amount, Amount] (Amount(0, EUR))(_ + _)
62. Stream API Step 1 5000 loans 50 rows ~ 560 ms Iteratees Step 2 5000 loans 50 rows ~ 3500 ms ?
63. simple test complex test Thread.sleep((Math.random() * 1000) % 2) toLong)
64. Stream API Step 1 5000 loans 50 rows ~ 560 ms with pause ~ 144900 ms Iteratees Step 2 5000 loans 50 rows ~ 3500 ms with pause ~ 157285 ms ?
65. Cost of using this implementation of iteratees is greater than gain of interleaving for such small operations
66. Bulk interleaving
67. //Portfolio val split = loans.map(_.stream) .grouped(loans.size / 4) split .map(rows => Enumerator.flatten( ) ) .foldLeft(Enumerator.empty[Row]) (Enumerator.interleave(_, _)) Future(rows.flatten) .map(Enumerator.enumerate(_)) Seq[Stream[Row]] Seq[Loan] Iterator[Seq[Stream[Row]]] Seq[Stream[Row]] Future[Seq[Row]] Future[Enumerator[Row]] Enumerator[Row] Enumerator[Row] Seq[Enumerator[Row]]
68. Stream API Step 1 5000 loans 50 rows ~ 560 ms with pause ~ 144900 ms Iteratees Step 2 5000 loans 50 rows ~ 4571 ms with pause ~ 39042 ms
69. On demand computation Function composition Sequential computation Synchronism Transformation limited to «map» Pros Cons
70. On demand computation Function composition Sequential computation Synchronism Pros Cons
71. On demand computation Pros Cons Function composition Parallel computation Asynchronism No error management No elasticity No resilience
72. Step 3 Akka actor
73. Integrating Akka libraryDependencies ++= Seq( "com.typesafe.akka" %% "akka-actor" % "2.2.0" )
74. Actors are objects They communicate with each other by messages asynchronously
75. class Backend extends Actor { def receive = { case Compute(loan) => sender.tell( msg = loan.stream.toList, sender = self) } } case class Compute(loan: Loan)
76. case class Loan def rows(implicit calculator: ActorRef, ctx: ExecutionContext) = { val responseFuture = ask(calculator,Compute(this)) val rowsFuture = responseFuture .mapTo[List[Row]] rowsFuture.map(Enumerator.enumerate(_)) ) } }
77. val system = ActorSystem.create("ScalaIOSystem") val calculator = system.actorOf(Props[Backend] .withRouter( RoundRobinRouter(nrOfInstances = 10) ) ,"calculator") }
78. Supervision val simpleStrategy = OneForOneStrategy() { case _: AskTimeoutException => Resume case _: RuntimeException => Escalate } system.actorOf(Props[Backend] ... .withSupervisorStrategy(simpleStrategy)), "calculator")
79. Router Routee 3 Routee 2 Routee 1 Compute Compute
80. Router Routee 3 Routee 2 Routee 1 AskTimeoutException Resume
81. Router Routee 3 Routee 2 Routee 1 Actor System
82. //Loan Enumerator.enumerate( Stream.iterate(first)(f).take(duration) ) //Porfolio Enumerator.interleave(loans.map(_.rows)) RowProducer //Loan ask(calculator,Compute(this)) .mapTo[List[Row]] .map(Enumerator.enumerate(_)) //Porfolio Enumerator.interleave(loans.map(_.rows))
83. RowProducer //Loan ask(calculator,Compute(this)) .mapTo[List[Row]] .map(Enumerator.enumerate(_)) //Porfolio Enumerator.interleave(loans.map(_.rows)) + parallel computation - on demand computation
84. RowTransformer + Nothing changed val totalPaid = Enumeratee.map[Row](row => row.interests + row.amortization )
85. AmountConsumer def sum = Iteratee.fold[Amount, Amount] (Amount(0, EUR))(_ + _) + Nothing changed
86. 5000 loans 50 rows ~ 4571 ms with pause ~ 39042 ms Stream API Step 1 5000 loans 50 rows ~ 560 ms with pause ~ 144900 ms Iteratees Step 2 Akka actor Step 3 5000 loans 50 rows ~ 4271 ms with pause ~ 40882 ms
87. On demand computation Function composition Parallel computation Asynchronism Pros Cons No error management No elasticity No resilience
88. On demand computation Function composition Parallel computation Asynchronism Pros Cons No error management No elasticity No resilience
89. No on demand computation Function composition Parallel computation Asynchronism Error management Pros Cons No elasticity No resilience
90. Step 4 Akka cluster
91. Integrating Akka Cluster libraryDependencies ++= Seq( "com.typesafe.akka" %% "akka-cluster" % "2.2.0" )
92. Cluster Router ClusterRouterConfig Can create actors on different nodes of the cluster Role Local actors or not Control number of actors per node per system
93. Cluster Router AdaptiveLoadBalancingRouter Collect metrics (CPU, HEAP, LOAD) via JMX or Hyperic Sigar and make load balancing
94. val calculator = system.actorOf(Props[Backend] .withRouter( RoundRobinRouter(nrOfInstances = 10) ) ,"calculator") } val calculator = system.actorOf(Props[Backend] .withRouter(ClusterRouterConfig( local = localRouter, settings = clusterSettings) ) , "calculator") }
95. application.conf actor { provider = "akka.cluster.ClusterActorRefProvider" deployment.default.cluster { enabled = on } }
96. application.conf cluster { seed-nodes = [ "akka.tcp://ScalaIOSystem@127.0.0.1:2551", "akka.tcp://ScalaIOSystem@127.0.0.1:2552" ] auto-down = on }
97. Router Routee 3 Routee 1 Actor System Routee 4 Routee 3 Actor System Routee 6 Routee 5 Actor System Elasticity
98. Router Routee 3 Routee 1 Actor System Routee 4 Routee 3 Actor System Routee 6 Routee 5 Actor System Resilience
99. //Loan ask(calculator,Compute(this)) .mapTo[List[Row]] .map(Enumerator.enumerate(_)) //Porfolio Enumerator.interleave(loans.map(_.rows)) RowProducer + Nothing changed
100. RowTransformer + Nothing changed val totalPaid = Enumeratee.map[Row](row => row.interests + row.amortization )
101. AmountConsumer def sum = Iteratee.fold[Amount, Amount] (Amount(0, EUR))(_ + _) + Nothing changed
102. Function composition Parallel computation Asynchronism Error management Pros Cons No on demand computation No elasticity No resilience
103. Function composition Parallel computation Asynchronism Error management Pros Cons No on demand computation No elasticity No resilience
104. Function composition Parallel computation Asynchronism Error management Elasticity Resilience Network serialization Pros Cons No on demand computation
105. Stream API Step 1 5000 loans 50 rows ~ 560 ms with pause ~ 144900 ms Iteratees Step 2 5000 loans 50 rows ~ 4571 ms with pause ~ 39042 ms Akka actor Step 3 5000 loans 50 rows ~ 4271 ms with pause ~ 40882 ms Akka cluster Step 4 5000 loans 50 rows ~ 6213 ms with pause ~ 77957 ms 1 node / 2 actors
106. Stream API Step 1 5000 loans 50 rows ~ 560 ms with pause ~ 144900 ms Iteratees Step 2 5000 loans 50 rows ~ 4571 ms with pause ~ 39042 ms Akka actor Step 3 5000 loans 50 rows ~ 4271 ms with pause ~ 40882 ms Akka cluster Step 4 5000 loans 50 rows ~ 5547 ms with pause ~ 39695 ms 2 nodes / 4 actors
107. Conclusion
108. Stream API Step 1 powerful library low memory performance when single threaded Iteratees Step 2 Akka actor Step 3 error management control on parallel execution via configuration Akka cluster Step 4 elasticity resilience monitoring elegant API enable asynchronism and parallelism
109. It’s all about trade-off
110. Hot subject Recet blog post from «Mandubian» for Scalaz stream machines and iteratees [1] Recent presentation from «Heather Miller» for spores (distribuables closures) [2] Recent release of Scala 2.10.3 and performance optimization of Promise Release candidate of play-iteratee module with performance optimization Lots of stuff in the roadmap of Akka cluster 2.3.0
111. Hot subject [1] : http://mandubian.com/2013/08/21/playztream/ [2] : https://speakerdeck.com/heathermiller/on-pickles-and-spores- improving-support-for-distributed-programming-in-scala
112. YOU FOR watching THANK Merci!