Why streaming APIs are good. Introduction to scalaz-stream. Implementation of Server-sent Events with scalaz-stream.

1. Streaming Data with
scalaz-stream
Gary Coady
gcoady@gilt.com

2. • Why do we want streaming APIs?
• Introduction to scalaz-stream
• Use case: Server-Sent Events implementation
Contents

3. Why do we want
streaming APIs?

4. Information with
Indeterminate/unbounded size
• Lines from a text file
• Bytes from a binary file
• Chunks of data from a TCP connection
• TCP connections
• Data from Kinesis or SQS or SNS or Kafka or…
• Data from an API with paged implementation

5. “Dangerous” Choices
• scala.collection.Iterable
Provides an iterator to step through items in
sequence
• scala.collection.immutable.Stream
Lazily evaluated, possibly infinite list of values

6. Do The Right Thing
• Safe setup and cleanup
• Constant memory usage
• Constant stack usage
• Refactor with confidence
• Composable
• Back-pressure

7. • Creates co-data
• Safe resource management
• Referential transparency
• Controlled asynchronous effects
What is scalaz-stream

8. User
code
Process
.await
“Waiting” for
callback
User
code
Callback

9. sealed
trait
Process[+F[_],
+O]
Effect
Output

10. case
class
Halt(cause:
Cause)
extends
Process[Nothing,
Nothing]

11. case
class
Emit[+O](seq:
Seq[O])
extends
Process[Nothing,
O]

12. case
class
Await[+F[_],
A,
+O](
req:
F[A],
rcv:
(EarlyCause
/
A)
=>
Process[F,
O]
)
extends
Process[F,
O]

13. Composition Options
Process1[I,
O]
-­‐
Stateful
transducer,
converts
I
=>
O
(with
state)
-­‐
Combine
with
“pipe”
Channel[F[_],
I,
O]
-­‐
Takes
I
values,
runs
function
I
=>
F[O]
-­‐
Combine
with
“through”
or
“observe”.
Sink[F[_],
I]
-­‐
Takes
I
values,
runs
function
I
=>
F[Unit]
-­‐
Add
with
“to”.

14. Implementing
Server-sent Events (SSE)
This specification defines an API for
opening an HTTP connection for
receiving push notifications from a
server in the form of DOM events.

15. case
class
SSEEvent(eventName:
Option[String],
data:
String)
data:
This
is
the
first
message.
data:
This
is
the
second
message,
it
data:
has
two
lines.
data:
This
is
the
third
message.
event:
add
data:
73857293
event:
remove
data:
2153
event:
add
data:
113411
Example streams

16. We want this type:
Process[Task,
SSEEvent]
“A potentially infinite stream of SSE event messages”

17. async.boundedQueue[A]
• Items added to queue are removed in same order
• Connect different asynchronous domains
• Methods:
def
enqueueOne(a:
A):
Task[Unit]
def
dequeue:
Process[Task,
A]

18. HTTP Client
Implementation
• Use Apache AsyncHTTPClient
• Hook into onBodyPartReceived callback
• Use async.boundedQueue to convert chunks into
stream

19. def
httpRequest(client:
AsyncHttpClient,
url:
String):
Process[Task,
ByteVector]
=
{
val
contentQueue
=
async.boundedQueue[ByteVector](10)
val
req
=
client.prepareGet(url)
req.execute(new
AsyncCompletionHandler[Unit]
{
override
def
onBodyPartReceived(content:
HttpResponseBodyPart)
=
{
contentQueue.enqueueOne(
ByteVector(content.getBodyByteBuffer)
).run
super.onBodyPartReceived(content)
}
})
contentQueue.dequeue
}

20. How to terminate
stream?

21. req.execute(new
AsyncCompletionHandler[Unit]
{
...
override
def
onCompleted(r:
Response):
Unit
=
{
logger.debug("Request
completed")
contentQueue.close.run
}
...
}

22. How to terminate
stream with errors?

23. req.execute(new
AsyncCompletionHandler[Unit]
{
...
override
def
onThrowable(t:
Throwable):
Unit
=
{
logger.debug("Request
failed
with
error",
t)
contentQueue.fail(t).run
}
...
}

24. Process[Task, ByteVector]
Process[Task, SSEEvent]
Process[Task, Underpants]
Step 1
Step 2
Step 3

25. • Split at line endings
• Convert ByteVector into UTF-8 Strings
• Partition by SSE “tag” (“data”, “id”, “event”, …)
• Emit accumulated SSE data when blank line found

26. • Split at line endings
ByteVector
=>
Seq[ByteVector]
• Convert ByteVector into UTF-8 Strings
ByteVector
=>
String
• Partition by SSE “tag” (“data”, “id”, “event”, …)
String
=>
SSEMessage
• Emit accumulated SSE data when blank line found
SSEMessage
=>
SSEEvent

27. Handling Network Errors
• If a network error occurs:
• Sleep a while
• Set up the connection again and keep going
• Append the same Process definition again!

28. def
sseStream:
Process[Task,
SSEEvent]
=
{
httpRequest(client,
url)
.pipe(splitLines)
.pipe(emitMessages)
.pipe(emitEvents)
.partialAttempt
{
case
e:
ConnectException
=>
retryRequest
case
e:
TimeoutException
=>
retryRequest
}
.map(_.merge)
}
def
retryRequest:
Process[Task,
SSEEvent]
=
{
time.sleep(retryTime)
++
sseStream
}

29. Usage
sseStream(client,
url)
pipe
jsonToString
to
io.stdOutLines

30. Questions?