expiration strategies for single async cache

app/controllers/Prismic.scala

@@ -2,6 +2,7 @@ package controllers
 
 import scala.concurrent.duration._
 
+import lila.memo.AsyncCache2Single
 import io.prismic.Fragment.DocumentLink
 import io.prismic.{ Api => PrismicApi, _ }
 import lila.app._
@@ -16,10 +17,10 @@ object Prismic {
     case _      => logger info message
   }
 
-  private val prismicApiCache = lila.memo.AsyncCache2Single[PrismicApi](
+  private val prismicApiCache = AsyncCache2Single[PrismicApi](
     name = "prismic.fetchPrismicApi",
     f = PrismicApi.get(Env.api.PrismicApiUrl, logger = prismicLogger),
-    timeToLive = 1 minute)(Env.current.system)
+    expireAfter = AsyncCache2Single.ExpireAfterWrite(1 minute))(Env.current.system)
 
   def prismicApi = prismicApiCache.get
 

modules/memo/src/main/AsyncCache2.scala

@@ -36,29 +36,3 @@ object AsyncCache2 {
   case class ExpireAfterAccess(duration: FiniteDuration) extends ExpireAfter
   case class ExpireAfterWrite(duration: FiniteDuration) extends ExpireAfter
 }
-
-final class AsyncCache2Single[V] private (cache: AsyncLoadingCache[Unit, V], f: Unit => Fu[V]) {
-
-  def get: Fu[V] = cache.get(())
-
-  def refresh: Unit = cache.put((), f(()))
-}
-
-object AsyncCache2Single {
-
-  def apply[V](
-    name: String,
-    f: => Fu[V],
-    timeToLive: FiniteDuration,
-    resultTimeout: FiniteDuration = 5 seconds)(implicit system: ActorSystem) = {
-    val safeF = (_: Unit) => f.withTimeout(
-      duration = resultTimeout,
-      error = lila.common.LilaException(s"AsyncCache $name single timed out after $resultTimeout"))
-    new AsyncCache2Single[V](
-      cache = Scaffeine()
-        .expireAfterWrite(timeToLive)
-        .maximumSize(1)
-        .buildAsyncFuture(safeF),
-      safeF)
-  }
-}

modules/memo/src/main/AsyncCache2Single.scala

@@ -0,0 +1,37 @@
+package lila.memo
+
+import akka.actor.ActorSystem
+import com.github.blemale.scaffeine.{ AsyncLoadingCache, Scaffeine }
+import scala.concurrent.duration._
+
+final class AsyncCache2Single[V] private (cache: AsyncLoadingCache[Unit, V], f: Unit => Fu[V]) {
+
+  def get: Fu[V] = cache.get(())
+
+  def refresh: Unit = cache.put((), f(()))
+}
+
+object AsyncCache2Single {
+
+  def apply[V](
+    name: String,
+    f: => Fu[V],
+    expireAfter: ExpireAfter,
+    resultTimeout: FiniteDuration = 5 seconds)(implicit system: ActorSystem) = {
+    val safeF = (_: Unit) => f.withTimeout(
+      duration = resultTimeout,
+      error = lila.common.LilaException(s"AsyncCache $name single timed out after $resultTimeout"))
+    val b1 = Scaffeine().maximumSize(1)
+    val b2 = expireAfter match {
+      case ExpireAfterAccess(duration) => b1 expireAfterAccess duration
+      case ExpireAfterWrite(duration)  => b1 expireAfterWrite duration
+    }
+    new AsyncCache2Single[V](
+      cache = b2.buildAsyncFuture(safeF),
+      safeF)
+  }
+
+  sealed trait ExpireAfter
+  case class ExpireAfterAccess(duration: FiniteDuration) extends ExpireAfter
+  case class ExpireAfterWrite(duration: FiniteDuration) extends ExpireAfter
+}