temporary commit

src/main/kotlin/net/woggioni/gbcs/cache/Cache.kt

@@ -1,10 +0,0 @@
-package net.woggioni.gbcs.cache
-
-import io.netty.buffer.ByteBuf
-import java.nio.channels.ByteChannel
-
-interface Cache {
-    fun get(key : String) : ByteChannel?
-
-    fun put(key : String, content : ByteBuf) : Unit
-}

src/main/kotlin/net/woggioni/gbcs/cache/FileSystemCache.kt

@@ -1,20 +1,32 @@
 package net.woggioni.gbcs.cache
 
-import io.netty.buffer.ByteBuf
-import net.woggioni.gbcs.GradleBuildCacheServer.Companion.digestString
+import net.woggioni.gbcs.api.Cache
+import net.woggioni.jwo.JWO
 import net.woggioni.jwo.LockFile
+import java.nio.channels.Channels
 import java.nio.channels.FileChannel
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.StandardCopyOption
 import java.nio.file.StandardOpenOption
 import java.nio.file.attribute.BasicFileAttributes
+import java.security.MessageDigest
 import java.time.Duration
 import java.time.Instant
 import java.util.concurrent.atomic.AtomicReference
+import java.util.zip.Deflater
+import java.util.zip.DeflaterOutputStream
+import java.util.zip.Inflater
+import java.util.zip.InflaterInputStream
 
 
-class FileSystemCache(val root: Path, val maxAge: Duration) : Cache {
+class FileSystemCache(
+    val root: Path,
+    val maxAge: Duration,
+    val digestAlgorithm: String?,
+    val compressionEnabled: Boolean,
+    val compressionLevel: Int
+) : Cache {
 
     private fun lockFilePath(key: String): Path = root.resolve("$key.lock")
 
@@ -22,40 +34,52 @@ class FileSystemCache(val root: Path, val maxAge: Duration) : Cache {
         Files.createDirectories(root)
     }
 
-    override fun equals(other: Any?): Boolean {
-        return when (other) {
-            is FileSystemCache -> {
-                other.root == root && other.maxAge == maxAge
-            }
+    private var nextGc = AtomicReference(Instant.now().plus(maxAge))
 
-            else -> false
+    override fun get(key: String) = (digestAlgorithm
+        ?.let(MessageDigest::getInstance)
+        ?.let { md ->
+            digestString(key.toByteArray(), md)
+        } ?: key).let { digest ->
+        LockFile.acquire(lockFilePath(digest), true).use {
+            root.resolve(digest).takeIf(Files::exists)?.let { file ->
+                if (compressionEnabled) {
+                    val inflater = Inflater()
+                    Channels.newChannel(InflaterInputStream(Files.newInputStream(file), inflater))
+                } else {
+                    FileChannel.open(file, StandardOpenOption.READ)
+                }
+            }
+        }.also {
+            gc()
         }
     }
 
-    override fun hashCode(): Int {
-        return root.hashCode() xor maxAge.hashCode()
-    }
-
-    private var nextGc = AtomicReference(Instant.now().plus(maxAge))
-
-    override fun get(key: String) = LockFile.acquire(lockFilePath(key), true).use {
-        root.resolve(key).takeIf(Files::exists)?.let { FileChannel.open(it, StandardOpenOption.READ) }
-    }.also {
-        gc()
-    }
-
-    override fun put(key: String, content: ByteBuf) {
-        LockFile.acquire(lockFilePath(key), false).use {
-            val file = root.resolve(key)
-            val tmpFile = Files.createTempFile(root, null, ".tmp")
-            try {
-                Files.newOutputStream(tmpFile).use {
-                    content.readBytes(it, content.readableBytes())
+    override fun put(key: String, content: ByteArray) {
+        (digestAlgorithm
+            ?.let(MessageDigest::getInstance)
+            ?.let { md ->
+                digestString(key.toByteArray(), md)
+            } ?: key).let { digest ->
+            LockFile.acquire(lockFilePath(digest), false).use {
+                val file = root.resolve(digest)
+                val tmpFile = Files.createTempFile(root, null, ".tmp")
+                try {
+                    Files.newOutputStream(tmpFile).let {
+                        if (compressionEnabled) {
+                            val deflater = Deflater(compressionLevel)
+                            DeflaterOutputStream(it, deflater)
+                        } else {
+                            it
+                        }
+                    }.use {
+                        it.write(content)
+                    }
+                    Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
+                } catch (t: Throwable) {
+                    Files.delete(tmpFile)
+                    throw t
                 }
-                Files.move(tmpFile, file, StandardCopyOption.ATOMIC_MOVE)
-            } catch (t: Throwable) {
-                Files.delete(tmpFile)
-                throw t
             }
         }.also {
             gc()
@@ -87,4 +111,23 @@ class FileSystemCache(val root: Path, val maxAge: Duration) : Cache {
             Files.delete(lockFile)
         }
     }
+
+    override fun close() {}
+
+    companion object {
+        fun digest(
+            data: ByteArray,
+            md: MessageDigest = MessageDigest.getInstance("MD5")
+        ): ByteArray {
+            md.update(data)
+            return md.digest()
+        }
+
+        fun digestString(
+            data: ByteArray,
+            md: MessageDigest = MessageDigest.getInstance("MD5")
+        ): String {
+            return JWO.bytesToHex(digest(data, md))
+        }
+    }
 }

src/main/kotlin/net/woggioni/gbcs/cache/FileSystemCacheConfiguration.kt

@@ -0,0 +1,27 @@
+package net.woggioni.gbcs.cache
+
+import net.woggioni.gbcs.api.Configuration
+import net.woggioni.gbcs.base.GBCS
+import net.woggioni.jwo.Application
+import java.nio.file.Path
+import java.time.Duration
+
+data class FileSystemCacheConfiguration(
+    val root: Path?,
+    val maxAge: Duration,
+    val digestAlgorithm : String?,
+    val compressionEnabled: Boolean,
+    val compressionLevel: Int,
+) : Configuration.Cache {
+    override fun materialize() = FileSystemCache(
+        root ?: Application.builder("gbcs").build().computeCacheDirectory(),
+        maxAge,
+        digestAlgorithm,
+        compressionEnabled,
+        compressionLevel
+    )
+
+    override fun getNamespaceURI() = GBCS.GBCS_NAMESPACE_URI
+
+    override fun getTypeName() = "fileSystemCacheType"
+}

src/main/kotlin/net/woggioni/gbcs/cache/FileSystemCacheProvider.kt

@@ -0,0 +1,66 @@
+package net.woggioni.gbcs.cache
+
+import net.woggioni.gbcs.api.CacheProvider
+import net.woggioni.gbcs.base.GBCS
+import net.woggioni.gbcs.base.Xml
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import java.nio.file.Path
+import java.time.Duration
+import java.util.zip.Deflater
+
+class FileSystemCacheProvider : CacheProvider<FileSystemCacheConfiguration> {
+
+    override fun getXmlSchemaLocation() = "classpath:net/woggioni/gbcs/schema/gbcs.xsd"
+
+    override fun getXmlType() = "fileSystemCacheType"
+
+    override fun getXmlNamespace() = "urn:net.woggioni.gbcs"
+
+    override fun deserialize(el: Element): FileSystemCacheConfiguration {
+        val path = el.getAttribute("path")
+            .takeIf(String::isNotEmpty)
+            ?.let(Path::of)
+        val maxAge = el.getAttribute("max-age")
+            .takeIf(String::isNotEmpty)
+            ?.let(Duration::parse)
+            ?: Duration.ofDays(1)
+        val enableCompression = el.getAttribute("enable-compression")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toBoolean)
+            ?: true
+        val compressionLevel = el.getAttribute("compression-level")
+            .takeIf(String::isNotEmpty)
+            ?.let(String::toInt)
+            ?: Deflater.DEFAULT_COMPRESSION
+        val digestAlgorithm = el.getAttribute("digest").takeIf(String::isNotEmpty) ?: "MD5"
+
+        return FileSystemCacheConfiguration(
+            path,
+            maxAge,
+            digestAlgorithm,
+            enableCompression,
+            compressionLevel
+        )
+    }
+
+    override fun serialize(doc: Document, cache : FileSystemCacheConfiguration) = cache.run {
+        val result = doc.createElement("cache")
+        Xml.of(doc, result) {
+            val prefix = doc.lookupPrefix(GBCS.GBCS_NAMESPACE_URI)
+            attr("xs:type", "${prefix}:fileSystemCacheType", GBCS.XML_SCHEMA_NAMESPACE_URI)
+            attr("path", root.toString())
+            attr("max-age", maxAge.toString())
+            digestAlgorithm?.let { digestAlgorithm ->
+                attr("digest", digestAlgorithm)
+            }
+            attr("enable-compression", compressionEnabled.toString())
+            compressionLevel.takeIf {
+                it != Deflater.DEFAULT_COMPRESSION
+            }?.let {
+                attr("compression-level", it.toString())
+            }
+        }
+        result
+    }
+}