refactor(server): allow injecting bindings cache (#1928)

To improve testability, for the purpose of testing the fix in
#1924

Author: krzema12

jit-binding-server/src/main/kotlin/io/github/typesafegithub/workflows/jitbindingserver/ArtifactRoutes.kt

@@ -1,6 +1,7 @@
 package io.github.typesafegithub.workflows.jitbindingserver
 
 import com.github.benmanes.caffeine.cache.Caffeine
+import com.sksamuel.aedile.core.LoadingCache
 import com.sksamuel.aedile.core.asLoadingCache
 import com.sksamuel.aedile.core.refreshAfterWrite
 import io.github.oshai.kotlinlogging.KotlinLogging.logger
@@ -35,41 +36,46 @@ typealias ArtifactResult = Result<Map<String, Artifact>>
 
 private val prefetchScope = CoroutineScope(Dispatchers.IO)
 
-private val bindingsCache =
+internal fun buildBindingsCache(): LoadingCache<ActionCoords, ArtifactResult> =
     Caffeine
         .newBuilder()
         .refreshAfterWrite(1.hours)
         .recordStats()
         .asLoadingCache<ActionCoords, ArtifactResult> { runCatching { it.buildVersionArtifacts()!! } }
 
-fun Routing.artifactRoutes(prometheusRegistry: PrometheusMeterRegistry? = null) {
+fun Routing.artifactRoutes(
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
+    prometheusRegistry: PrometheusMeterRegistry? = null,
+) {
     prometheusRegistry?.let {
         CaffeineCacheMetrics.monitor(it, bindingsCache.underlying(), "bindings_cache")
     }
 
     route("{owner}/{name}/{version}/{file}") {
-        artifact(prometheusRegistry, refresh = false)
+        artifact(prometheusRegistry, bindingsCache, refresh = false)
     }
 
     route("/refresh/{owner}/{name}/{version}/{file}") {
-        artifact(prometheusRegistry, refresh = true)
+        artifact(prometheusRegistry, bindingsCache, refresh = true)
     }
 }
 
 private fun Route.artifact(
     prometheusRegistry: PrometheusMeterRegistry?,
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
     refresh: Boolean = false,
 ) {
-    headArtifact(prometheusRegistry, refresh)
-    getArtifact(prometheusRegistry, refresh)
+    headArtifact(bindingsCache, prometheusRegistry, refresh)
+    getArtifact(bindingsCache, prometheusRegistry, refresh)
 }
 
 private fun Route.headArtifact(
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
     prometheusRegistry: PrometheusMeterRegistry?,
     refresh: Boolean,
 ) {
     head {
-        val bindingArtifacts = call.toBindingArtifacts(refresh) ?: return@head call.respondNotFound()
+        val bindingArtifacts = call.toBindingArtifacts(refresh, bindingsCache) ?: return@head call.respondNotFound()
 
         val file = call.parameters["file"] ?: return@head call.respondNotFound()
 
@@ -84,11 +90,12 @@ private fun Route.headArtifact(
 }
 
 private fun Route.getArtifact(
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
     prometheusRegistry: PrometheusMeterRegistry?,
     refresh: Boolean,
 ) {
     get {
-        val bindingArtifacts = call.toBindingArtifacts(refresh) ?: return@get call.respondNotFound()
+        val bindingArtifacts = call.toBindingArtifacts(refresh, bindingsCache) ?: return@get call.respondNotFound()
 
         if (refresh && !deliverOnRefreshRoute) return@get call.respondText(text = "OK")
 
@@ -105,13 +112,19 @@ private fun Route.getArtifact(
     }
 }
 
-internal fun prefetchBindingArtifacts(coords: Collection<ActionCoords>) {
+internal fun prefetchBindingArtifacts(
+    coords: Collection<ActionCoords>,
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
+) {
     prefetchScope.launch {
         bindingsCache.getAll(coords)
     }
 }
 
-private suspend fun ApplicationCall.toBindingArtifacts(refresh: Boolean): Map<String, Artifact>? {
+private suspend fun ApplicationCall.toBindingArtifacts(
+    refresh: Boolean,
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
+): Map<String, Artifact>? {
     val actionCoords = parameters.extractActionCoords(extractVersion = true)
 
     logger.info { "➡️ Requesting ${actionCoords.prettyPrint}" }

jit-binding-server/src/main/kotlin/io/github/typesafegithub/workflows/jitbindingserver/Main.kt

@@ -38,14 +38,15 @@ fun main() {
     Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
         logger.error(throwable) { "Uncaught exception in thread $thread" }
     }
+    val bindingsCache = buildBindingsCache()
     embeddedServer(Netty, port = 8080) {
         installPlugins(prometheusRegistry)
 
         routing {
             internalRoutes(prometheusRegistry)
 
-            artifactRoutes(prometheusRegistry)
-            metadataRoutes(prometheusRegistry)
+            artifactRoutes(bindingsCache, prometheusRegistry)
+            metadataRoutes(bindingsCache, prometheusRegistry)
         }
     }.start(wait = true)
 }

jit-binding-server/src/main/kotlin/io/github/typesafegithub/workflows/jitbindingserver/MetadataRoutes.kt

@@ -1,6 +1,7 @@
 package io.github.typesafegithub.workflows.jitbindingserver
 
 import com.github.benmanes.caffeine.cache.Caffeine
+import com.sksamuel.aedile.core.LoadingCache
 import com.sksamuel.aedile.core.asLoadingCache
 import com.sksamuel.aedile.core.refreshAfterWrite
 import io.github.oshai.kotlinlogging.KotlinLogging.logger
@@ -21,32 +22,45 @@ private val logger = logger { }
 
 typealias MetadataResult = Result<Map<String, String>>
 
-private val metadataCache =
+@Suppress("ktlint:standard:function-signature") // Conflict with detekt.
+private fun buildMetadataCache(
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
+): LoadingCache<ActionCoords, MetadataResult> =
     Caffeine
         .newBuilder()
         .refreshAfterWrite(1.hours)
         .recordStats()
         .asLoadingCache<ActionCoords, MetadataResult> {
             runCatching {
-                it.buildPackageArtifacts(githubAuthToken = getGithubAuthToken(), ::prefetchBindingArtifacts)
+                it.buildPackageArtifacts(
+                    githubAuthToken = getGithubAuthToken(),
+                    { coords -> prefetchBindingArtifacts(coords, bindingsCache) },
+                )
             }
         }
 
-fun Routing.metadataRoutes(prometheusRegistry: PrometheusMeterRegistry? = null) {
+fun Routing.metadataRoutes(
+    bindingsCache: LoadingCache<ActionCoords, ArtifactResult>,
+    prometheusRegistry: PrometheusMeterRegistry? = null,
+) {
+    val metadataCache = buildMetadataCache(bindingsCache)
     prometheusRegistry?.let {
         CaffeineCacheMetrics.monitor(it, metadataCache.underlying(), "metadata_cache")
     }
 
     route("{owner}/{name}/{file}") {
-        metadata()
+        metadata(metadataCache)
     }
 
     route("/refresh/{owner}/{name}/{file}") {
-        metadata(refresh = true)
+        metadata(metadataCache, refresh = true)
     }
 }
 
-private fun Route.metadata(refresh: Boolean = false) {
+private fun Route.metadata(
+    metadataCache: LoadingCache<ActionCoords, MetadataResult>,
+    refresh: Boolean = false,
+) {
     get {
         val actionCoords = call.parameters.extractActionCoords(extractVersion = false)