How to update changes?

[Runkang10]

I tried to reload changes but it doesn't work:

package io.github.runkang10.advancedcrash.system

import com.charleskorn.kaml.Yaml
import io.github.runkang10.advancedcrash.common.Plugin
import io.github.runkang10.advancedcrash.configurations.ConfigTemplate
import io.github.runkang10.advancedcrash.configurations.CrashTemplate
import io.github.runkang10.advancedcrash.configurations.LanguageTemplate
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.serialization.DeserializationStrategy
import kotlinx.serialization.SerializationStrategy
import kotlinx.serialization.builtins.ListSerializer
import java.io.File

class YamlLoader(plugin: Plugin) {
    private val loadMutex = Mutex()
    private val saveMutex = Mutex()

    private val defaultYaml = Yaml.default

    private val configFile = File(plugin.dataFolder, "config.yml")
    private val languageFile = File(plugin.dataFolder, "language.yml")
    private val crashListFile = File(plugin.dataFolder, "crash-list.yml")

    private val configSerializer = ConfigTemplate.serializer()
    private val languageSerializer = LanguageTemplate.serializer()
    private val crashListSerializer = ListSerializer(CrashTemplate.serializer())

    @Volatile
    private var _config: ConfigTemplate? = null

    @Volatile
    private var _language: LanguageTemplate? = null

    @Volatile
    private var _crashList: List<CrashTemplate>? = null

    val config get() = _config!!
    val language get() = _language!!
    val crashList get() = _crashList!!

    suspend fun load(config: Boolean = true, language: Boolean = true, crashList: Boolean = true) =
        loadMutex.withLock {
            if (config) {
                createIfNotPresent(configFile, configSerializer, ConfigTemplate())
                _config = loadContent(configSerializer, configFile)
            }

            if (language) {
                createIfNotPresent(languageFile, languageSerializer, LanguageTemplate())
                _language = loadContent(languageSerializer, languageFile)
            }

            if (crashList) {
                createIfNotPresent(crashListFile, crashListSerializer, listOf(CrashTemplate()))
                _crashList = loadContent(crashListSerializer, crashListFile)
            }
        }

    suspend fun save(
        config: ConfigTemplate? = null,
        language: LanguageTemplate? = null,
        crashList: List<CrashTemplate>? = null
    ) =
        saveMutex.withLock {
            if (config != null) saveCopy(configFile, configSerializer, config.copy())
            if (language != null) saveCopy(languageFile, languageSerializer, language.copy())
            if (crashList != null) saveCopy(crashListFile, crashListSerializer, crashList.toList())

            return@withLock this
        }


    private fun <T> createIfNotPresent(file: File, serializer: SerializationStrategy<T>, template: T) {
        if (!file.exists()) saveCopy(file, serializer, template)
    }

    private fun <T> loadContent(deserialization: DeserializationStrategy<T>, file: File) =
        defaultYaml.decodeFromString(deserialization, file.readText())

    private fun <T> saveCopy(file: File, serializer: SerializationStrategy<T>, copy: T) =
        file.writeText(defaultYaml.encodeToString(serializer, copy))
}

It updates once then it won't update anymore:

package io.github.runkang10.advancedcrash.tasks

import io.github.runkang10.advancedcrash.common.Plugin
import io.github.runkang10.advancedcrash.configurations.CrashTypeTemplate
import io.github.runkang10.advancedcrash.internal.enums.CoroutineTaskStatus
import io.github.runkang10.advancedcrash.internal.interfaces.CoroutineTask
import io.github.runkang10.advancedcrash.system.InternalLogger
import io.github.runkang10.advancedcrash.system.ServiceRegistry
import io.github.runkang10.advancedcrash.system.YamlLoader
import kotlinx.coroutines.*
import java.time.Instant

class GarbageCollectorTask(private val plugin: Plugin) : CoroutineTask {
    private val yamlLoader = ServiceRegistry.get(YamlLoader::class.java) as YamlLoader

    private val coroutine = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private var _status = CoroutineTaskStatus.OFF

    override fun launch() {
        _status = CoroutineTaskStatus.ON
        val garbageCollectorConfig = yamlLoader.config.tasks.garbageCollector
        val delay = garbageCollectorConfig.timeUnit.toMillis(garbageCollectorConfig.delay)

        InternalLogger.info("AdvancedCrash's Garbage Collector has been launched.")

        coroutine.launch {
            while (_status == CoroutineTaskStatus.ON) {
                purgeExpiredCrashItems()
                delay(delay)
            }

            InternalLogger.warn("AdvancedCrash's Garbage Collector has been shutdown!")
        }
    }

    override fun cancel() {
        _status = CoroutineTaskStatus.OFF
    }

    private suspend fun purgeExpiredCrashItems() {
        val now = Instant.now()
        val originalList = yamlLoader.crashList.toList().apply {
            InternalLogger.info("Original: $this")
        }

        val updatedList = yamlLoader.crashList.filter { crash ->
            if (crash.type == CrashTypeTemplate.PERM) return@filter true

            runCatching {
                Instant.parse(crash.duration).isAfter(now)
            }.getOrDefault(false)
        }.apply {
            InternalLogger.info("Updated: $this")
        }

        if (updatedList != originalList) {
            yamlLoader.save(crashList = updatedList)
            yamlLoader.load(false, false, true)
        }
    }
}

[charleskorn]

Can you please simplify the code to demonstrate exactly what the issue with Kaml is? There's a lot of code here and a lot of it has nothing to do with Kaml.

A clear description of the error or behaviour you see would be helpful as well.

[Runkang10]

Oops... My bad... The issue was @Volatile causing this. Apologize for wasting your time and thanks for your support.