Running a background task to update a cache - scala

Question

I'm creating a web server using Akka-HTTP. When receiving a request (to a certain route), the server calls a REST API. The call to this API is fairly long. Currently, I'm caching the result so that the following request uses the cache. I want to have a background task that updates periodically the cache (by calling the API). When receiving the request, the server would use the cached result (instead of having to call the API). The cache would only be updated through the background task.
How would I do that? I can use Akka's scheduling module to run the task periodically but I don't know how to update the cache once the task has run.
Currently, I have something like that:
val roster = Util.get_roster()
var pcache = new SRCache(roster)
val route = cache(lfuCache, keyerFunction)(
pathSingleSlash {
get {
complete(
HttpEntity(
ContentTypes.`text/html(UTF-8)`,Views.index(pcache.get).toString))
}
}
)
pcache.get calls the API (which is quite slow) and I want to replace the API call by something that simply returns the content of the cache and add a background task to update the cache.

Answer 1

Assuming you are using the cache from this example: https://doc.akka.io/docs/akka-http/current/common/caching.html.
import akka.http.caching.scaladsl.Cache
import akka.http.caching.scaladsl.CachingSettings
import akka.http.caching.LfuCache
import akka.http.scaladsl.server.RequestContext
import akka.http.scaladsl.server.RouteResult
import akka.http.scaladsl.model.Uri
import akka.http.scaladsl.server.directives.CachingDirectives._
import scala.concurrent.duration._
// Use the request's URI as the cache's key
val keyerFunction: PartialFunction[RequestContext, Uri] = {
case r: RequestContext => r.request.uri
}
val defaultCachingSettings = CachingSettings(system)
val lfuCacheSettings =
defaultCachingSettings.lfuCacheSettings
.withInitialCapacity(25)
.withMaxCapacity(50)
.withTimeToLive(20.seconds)
.withTimeToIdle(10.seconds)
val cachingSettings =
defaultCachingSettings.withLfuCacheSettings(lfuCacheSettings)
val lfuCache: Cache[Uri, RouteResult] = LfuCache(cachingSettings)
// Create the route
val route = cache(lfuCache, keyerFunction)(innerRoute)
Your background task should be scheduled to update lfuCache. Here is the interface of this cache class you can use: https://doc.akka.io/api/akka-http/10.1.10/akka/http/caching/scaladsl/Cache.html.
Methods of interest:
abstract def get(key: K): Option[Future[V]]
// Retrieves the future instance that is currently in the cache for the given key.
abstract def getOrLoad(key: K, loadValue: (K) ⇒ Future[V]): Future[V]
// Returns either the cached Future for the given key,
// or applies the given value loading function on the key, producing a Future[V].
abstract def put(key: K, mayBeValue: Future[V])
(implicit ex: ExecutionContext): Future[V]
// Cache the given future if not cached previously.
This is the Scheduler interface you can use:
https://doc.akka.io/docs/akka/current/scheduler.html
val cancellable =
system.scheduler.schedule(0 milliseconds, 5 seconds, ...)
Your scheduler will call lfuCache.put(...) every n seconds and update cache.
Next, your code can follow one of these patterns:
Use cached route as your are already doing with:
val route = cache(lfuCache, keyerFunction)(....
Or simply call lfuCache.get(key) or lfuCache.getOrLoad(...) without using caching dsl directives (without this: cache(lfuCache,...).
If you are using Cache class directly for putting and retrieving values, then consider using simpler keys instead of URI values.