feat: Cache identity responses

darkfeed/build.gradle.kts

···
     implementation(libs.ktor.serialization.kotlinx.json)
     implementation(libs.java.jwt)
     implementation(libs.clikt)
+    implementation(libs.kache)
 }
 
 java {

darkfeed/src/main/kotlin/Main.kt

···
         } catch (error: Exception) {
             log.warn("Unknown failure occurred: {}", error.message)
             null
-        } finally {
+        }
+
+        if (authAccount == null) {
             log.warn("Authorized requests (e.g. updating feed generator record) will not be available")
         }
 

darkfeed/src/main/kotlin/api/AtpIdentityClient.kt

···
 package rs.averyrive.darkfeed.api
 
+import com.mayakapps.kache.InMemoryKache
 import io.ktor.client.*
 import io.ktor.client.call.*
 import io.ktor.client.engine.cio.*
···
 import kotlinx.serialization.json.Json
 import org.slf4j.LoggerFactory
 import rs.averyrive.darkfeed.api.model.*
+import kotlin.time.Duration.Companion.hours
+
+// Specify size of each cache
+const val CACHE_SIZE: Long = 1 * 1024 * 1024 // 1 MB
 
 /** Client that handles identity related requests for ATProto accounts. */
 class AtpIdentityClient {
···
         install(Logging)
     }
 
+    /** Cache of handle to DID relationships. */
+    private val handleDidCache = InMemoryKache<String, Did>(CACHE_SIZE) {
+        expireAfterWriteDuration = 1.hours
+    }
+
+    /** Cache of DID to PDS host relationships. */
+    private val didPdsCache = InMemoryKache<Did, String>(CACHE_SIZE) {
+        expireAfterWriteDuration = 1.hours
+    }
+
     /**
      * Resolve a handle's DID.
      *
···
      */
     suspend fun resolveDidFromHandle(handle: String): Did {
         log.debug("Resolving DID for '{}'...", handle)
+
+        // Return cached DID if it exists.
+        handleDidCache.get(handle)?.let { did ->
+            log.debug("Returning cached DID for '{}': {}", handle, did.toString())
+            return did
+        }
 
         @Serializable
         data class ResolveHandleResponse(val did: String)
···
             else -> throw RuntimeException("Received unexpected response: ${resolveHandleResponse.bodyAsText()}")
         }
 
-        log.debug("Resolved DID for '{}': {}", handle, did.toString())
+        // Cache the DID for this handle.
+        handleDidCache.put(handle, did)
+        log.debug("Resolved and cached DID for '{}': {}", handle, did.toString())
 
         return did
     }
···
      */
     suspend fun resolvePdsFromDid(did: Did): String {
         log.debug("Resolving PDS for '{}'...", did.toString())
+
+        // Return cached PDS host if it exists.
+        didPdsCache.get(did)?.let { pdsHost ->
+            log.debug("Returning cached PDS host for '{}': {}", did.toString(), pdsHost)
+            return pdsHost
+        }
 
         // Get the DID document, using either `plc.directory` or
         // `/.well-known/did.json` depending on the type of DID.
···
             ?.serviceEndpoint
             ?: throw PdsNotFoundException(did)
 
-        log.debug("Resolved PDS for '{}': {}", did.toString(), pdsHost)
+        // Cache the PDS for this DID.
+        didPdsCache.put(did, pdsHost)
+        log.debug("Resolved and cached PDS for '{}': {}", did.toString(), pdsHost)
 
         return pdsHost
+    }
+
+    /**
+     * Invalidate the PDS associated with the given DID.
+     *
+     * This should be used when a call to the PDS fails due to the PDS no longer
+     * being available. This may indicate that the PDS has moved and should be
+     * resolved again.
+     *
+     * @param did DID to invalidate.
+     */
+    suspend fun invalidateCachedPds(did: Did) {
+        didPdsCache.remove(did)
     }
 }
 

darkfeed/src/main/kotlin/api/BskyApi.kt

···
             val record: Generator,
         )
 
+        // TODO: If this PDS is not accessible, invalidate cache and retry.
         val ownerPdsHost = atpIdentityClient.resolvePdsFromDid(authManager.authAccountDid.toDid())
 
         val response = httpClient.post {
···
         @Serializable
         data class Response(val cursor: String?, val records: List<LikeRef>)
 
+        // TODO: If this PDS is not accessible, invalidate cache and retry.
         val requestorPdsHost = atpIdentityClient.resolvePdsFromDid(actor.toDid())
 
         val response = httpClient.get {

gradle/libs.versions.toml

···
 ktor = "3.0.1"
 auth0 = "4.4.0"
 clikt = "5.0.1"
+kache = "2.1.1"
 
 [libraries]
 logback-classic = { group = "ch.qos.logback", name = "logback-classic", version.ref = "logback" }
···
 ktor-serialization-kotlinx-json = { group = "io.ktor", name = "ktor-serialization-kotlinx-json", version.ref = "ktor" }
 java-jwt = { group = "com.auth0", name = "java-jwt", version.ref = "auth0" }
 clikt = { group = "com.github.ajalt.clikt", name = "clikt", version.ref = "clikt" }
+kache = { group = "com.mayakapps.kache", name = "kache", version.ref = "kache" }
 
 [plugins]
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }