feat(punishment): implement service for managing player punishments with enhanced operations

Author: twisti-dev

build.gradle.kts

@@ -13,7 +13,7 @@ buildscript {
 
 plugins {
     id("org.jetbrains.kotlinx.binary-compatibility-validator") version "0.17.0"
-    id("io.freefair.aspectj.post-compile-weaving") version "8.13.1"
+//    id("io.freefair.aspectj.post-compile-weaving") version "8.13.1"
     java
 }
 
@@ -30,7 +30,7 @@ allprojects {
     }
 
     apply(plugin = "java")
-    apply(plugin = "io.freefair.aspectj.post-compile-weaving")
+//    apply(plugin = "io.freefair.aspectj.post-compile-weaving")
 
     dependencies {
 //        implementation(platform("org.springframework.boot:spring-boot-dependencies:3.4.4"))

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/SurfCloudApplication.kt

@@ -3,12 +3,11 @@ package dev.slne.surf.cloud.api.common
 import org.springframework.boot.autoconfigure.AutoConfigurationExcludeFilter
 import org.springframework.boot.autoconfigure.AutoConfigurationPackage
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration
-import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration
 import org.springframework.boot.autoconfigure.domain.EntityScan
 import org.springframework.boot.context.TypeExcludeFilter
 import org.springframework.cache.annotation.EnableCaching
+import org.springframework.context.annotation.AdviceMode
 import org.springframework.context.annotation.ComponentScan
-import org.springframework.context.annotation.EnableAspectJAutoProxy
 import org.springframework.context.annotation.FilterType
 import org.springframework.scheduling.annotation.EnableAsync
 import org.springframework.scheduling.annotation.EnableScheduling
@@ -24,10 +23,10 @@ import java.lang.annotation.Inherited
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @EnableScheduling
-@EnableAsync
-@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
+@EnableAsync(mode = AdviceMode.ASPECTJ)
+//@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)
 @EntityScan
-@EnableCaching
+@EnableCaching(mode = AdviceMode.ASPECTJ)
 @AutoConfigurationPackage
 @Inherited
 @EnableAutoConfiguration

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/exposed/service/AbstractExposedDAOService.kt

@@ -8,6 +8,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import org.jetbrains.exposed.dao.Entity
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.ApplicationContext
 import kotlin.coroutines.CoroutineContext
 
 /**
@@ -23,6 +25,11 @@ abstract class AbstractExposedDAOService<K, V : Entity<*>>(
     cacheCustomizer: Caffeine<Any, Any>.() -> Unit = {},
     private val context: CoroutineContext = Dispatchers.IO
 ) {
+    @Autowired
+    lateinit var applicationContext: ApplicationContext
+
+    protected val self get() = applicationContext.getBean(javaClass)
+
     /**
      * Cache for storing loaded entities, using Caffeine with coroutine-based loading.
      */
@@ -34,7 +41,7 @@ abstract class AbstractExposedDAOService<K, V : Entity<*>>(
             val cacheContext = context + cacheName + SupervisorJob()
 
             asLoadingCache<K, V?>(CoroutineScope(cacheContext)) {
-                load(it)
+                self.load(it)
             }
         }
 
@@ -74,7 +81,7 @@ abstract class AbstractExposedDAOService<K, V : Entity<*>>(
         createIfMissing: Boolean = true,
         block: suspend V.() -> Unit
     ) {
-        val entity = cache.get(key) ?: if (createIfMissing) create(key) else null
+        val entity = cache.get(key) ?: if (createIfMissing) self.create(key) else null
         if (entity != null) {
             entity.block()
             cache.put(key, entity)

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/plugin/AdditionalStandaloneConfiguration.kt

@@ -1,33 +1,45 @@
 package dev.slne.surf.cloud.api.server.plugin
 
 import dev.slne.surf.cloud.api.server.plugin.utils.PluginUtilProxies
+import dev.slne.surf.surfapi.core.api.util.logger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.reactive.awaitFirstOrNull
 import kotlinx.coroutines.suspendCancellableCoroutine
+import org.aopalliance.aop.Advice
 import org.aspectj.lang.ProceedingJoinPoint
 import org.aspectj.lang.annotation.Around
 import org.aspectj.lang.annotation.Aspect
 import org.aspectj.lang.reflect.MethodSignature
 import org.jetbrains.exposed.spring.SpringTransactionManager
 import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
 import org.reactivestreams.Publisher
+import org.springframework.aop.aspectj.AspectJExpressionPointcut
+import org.springframework.aop.support.DefaultPointcutAdvisor
 import org.springframework.beans.factory.getBean
+import org.springframework.boot.autoconfigure.AutoConfigurationPackages
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration
 import org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration
 import org.springframework.cache.annotation.EnableCaching
 import org.springframework.context.ApplicationContext
-import org.springframework.context.annotation.AdviceMode
-import org.springframework.context.annotation.Configuration
-import org.springframework.context.annotation.Import
+import org.springframework.context.ApplicationContextAware
+import org.springframework.context.ConfigurableApplicationContext
+import org.springframework.context.annotation.*
 import org.springframework.core.KotlinDetector
 import org.springframework.core.Ordered
+import org.springframework.core.PriorityOrdered
 import org.springframework.core.annotation.AnnotatedElementUtils
 import org.springframework.core.annotation.Order
+import org.springframework.instrument.classloading.LoadTimeWeaver
+import org.springframework.instrument.classloading.SimpleThrowawayClassLoader
 import org.springframework.scheduling.annotation.EnableAsync
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.EnableTransactionManagement
+import java.lang.instrument.ClassFileTransformer
+import java.lang.instrument.Instrumentation
 import java.lang.reflect.Method
+import java.security.ProtectionDomain
+import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED
 import kotlin.coroutines.resume
@@ -37,7 +49,11 @@ import kotlin.coroutines.startCoroutine
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.RUNTIME)
 @Configuration
-@Import(CoroutineTransactionalAspect::class)
+@Import(
+    CoroutineTransactionalAspect::class,
+    LoadTimeWeavingConfiguration::class,
+    TransactionConfiguration::class
+)
 @EnableAsync(mode = AdviceMode.ASPECTJ)
 @EnableCaching(mode = AdviceMode.ASPECTJ)
 @EnableAutoConfiguration(
@@ -52,6 +68,95 @@ annotation class AdditionalStandaloneConfiguration
 @Configuration
 class TransactionConfiguration
 
+@EnableLoadTimeWeaving(aspectjWeaving = EnableLoadTimeWeaving.AspectJWeaving.ENABLED)
+@Configuration
+class LoadTimeWeavingConfiguration(context: ApplicationContext) : LoadTimeWeavingConfigurer {
+    private val allowedPrefixes = AutoConfigurationPackages.get(context)
+        .map { it.trimEnd('.') + "." }
+//        .plus(listOf("org.springframework."))
+
+    val weaver = LoadTimeWeaverImpl(
+        LoadTimeWeaverImpl.getInstrumentation(),
+        context.classLoader ?: error("Application context does not have a class loader"),
+        allowedPrefixes
+    )
+
+    override fun getLoadTimeWeaver(): LoadTimeWeaver = weaver
+
+    class LoadTimeWeaverImpl(
+        private val instrumentation: Instrumentation,
+        private val classLoader: ClassLoader,
+        private val allowedPrefixes: List<String>
+    ) : LoadTimeWeaver {
+        private val transformers = CopyOnWriteArrayList<ClassFileTransformer>()
+
+        override fun addTransformer(transformer: ClassFileTransformer) {
+            val actualTransformer =
+                FilteringClassFileTransformer(transformer, classLoader, allowedPrefixes)
+            if (transformers.addIfAbsent(actualTransformer)) {
+                instrumentation.addTransformer(actualTransformer)
+            }
+        }
+
+        override fun getInstrumentableClassLoader(): ClassLoader = classLoader
+        override fun getThrowawayClassLoader(): ClassLoader =
+            SimpleThrowawayClassLoader(classLoader)
+
+        class FilteringClassFileTransformer(
+            private val targetTransformer: ClassFileTransformer,
+            private val targetClassLoader: ClassLoader,
+            private val allowedPrefixes: List<String>
+        ) : ClassFileTransformer {
+            override fun transform(
+                loader: ClassLoader?,
+                className: String?,
+                classBeingRedefined: Class<*>?,
+                protectionDomain: ProtectionDomain?,
+                classfileBuffer: ByteArray?
+            ): ByteArray? {
+                if (loader != targetClassLoader || className == null) return null
+                val dotted = className.replace('/', '.')
+                if (allowedPrefixes.none { dotted.startsWith(it) }) {
+                    return null
+                }
+
+                return try {
+                    targetTransformer.transform(
+                        loader,
+                        className,
+                        classBeingRedefined,
+                        protectionDomain,
+                        classfileBuffer
+                    )
+                } catch (ex: Throwable) {
+                    log.atWarning()
+                        .withCause(ex)
+                        .log("LTW: skipping weaving for $dotted due to ${ex.javaClass.simpleName}: ${ex.message}")
+                    null
+                }
+            }
+        }
+
+        companion object {
+            private val log = logger()
+            private const val AGENT_CLASS =
+                "org.springframework.instrument.InstrumentationSavingAgent"
+            private val agentClass: Class<*> by lazy {
+                Class.forName(AGENT_CLASS, true, javaClass.classLoader.parent)
+            }
+            private val agentMethod by lazy {
+                agentClass.getDeclaredMethod(
+                    "getInstrumentation",
+                )
+            }
+
+            fun getInstrumentation(): Instrumentation {
+                return agentMethod.invoke(null) as Instrumentation
+            }
+        }
+
+    }
+}
 
 /**
  * **Internal** Aspect that wraps every *suspending* call annotated (directly or
@@ -90,8 +195,13 @@ class TransactionConfiguration
  */
 @Aspect
 @Component
-@Order(Ordered.LOWEST_PRECEDENCE)
-class CoroutineTransactionalAspect(private val context: ApplicationContext) {
+class CoroutineTransactionalAspect(private val context: ApplicationContext) : Advice, PriorityOrdered {
+
+    init {
+        repeat(20) {
+            println("CoroutineTransactionalAspect initialized with context: $context")
+        }
+    }
 
     /**
      * Around-advice for any method or class annotated with
@@ -182,4 +292,7 @@ class CoroutineTransactionalAspect(private val context: ApplicationContext) {
         )
     }
 
+    override fun getOrder(): Int {
+        return Ordered.LOWEST_PRECEDENCE
+    }
 }

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/plugin/CoroutineTransactional.kt

@@ -1,5 +1,6 @@
 package dev.slne.surf.cloud.api.server.plugin
 
+import kotlinx.coroutines.CoroutineScope
 import org.springframework.aot.hint.annotation.Reflective
 import java.lang.annotation.Inherited
 import kotlin.annotation.AnnotationRetention.RUNTIME
@@ -59,4 +60,13 @@ annotation class CoroutineTransactional(
         FALSE(false),
         DEFAULT(null);
     }
+
+    interface ScopeProvider {
+        /**
+         * Provides the current coroutine scope for the transaction.
+         * This is used to ensure that the transaction is suspended correctly
+         * when the coroutine yields.
+         */
+        fun getCurrentScope(): CoroutineScope
+    }
 }

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/plugin/utils/plugin-utils.kt

@@ -12,3 +12,29 @@ val currentDb
         getCallerClass()?.classLoader as? SpringPluginClassloader
             ?: error("Not in plugin classloader!")
     )
+
+fun pluginContext(classloader: SpringPluginClassloader) = classloader.context
+val context
+    get() = pluginContext(
+        getCallerClass()?.classLoader as? SpringPluginClassloader
+            ?: error("Not in plugin classloader!")
+    )
+
+val currentContext
+    get() = pluginContext(
+        getCallerClass()?.classLoader as? SpringPluginClassloader
+            ?: error("Not in plugin classloader!")
+    )
+
+fun <T> bean(clazz: Class<T>, classloader: SpringPluginClassloader): T {
+    return classloader.context.getBean(clazz)
+}
+
+fun <T> bean(clazz: Class<T>): T {
+    return bean(clazz, getCallerClass()?.classLoader as? SpringPluginClassloader
+        ?: error("Not in plugin classloader!"))
+}
+
+inline fun <reified T> bean(): T {
+    return bean(T::class.java)
+}

surf-cloud-core/surf-cloud-core-common/src/main/kotlin/dev/slne/surf/cloud/core/common/messages/MessageManager.kt

@@ -37,7 +37,7 @@ object MessageManager { // TODO: Add more messages
             this,
             "BEIM VERBINDUNGSAUFBAU IST EIN FEHLER AUFGETRETEN",
             {
-                error("Beim versuch eine Verbindung aufzubauen ist")
+                error("Beim Versuch, eine Verbindung aufzubauen, ist")
                 appendNewline()
                 error("ein unbekannter Fehler aufgetreten.")
             },
@@ -48,9 +48,9 @@ object MessageManager { // TODO: Add more messages
     val loginTimedOut = buildText {
         CommonComponents.renderDisconnectMessage(
             this,
-            "VERBINDUNG ZUR SERVER-INSTANCE WURDE GETRENNT",
+            "VERBINDUNG ZUR SERVER-INSTANZ WURDE GETRENNT",
             {
-                error("Die Verbindung zur Server-Instance wurde")
+                error("Die Verbindung zur Server-Instanz wurde")
                 appendNewline()
                 error("unerwartet getrennt.")
             },
@@ -138,7 +138,7 @@ object MessageManager { // TODO: Add more messages
                     appendNewline(3)
 
                     if (!punishment.securityBan) {
-                        spacer("Du denkst dies ist eine Fehlentscheidung?")
+                        spacer("Du denkst, dies ist eine Fehlentscheidung?")
                     }
                     appendNewline {
                         spacer("Kontaktiere den Support in unserem Discord")
@@ -199,7 +199,7 @@ object MessageManager { // TODO: Add more messages
         }
 
         object Mute {
-            val voiceMutedActionbar = buildText { error("Du bist vom Voicechat ausgeschlossen!") }
+            val voiceMutedActionbar = buildText { error("Du bist vom Voice-Chat ausgeschlossen!") }
 
             operator fun invoke(punishment: PunishmentMute) = MuteComponentBuilder(punishment)
 

surf-cloud-core/surf-cloud-core-common/src/main/resources/application.properties

@@ -13,3 +13,5 @@ spring.jpa.properties.hibernate.cache.use_query_cache=true
 spring.jpa.properties.hibernate.cache.region.factory_class=jcache
 spring.jpa.properties.hibernate.javax.cache.provider=org.ehcache.jsr107.EhcacheCachingProvider
 spring.jpa.properties.hibernate.javax.cache.missing_cache_strategy=create
+
+spring.aop.proxy-target-class=false

surf-cloud-standalone-launcher/src/main/java/dev/slne/surf/cloud/launcher/LauncherAgent.java

@@ -14,6 +14,7 @@
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.regex.Pattern;
+import org.springframework.instrument.InstrumentationSavingAgent;
 
 public class LauncherAgent {
   private static Instrumentation instrumentation;
@@ -24,7 +25,7 @@ public static void agentmain(String agentArgs, Instrumentation inst) {
 
   public static void premain(String agentArgs, Instrumentation inst) {
     System.out.println("Launcher-Agent started. Loading actual agent...");
-//    InstrumentationSavingAgent.premain(agentArgs, inst);
+    InstrumentationSavingAgent.premain(agentArgs, inst);
     instrumentation = inst;
 //    launchSparkHook(agentArgs, inst);
   }

surf-cloud-standalone/src/main/kotlin/dev/slne/surf/cloud/standalone/__AdditionalSpringStandaloneConfiguration.kt

@@ -4,7 +4,6 @@ import dev.slne.surf.cloud.api.server.plugin.AdditionalStandaloneConfiguration
 import dev.slne.surf.cloud.api.server.plugin.TransactionConfiguration
 import org.jetbrains.exposed.spring.autoconfigure.ExposedAutoConfiguration
 import org.springframework.boot.autoconfigure.ImportAutoConfiguration
-import org.springframework.context.annotation.EnableAspectJAutoProxy
 import org.springframework.context.annotation.Import
 
 /**
@@ -15,5 +14,5 @@ import org.springframework.context.annotation.Import
 @AdditionalStandaloneConfiguration
 @ImportAutoConfiguration(ExposedAutoConfiguration::class)
 @Import(TransactionConfiguration::class)
-@EnableAspectJAutoProxy(proxyTargetClass = true)
+//@EnableAspectJAutoProxy(proxyTargetClass = true)
 internal class __AdditionalSpringStandaloneConfiguration