Add the restarter

buildSrc/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+dependencies {
+    // Change in version catalog too
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:2.2.0-RC")
+}

buildSrc/src/main/kotlin/BotCommands-Restarter-conventions.gradle.kts

@@ -0,0 +1,37 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    kotlin("jvm")
+}
+
+group = "dev.freya02"
+version = "3.0.0-beta.2_DEV"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(24)
+    }
+
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+
+    withSourcesJar()
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+dependencies {
+    testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.10.0")
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_21
+
+        freeCompilerArgs.addAll("-Xjsr305=strict")
+    }
+}

gradle/libs.versions.toml

@@ -0,0 +1,16 @@
+[versions]
+kotlin = "2.2.0-RC" # Also change in buildSrc
+botcommands = "3.0.0-beta.2_DEV"
+jda = "5.5.1"
+mockk = "1.13.16"
+bytebuddy = "1.17.5"
+logback-classic = "1.5.18"
+kotlin-logging = "7.0.3"
+
+[libraries]
+botcommands = { module = "io.github.freya022:BotCommands", version.ref = "botcommands" }
+jda = { module = "net.dv8tion:JDA", version.ref = "jda" }
+mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
+bytebuddy = { module = "net.bytebuddy:byte-buddy", version.ref = "bytebuddy" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback-classic" }
+kotlin-logging = { module = "io.github.oshai:kotlin-logging-jvm", version.ref = "kotlin-logging" }

restarter-jda-cache/build.gradle.kts

@@ -0,0 +1,55 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("BotCommands-Restarter-conventions")
+    `maven-publish`
+}
+
+repositories {
+    maven("https://jitpack.io")
+}
+
+dependencies {
+    implementation(libs.kotlin.logging)
+    implementation(libs.botcommands)
+
+    testImplementation(libs.mockk)
+    testImplementation(libs.bytebuddy)
+    testImplementation(libs.logback.classic)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_24
+    targetCompatibility = JavaVersion.VERSION_24
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_24
+        freeCompilerArgs.add("-Xcontext-parameters")
+    }
+}
+
+val jar by tasks.getting(Jar::class) {
+    manifest {
+        attributes(
+            "Premain-Class" to "dev.freya02.botcommands.restart.jda.cache.Agent",
+        )
+    }
+}
+
+tasks.withType<Test> {
+    useJUnitPlatform()
+
+    jvmArgs("-javaagent:${jar.archiveFile.get().asFile.absolutePath}")
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            from(components["java"])
+
+            artifactId = "BotCommands-Restarter-JDA-Cache"
+        }
+    }
+}

restarter-jda-cache/src/main/kotlin/dev/freya02/botcommands/restart/jda/cache/Agent.kt

@@ -0,0 +1,18 @@
+package dev.freya02.botcommands.restart.jda.cache
+
+import dev.freya02.botcommands.restart.jda.cache.transformer.BContextImplTransformer
+import dev.freya02.botcommands.restart.jda.cache.transformer.JDABuilderTransformer
+import dev.freya02.botcommands.restart.jda.cache.transformer.JDAImplTransformer
+import dev.freya02.botcommands.restart.jda.cache.transformer.JDAServiceTransformer
+import java.lang.instrument.Instrumentation
+
+object Agent {
+
+    @JvmStatic
+    fun premain(agentArgs: String?, inst: Instrumentation) {
+        inst.addTransformer(JDABuilderTransformer)
+        inst.addTransformer(JDAServiceTransformer)
+        inst.addTransformer(BContextImplTransformer)
+        inst.addTransformer(JDAImplTransformer)
+    }
+}

restarter-jda-cache/src/main/kotlin/dev/freya02/botcommands/restart/jda/cache/BufferingEventManager.kt

@@ -0,0 +1,67 @@
+package dev.freya02.botcommands.restart.jda.cache
+
+import net.dv8tion.jda.api.events.GenericEvent
+import net.dv8tion.jda.api.hooks.IEventManager
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+internal class BufferingEventManager @DynamicCall constructor(
+    delegate: IEventManager,
+) : IEventManager {
+
+    private val lock = ReentrantLock()
+    private val eventBuffer: MutableList<GenericEvent> = arrayListOf()
+
+    private var delegate: IEventManager? = delegate
+
+    internal fun setDelegate(delegate: IEventManager) {
+        lock.withLock {
+            check(delegate !is BufferingEventManager) {
+                "Tried to delegate to a BufferingEventManager!"
+            }
+
+            this.delegate = delegate
+            eventBuffer.forEach(::handle)
+        }
+    }
+
+    internal fun detach() {
+        lock.withLock {
+            delegate = null
+        }
+    }
+
+    override fun register(listener: Any) {
+        lock.withLock {
+            val delegate = delegate ?: error("Should not happen, implement a listener queue if necessary")
+            delegate.register(listener)
+        }
+    }
+
+    override fun unregister(listener: Any) {
+        lock.withLock {
+            val delegate = delegate ?: error("Should not happen, implement a listener queue if necessary")
+            delegate.unregister(listener)
+        }
+    }
+
+    override fun handle(event: GenericEvent) {
+        val delegate = lock.withLock {
+            val delegate = delegate
+            if (delegate == null) {
+                eventBuffer += event
+                return
+            }
+            delegate
+        }
+
+        delegate.handle(event)
+    }
+
+    override fun getRegisteredListeners(): List<Any?> {
+        lock.withLock {
+            val delegate = delegate ?: error("Should not happen, implement a listener queue if necessary")
+            return delegate.registeredListeners
+        }
+    }
+}

restarter-jda-cache/src/main/kotlin/dev/freya02/botcommands/restart/jda/cache/DynamicCall.kt

