Bulk cape support

Author: emyfops

common/src/main/kotlin/com/lambda/command/commands/CapeCommand.kt

@@ -23,6 +23,7 @@ import com.lambda.brigadier.argument.value
 import com.lambda.brigadier.execute
 import com.lambda.brigadier.required
 import com.lambda.command.LambdaCommand
+import com.lambda.network.CapeManager
 import com.lambda.network.CapeManager.updateCape
 import com.lambda.network.NetworkManager
 import com.lambda.util.Communication.info
@@ -38,7 +39,7 @@ object CapeCommand : LambdaCommand(
         required(literal("set")) {
             required(string("id")) { id ->
                 suggests { _, builder ->
-                    NetworkManager.capes
+                    CapeManager.capeList
                         .forEach { builder.suggest(it) }
 
                     builder.buildFuture()

common/src/main/kotlin/com/lambda/module/modules/client/Network.kt

@@ -49,10 +49,11 @@ object Network : Module(
     defaultTags = setOf(ModuleTag.CLIENT),
     enabledByDefault = true,
 ) {
-    val authServer  by setting("Auth Server", "auth.lambda-client.org")
-    val apiUrl      by setting("API Server", "https://api.lambda-client.org")
-    val apiVersion  by setting("API Version", ApiVersion.V1)
-    val mappings    by setting("Mappings", "https://mappings.lambda-client.org")
+    val authServer by setting("Auth Server", "auth.lambda-client.org")
+    val apiUrl by setting("API Server", "https://api.lambda-client.org")
+    val apiVersion by setting("API Version", ApiVersion.V1)
+    val mappings by setting("Mappings", "https://mappings.lambda-client.org")
+    val cdn by setting("CDN", "https://cdn.lambda-client.org")
 
     val gameVersion = SharedConstants.getGameVersion().name
 

common/src/main/kotlin/com/lambda/network/CapeManager.kt

@@ -17,45 +17,76 @@
 
 package com.lambda.network
 
+import com.lambda.Lambda.LOG
 import com.lambda.Lambda.mc
 import com.lambda.context.SafeContext
 import com.lambda.core.Loadable
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.graphics.texture.TextureUtils
+import com.lambda.module.modules.client.Network.cdn
 import com.lambda.network.api.v1.endpoints.getCape
+import com.lambda.network.api.v1.endpoints.getCapes
 import com.lambda.network.api.v1.endpoints.setCape
 import com.lambda.sound.SoundManager.toIdentifier
 import com.lambda.threading.runIO
+import com.lambda.threading.runSafe
+import com.lambda.util.FileUtils.createIfNotExists
+import com.lambda.util.FileUtils.downloadCompare
 import com.lambda.util.FileUtils.downloadIfNotPresent
+import com.lambda.util.FileUtils.ifNotExists
+import com.lambda.util.FileUtils.isOlderThan
 import com.lambda.util.FolderRegister.capes
 import com.lambda.util.extension.resolveFile
+import kotlinx.coroutines.runBlocking
 import net.minecraft.client.texture.NativeImage.read
 import net.minecraft.client.texture.NativeImageBackedTexture
+import java.util.LinkedList
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
+import kotlin.concurrent.fixedRateTimer
 import kotlin.io.path.extension
 import kotlin.io.path.inputStream
 import kotlin.io.path.nameWithoutExtension
 import kotlin.io.path.walk
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.seconds
 
 @Suppress("JavaIoSerializableObjectMustHaveReadResolve")
 object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
-    /**
-     * We want to cache images to reduce cloudflare requests and save money
-     */
+    // We want to cache images to reduce class B requests
     private val images = capes.walk()
         .filter { it.extension == "png" }
         .associate { it.nameWithoutExtension to NativeImageBackedTexture(read(it.inputStream())) }
         .onEach { (key, value) -> mc.textureManager.registerTexture(key.toIdentifier(), value) }
 
+    private val fetchQueue = LinkedList<UUID>()
+
+    // We want to cache the cape list to reduce class B requests
+    val capeList = runBlocking {
+        capes.resolveFile("capes.txt")
+            .isOlderThan(24.hours) {
+                it.downloadIfNotPresent("$cdn/capes.txt")
+                    .onFailure { err -> LOG.error("Could not download the cape list: $err") }
+            }
+            .ifNotExists {
+                it.downloadCompare("$cdn/capes.txt", -1)
+                    .onFailure { err -> LOG.error("Could not download the cape list: $err") }
+            }
+            .createIfNotExists()
+            .readText()
+            .split("\n")
+    }
+
     /**
      * Sets the current player's cape
      *
      * @param block Lambda called once the coroutine completes, it contains the throwable if any
      */
     fun updateCape(cape: String, block: (Throwable?) -> Unit = {}) = runIO {
         setCape(cape).getOrThrow()
+
+        runSafe { fetchCape(player.uuid) }
     }.invokeOnCompletion { block(it) }
 
     /**
@@ -75,11 +106,24 @@ object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
         put(uuid, cape.id)
     }.invokeOnCompletion { block(it) }
 
-    override fun load() = "Loaded ${images.size} cached capes"
+    override fun load() = "Loaded ${images.size} cached capes and ${capeList.size} remote capes"
 
     init {
-        listen<WorldEvent.Player.Join>(alwaysListen = true) {
-            fetchCape(it.uuid)
+        fixedRateTimer(
+            daemon = true,
+            name = "Cape-fetcher",
+            period = 15.seconds.inWholeMilliseconds,
+        ) {
+            if (fetchQueue.isEmpty()) return@fixedRateTimer
+
+            runBlocking {
+                getCapes(fetchQueue)
+                    .onSuccess { it.forEach { cape -> put(cape.uuid, cape.id) } }
+
+                fetchQueue.clear()
+            }
         }
+
+        listen<WorldEvent.Player.Join>(alwaysListen = true) { fetchQueue.push(it.uuid) }
     }
 }

common/src/main/kotlin/com/lambda/network/NetworkManager.kt

@@ -24,6 +24,7 @@ import com.lambda.config.configurations.UserConfig
 import com.lambda.core.Loadable
 import com.lambda.network.api.v1.models.Authentication
 import com.lambda.network.api.v1.models.Authentication.Data
+import com.lambda.util.FolderRegister.capes
 import com.lambda.util.reflections.getResources
 import java.io.File
 import java.util.*
@@ -52,11 +53,6 @@ object NetworkManager : Configurable(UserConfig), Loadable {
 
     private var deserialized: Data? = null
 
-    // ToDo: Fetch remote file instead of checking local files
-    val capes = getResources(".*.png")
-        .filter { it.contains("capes") } // filterByInput hangs the program
-        .map { File(it).nameWithoutExtension }
-
     fun updateToken(resp: Authentication) {
         accessToken = resp.accessToken
         decodeAuth(accessToken)
@@ -67,11 +63,8 @@ object NetworkManager : Configurable(UserConfig), Loadable {
         deserialized = gson.fromJson(String(Base64.getUrlDecoder().decode(payload)), Data::class.java)
     }
 
-    override fun load(): String {
-        decodeAuth(accessToken)
-
-        // ToDo: Re-authenticate every 24 hours
 
-        return "Loaded ${capes.size} capes"
+    init {
+        decodeAuth(accessToken)
     }
 }

common/src/main/kotlin/com/lambda/network/api/v1/endpoints/GetCapes.kt

@@ -1,6 +1,5 @@
 package com.lambda.network.api.v1.endpoints
 
-import com.lambda.module.modules.client.Network
 import com.lambda.module.modules.client.Network.apiUrl
 import com.lambda.module.modules.client.Network.apiVersion
 import com.lambda.network.LambdaHttp
@@ -20,7 +19,7 @@ import java.util.*
  *
  * @return results of capes
  */
-suspend fun getCapes(vararg uuid: UUID) = getCapes(uuid.toSet())
+suspend fun getCapes(vararg uuid: UUID) = getCapes(uuid.toList())
 
 /**
  * Gets the cape of the given player UUIDs
@@ -32,7 +31,7 @@ suspend fun getCapes(vararg uuid: UUID) = getCapes(uuid.toSet())
  *
  * @return results of capes
  */
-suspend fun getCapes(uuids: Set<UUID>) = runCatching {
+suspend fun getCapes(uuids: List<UUID>) = runCatching {
     LambdaHttp.get("$apiUrl/api/$apiVersion/capes") {
         contentType(ContentType.Application.Json)
         setBody("""{ "players": [${uuids.joinToString(prefix = "\"", postfix = "\"", separator = "\",\"")}] }""")

common/src/main/kotlin/com/lambda/network/api/v1/models/Cape.kt

@@ -24,11 +24,13 @@ import java.util.UUID
 
 class Cape(
     @SerializedName("uuid")
-    val uuid: String,
+    val uuid: UUID,
 
     @SerializedName("type")
     val id: String,
 ) {
     val url: String
         get() = "https://cdn.lambda-client.org/$id.png"
+
+    override fun toString() = "Cape(uuid=$uuid, id=$id, url=$url)"
 }

common/src/main/kotlin/com/lambda/util/FileUtils.kt

@@ -64,7 +64,7 @@ object FileUtils {
     /**
      * Executes the [block] if the file is older than the given [duration]
      */
-    fun File.isOlderThan(duration: Duration, block: (File) -> Unit) =
+    inline fun File.isOlderThan(duration: Duration, block: (File) -> Unit) =
         ifExists { if (duration.inWholeMilliseconds < System.currentTimeMillis() - lastModified()) block(this) }
 
     /**
@@ -89,7 +89,7 @@ object FileUtils {
      *
      * @param block Lambda executed if the file doesn't exist or the file is empty
      */
-    inline fun File.createIfNotExists(block: (File) -> Unit): File {
+    inline fun File.createIfNotExists(block: (File) -> Unit = {}): File {
         if (length() == 0L) {
             parentFile.mkdirs()
             createNewFile()