This document summarizes the process of building a caching layer for a Scala library that handles large datasets. It describes the need for a caching mechanism to store large files and internal state in a distributed key-value store. The solution created a "zStore" interface with Cassandra and in-memory implementations. It then built a "zCache" layer that uses the zStore and a memoization technique to cache computation results, serialize and deserialize objects, and handle caching and expiration policies.

1. A TALE OF BUILDING
A LIBRARY IN SCALA
Yaakov Breuer
Photo License: “CC0 Public Domain” https://creativecommons.org/publicdomain/zero/1.0/
{facebook,github}.com/bryaakov

2. Agenda
• Background
• The Problem
• Design Goals
• The Solution
• Caching Layer

4. • Distributed high-scale data warehouse
• Combines Big Data with Linked Data
Linked Data is a way of modeling the world by
a graph with typed edges:
Background: “CM-Well”
Yaakov TR
worksAt

5. Background: “CM-Well”
• Was created about 9 years ago
• Holds 4B objects in Production
• Was open-sourced a year ago
 Usually not an easy task in large corporations
 Keeping us in shape

6. Background: “CM-Well”
Play
Kafka
BG
Process
BG
Process
BG
Process
Akka Sterams
ElasticsearchCassandra

7. Background: “CM-Well”
Example 1: Read/Query
$ curl localhost:9000/_sparql --data-binary '
SELECT ?comp WHERE {
<http://example.org/yaakov>
<http://example.org/ont/worksAt> ?comp . }'
------------------------------------------
| comp |
|========================================|
| <http://permid.org/1-4295861160> |
------------------------------------------

8. Background: “CM-Well”
Example 1: Read/Query (what actually happens)
HTTP GET is received:
• Translate payload to a case class: SparqlRequest
• Query Elasticsearch
• Fetch data from Cassandra
• Return human-readable response

9. Background: “CM-Well”
Example 2: Data ingest
$ curl -X PUT localhost:9000/_in?format=n3 --data-binary
'@prefix example: <http://example.org/ont/> .
<http://example.org/Yaakov>
example:worksAt <http://permid.org/1-4295861160> .'
{"success":true}

10. Background: “CM-Well”
Example 2: Data ingest (what actually happens)
HTTP PUT/POST was received:
• Data is parsed
• Kafka messages are being prdocued
• The user gets 200 OK
• (Eventually) Kafka Messages are consumed
• Data is persisted in Cassandra
• Data is indexed in Elasticsearch

11. THE PROBLEM

12. • Normally, we store documents / objects
• We do support large files as objects
• Kafka messages should be small *
• “Any problem in computer science can be
solved with another layer of indirection”
(David Wheeler)
* https://kafka.apache.org/documentation/#configuration
The Problem

13. We wanted…
• A key/value store
• Distributed and Persisted
• put/get API
• To keep it simple
• An in-process solution
Design Goals

14. Why re-invent the wheel?
(The everlasting trade-off…)
It seems twitter/util has a util-cache module
 Might be a good fit
 No persistence
 Twitter Futures
Other options?

15. THE SOLUTION:
“zStore”

16. The zStore Trait
trait ZStore {
def put(uzid: String, value: Array[Byte]): Future[Unit]
def put(uzid: String, value: Array[Byte], secondsToLive: Int):
Future[Unit]
def get(uzid: String): Future[Array[Byte]]
def remove(uzid: String): Future[Unit]
}

17. • ZStoreImpl – uses Cassandra
• ZStoreMem – in memory (for testing)
Implementations

18. • Main usage – large files
• Key is hash(content)
• Keeping internal state (e.g. Kafka offsets)
• Caching
• Using TTL
• Using Memoization
Usages

19. Adding a Caching Layer

20. Next Level: From zStore to zCache
• zStore has a String => Future[Array[Byte]] API
• We need to generalize it to K => Future[V]
• And let’s use memoization

21. Memoize
• Traditionally, “memoize” is a function that takes
one function and returns a new function with same
singnature that caches results.
• So you can simply wrap existing heavylifting
method by it; no need to refactor.

22. Memoize Example
Reminder – HTTP GET is received:
• Translate payload to a case class: SparqlRequest
• Query Elasticsearch
• Fetch data from Cassandra
• Return human-readable response

23. Memoize Example
def handleHttpGet = {
val request: SparqlRequest = ???
val response = execute(request)
response.map(Ok.apply) // 200 OK
}

24. Memoize Example
val cachedExecute = memoize(execute)
def handleHttpGet = {
val request: SparqlRequest = ???
val response = cachedExecute(request)
response.map(Ok.apply) // 200 OK
}

25. zCache.memoize
When used, will have to do the following:
Given a key,
• Get from zStore (with retries)
• If exists, return value
• Else:
• Evaluate the “task”
• Put results in zStore (with TTL)
• Return value

26. zCache.memoize
In order achieve that, we are going to need:
Given a key, convert from key:K to uzid:String
• Get from zStore (with retries)
• If exists, return value but map from Array[Byte] to V
• Else:
• Evaluate the “task”
• Put results in zStore (with TTL)
but map from V to Array[Byte]
• Return value

27. def memoize[K,V](task: K => Future[V])
: K => Future[V] = ???
zCache: Constructing memoize API

28. def memoize[K,V](task: K => Future[V])(
digest: K => String,
deserializer: Array[Byte] => V,
serializer: V => Array[Byte]
): K => Future[V] = ???
zCache: Constructing memoize API

29. def memoize[K,V](task: K => Future[V])(
digest: K => String,
deserializer: Array[Byte] => V,
serializer: V => Array[Byte],
isCachable: V => Boolean
)
: K => Future[V] = ???
zCache: Constructing memoize API

30. def memoize[K,V](task: K => Future[V])(
digest: K => String,
deserializer: Array[Byte] => V,
serializer: V => Array[Byte],
isCachable: V => Boolean = (_: V) => true
)
: K => Future[V] = ???
zCache: Constructing memoize API

31. def memoize[K,V](task: K => Future[V])(
digest: K => String,
deserializer: Array[Byte] => V,
serializer: V => Array[Byte],
isCachable: V => Boolean = (_: V) => true
)(ttlSeconds: Int = 10, pollingMaxRetries: Int = 5,
pollingInterval: Int = 1)
: K => Future[V] = ???
zCache: Constructing memoize API

32. def memoize[K,V](task: K => Future[V])(
digest: K => String,
deserializer: Array[Byte] => V,
serializer: V => Array[Byte],
isCachable: V => Boolean = (_: V) => true
)(ttlSeconds: Int = 10, pollingMaxRetries: Int = 5,
pollingInterval: Int = 1)(
implicit ec: ExecutionContext
): K => Future[V] = ???
zCache: Constructing memoize API

33. THANK YOU

34. FAQ: Can I reuse this library?
• Probably not as-is…
• You’re welcome to be inspired

35. • Contacts:
facebook.com/bryaakov
github.com/bryaakov
• Questions?