@@ -0,0 +1,10 @@
+package dev.freya02.botcommands.restart.jda.cache
+
+/**
+ * This member is used by generated code and as such is not directly referenced.
+ *
+ * This member must be `public`.
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
+internal annotation class DynamicCall

restarter-jda-cache/src/main/kotlin/dev/freya02/botcommands/restart/jda/cache/JDABuilderConfiguration.kt

@@ -0,0 +1,130 @@
+package dev.freya02.botcommands.restart.jda.cache
+
+import io.github.freya022.botcommands.api.core.utils.enumSetOf
+import io.github.freya022.botcommands.api.core.utils.enumSetOfAll
+import io.github.oshai.kotlinlogging.KotlinLogging
+import net.dv8tion.jda.api.OnlineStatus
+import net.dv8tion.jda.api.entities.Activity
+import net.dv8tion.jda.api.hooks.IEventManager
+import net.dv8tion.jda.api.hooks.InterfacedEventManager
+import net.dv8tion.jda.api.utils.ChunkingFilter
+import net.dv8tion.jda.api.utils.MemberCachePolicy
+import net.dv8tion.jda.api.utils.cache.CacheFlag
+import java.util.*
+
+private val logger = KotlinLogging.logger { }
+
+class JDABuilderConfiguration internal constructor() {
+
+    private val warnedUnsupportedValues: MutableSet<String> = hashSetOf()
+
+    var hasUnsupportedValues = false
+        private set
+
+    private val builderValues: MutableMap<ValueType, Any?> = hashMapOf()
+    private var _eventManager: IEventManager? = null
+    val eventManager: IEventManager get() = _eventManager ?: InterfacedEventManager()
+
+    // So we can track the initial token and intents, the constructor will be instrumented and call this method
+    // The user overriding the values using token/intent setters should not be an issue
+    @DynamicCall
+    fun onInit(token: String?, intents: Int) {
+        builderValues[ValueType.TOKEN] = token
+        builderValues[ValueType.INTENTS] = intents
+        builderValues[ValueType.CACHE_FLAGS] = enumSetOfAll<CacheFlag>()
+    }
+
+    @DynamicCall
+    fun markUnsupportedValue(signature: String) {
+        if (warnedUnsupportedValues.add(signature))
+            logger.warn { "Unsupported JDABuilder method '$signature', JDA will not be cached between restarts" }
+        hasUnsupportedValues = true
+    }
+
+    @DynamicCall
+    fun setStatus(status: OnlineStatus) {
+        builderValues[ValueType.STATUS] = status
+    }
+
+    @DynamicCall
+    fun setEventManager(eventManager: IEventManager?) {
+        _eventManager = eventManager
+    }
+
+    @DynamicCall
+    fun setEventPassthrough(enable: Boolean) {
+        builderValues[ValueType.EVENT_PASSTHROUGH] = enable
+    }
+
+    @DynamicCall
+    @Suppress("UNCHECKED_CAST")
+    fun enableCache(first: CacheFlag, vararg others: CacheFlag) {
+        (builderValues[ValueType.CACHE_FLAGS] as EnumSet<CacheFlag>) += enumSetOf(first, *others)
+    }
+
+    @DynamicCall
+    @Suppress("UNCHECKED_CAST")
+    fun enableCache(flags: Collection<CacheFlag>) {
+        (builderValues[ValueType.CACHE_FLAGS] as EnumSet<CacheFlag>) += flags
+    }
+
+    @DynamicCall
+    @Suppress("UNCHECKED_CAST")
+    fun disableCache(first: CacheFlag, vararg others: CacheFlag) {
+        (builderValues[ValueType.CACHE_FLAGS] as EnumSet<CacheFlag>) -= enumSetOf(first, *others)
+    }
+
+    @DynamicCall
+    @Suppress("UNCHECKED_CAST")
+    fun disableCache(flags: Collection<CacheFlag>) {
+        (builderValues[ValueType.CACHE_FLAGS] as EnumSet<CacheFlag>) -= flags
+    }
+
+    @DynamicCall
+    fun setMemberCachePolicy(memberCachePolicy: MemberCachePolicy?) {
+        builderValues[ValueType.MEMBER_CACHE_POLICY] = memberCachePolicy
+    }
+
+    @DynamicCall
+    fun setChunkingFilter(filter: ChunkingFilter?) {
+        builderValues[ValueType.CHUNKING_FILTER] = filter
+    }
+
+    @DynamicCall
+    fun setLargeThreshold(threshold: Int) {
+        builderValues[ValueType.LARGE_THRESHOLD] = threshold
+    }
+
+    @DynamicCall
+    fun setActivity(activity: Activity?) {
+        builderValues[ValueType.ACTIVITY] = activity
+    }
+
+    @DynamicCall
+    fun setEnableShutdownHook(enable: Boolean) {
+        builderValues[ValueType.ENABLE_SHUTDOWN_HOOK] = enable
+    }
+
+    internal infix fun isSameAs(other: JDABuilderConfiguration): Boolean {
+        if (hasUnsupportedValues) return false
+        if (other.hasUnsupportedValues) return false
+
+        return builderValues == other.builderValues
+    }
+
+    private enum class ValueType {
+        TOKEN,
+        INTENTS,
+        STATUS,
+        EVENT_PASSTHROUGH,
+        CACHE_FLAGS,
+        // These two are interfaces, it's fine to compare them by equality,
+        // their reference will be the same as they are from the app class loader,
+        // so if two runs uses MemberCachePolicy#VOICE, it'll still be compatible
+        MEMBER_CACHE_POLICY,
+        CHUNKING_FILTER,
+        LARGE_THRESHOLD,
+        ACTIVITY,
+        ENABLE_SHUTDOWN_HOOK,
+    }
+}