Merge pull request #5 from frankois944/4-implement-missing-cachestorage-methods

Add new deletion api

Author: frankois944

KtorKMPFileCaching/build.gradle.kts

@@ -43,7 +43,7 @@ kotlin {
     }
     @OptIn(ExperimentalWasmDsl::class)
     wasmJs {
-        moduleName = "ktorfilecaching"
+        outputModuleName = "ktorfilecaching"
         browser {
             testTask {
                 useKarma {
@@ -127,15 +127,14 @@ kotlin {
             implementation(libs.ktor.client.mock)
             implementation(libs.kotlin.coroutines.test)
             implementation(libs.ktor.client.logging)
-            implementation(libs.kotlinx.datetime)
             implementation(libs.kotlin.serialization)
         }
     }
 }
 
 android {
     namespace = "fr.frankois944.ktorfilecaching"
-    compileSdk = 34
+    compileSdk = 36
     defaultConfig {
         minSdk = 24
     }
@@ -150,7 +149,7 @@ mavenPublishing {
     coordinates(
         groupId = "io.github.frankois944",
         artifactId = "ktorfilecaching",
-        version = "0.7.0",
+        version = "0.8.0",
     )
 
     // Configure POM metadata for the published artifact
@@ -185,7 +184,7 @@ mavenPublishing {
     }
 
     // Configure publishing to Maven Central
-    publishToMavenCentral(com.vanniktech.maven.publish.SonatypeHost.CENTRAL_PORTAL)
+    publishToMavenCentral()
 
     // Enable GPG signing for all publications
     signAllPublications()

KtorKMPFileCaching/src/browserStorageSystemMain/kotlin/fr/frankois944/ktorfilecaching/KtorFileCaching.localStorageSystemMain.kt

@@ -6,22 +6,29 @@ import io.ktor.client.plugins.cache.storage.CacheStorage
 import io.ktor.client.plugins.cache.storage.CachedResponseData
 import io.ktor.http.Url
 import io.ktor.util.collections.ConcurrentMap
+import io.ktor.util.logging.KtorSimpleLogger
+import io.ktor.util.logging.trace
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.cbor.Cbor
+import kotlinx.serialization.decodeFromByteArray
 import kotlinx.serialization.decodeFromHexString
+import kotlinx.serialization.encodeToByteArray
 import kotlinx.serialization.encodeToHexString
 import okio.ByteString.Companion.encodeUtf8
 import okio.FileSystem
 import okio.HashingSink
 import okio.Path
+import okio.Path.Companion.toPath
 import okio.blackholeSink
 import okio.buffer
 import okio.use
+import kotlin.collections.emptySet
 
 internal val prefix = "fr.frankois944.ktorfilecaching_key"
 
@@ -41,14 +48,18 @@ internal class FileCacheStorage(
 ) : CacheStorage {
     private val mutexes = ConcurrentMap<String, Mutex>()
 
+    @Suppress("ktlint:standard:property-naming")
+    private val LOGGER = KtorSimpleLogger("KtorFileCaching")
+
     override suspend fun store(
         url: Url,
         data: CachedResponseData,
     ): Unit =
         withContext(dispatcher) {
             val urlHex = key(url)
-            val caches = readCache(urlHex).filterNot { it.varyKeys == data.varyKeys } + data
-            writeCache(urlHex, caches)
+            updateCache(urlHex) { caches ->
+                caches.filterNot { it.varyKeys == data.varyKeys } + data
+            }
         }
 
     override suspend fun findAll(url: Url): Set<CachedResponseData> = readCache(key(url))
@@ -58,7 +69,24 @@ internal class FileCacheStorage(
         varyKeys: Map<String, String>,
     ): CachedResponseData? {
         val data = readCache(key(url))
-        return data.find { varyKeys.all { (key, value) -> it.varyKeys[key] == value } }
+        return data.find {
+            varyKeys.all { (key, value) -> it.varyKeys[key] == value }
+        }
+    }
+
+    override suspend fun remove(
+        url: Url,
+        varyKeys: Map<String, String>,
+    ) {
+        val urlHex = key(url)
+        updateCache(urlHex) { caches ->
+            caches.filterNot { it.varyKeys == varyKeys }
+        }
+    }
+
+    override suspend fun removeAll(url: Url) {
+        val urlHex = key(url)
+        deleteCache(urlHex)
     }
 
     private fun key(url: Url): String {
@@ -69,27 +97,53 @@ internal class FileCacheStorage(
         return hashingSink.hash.hex()
     }
 
-    private suspend fun writeCache(
+    private suspend fun readCache(urlHex: String): Set<CachedResponseData> {
+        val mutex = mutexes.computeIfAbsent(urlHex) { Mutex() }
+        return mutex.withLock { readCacheUnsafe(urlHex) }
+    }
+
+    private suspend inline fun updateCache(
         urlHex: String,
-        caches: List<CachedResponseData>,
-    ) = coroutineScope {
+        transform: (Set<CachedResponseData>) -> List<CachedResponseData>,
+    ) {
         val mutex = mutexes.computeIfAbsent(urlHex) { Mutex() }
-        mutex.withLock {
-            val serializedData = Cbor.encodeToHexString(caches.map { SerializableCachedResponseData(it) })
-            Database.setItem("${prefix}_$urlHex", serializedData)
+        return mutex.withLock {
+            val caches = readCacheUnsafe(urlHex)
+            writeCacheUnsafe(urlHex, transform(caches))
         }
     }
 
-    private suspend fun readCache(urlHex: String): Set<CachedResponseData> {
+    private suspend fun deleteCache(urlHex: String) {
         val mutex = mutexes.computeIfAbsent(urlHex) { Mutex() }
-        return mutex.withLock {
-            val item = Database.getItem("${prefix}_$urlHex")
-            if (item == null) return@withLock emptySet()
+        mutex.withLock {
             try {
-                Cbor.decodeFromHexString<Set<SerializableCachedResponseData>>(item).map { it.cachedResponseData }.toSet()
-            } catch (e: Exception) {
-                emptySet()
+                if (Database.getItem("${prefix}_$urlHex") == null) return@withLock
+                Database.removeItem("${prefix}_$urlHex")
+            } catch (cause: Exception) {
+                LOGGER.trace { "Exception during cache deletion in a file: ${cause.stackTraceToString()}" }
             }
         }
     }
+
+    private suspend fun writeCacheUnsafe(
+        urlHex: String,
+        caches: List<CachedResponseData>,
+    ) = coroutineScope {
+        try {
+            val serializedData = Cbor.encodeToHexString(caches.map { SerializableCachedResponseData(it) })
+            Database.setItem("${prefix}_$urlHex", serializedData)
+        } catch (cause: Exception) {
+            LOGGER.trace { "Exception during saving a cache to a file: ${cause.stackTraceToString()}" }
+        }
+    }
+
+    private suspend fun readCacheUnsafe(urlHex: String): Set<CachedResponseData> {
+        return try {
+            val item = Database.getItem("${prefix}_$urlHex") ?: return emptySet()
+            Cbor.decodeFromHexString<Set<SerializableCachedResponseData>>(item).map { it.cachedResponseData }.toSet()
+        } catch (cause: Exception) {
+            LOGGER.trace { "Exception during cache lookup in a file: ${cause.stackTraceToString()}" }
+            emptySet()
+        }
+    }
 }

KtorKMPFileCaching/src/commonMain/kotlin/fr/frankois944/ktorfilecaching/CachingCacheStorage.kt

@@ -38,4 +38,17 @@ internal class CachingCacheStorage(
         }
         return store.getValue(url)
     }
+
+    override suspend fun remove(
+        url: Url,
+        varyKeys: Map<String, String>,
+    ) {
+        delegate.remove(url, varyKeys)
+        store[url] = delegate.findAll(url)
+    }
+
+    override suspend fun removeAll(url: Url) {
+        delegate.removeAll(url)
+        store.remove(url)
+    }
 }