Merge branch 'refactor' (yippieee)

Author: lolcatjpg

README.md

@@ -13,3 +13,7 @@ websockets
 - [ ] current status
 - [ ] broadcast details on mqtt
 - [ ] playlist generation based on stats ("kelder toppers" etc)
+
+## do next
+
+- fix http error handling in `Http.kt`

build.gradle

@@ -26,22 +26,28 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-actuator'
 //    implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'// management stuff
 //    runtimeOnly 'org.postgresql:postgresql'
+
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 
+
     // -- kotlin --
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     implementation "com.fasterxml.jackson.module:jackson-module-kotlin"
     implementation "org.jetbrains.kotlin:kotlin-reflect"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
 
     // -- mqtt --
     implementation "org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.5"
+    implementation "com.hivemq:hivemq-mqtt-client:1.3.12"
 
+    // -- misc --
+    implementation 'com.github.f4b6a3:uuid-creator:6.1.0'
 }
 
-tasks.named('test') {
-    useJUnitPlatform()
-}
+//tasks.named('test') {
+//    useJUnitPlatform()
+//}
 
 // https://kotlinlang.org/docs/annotations.html#all-meta-target
 kotlin {

example.env

@@ -0,0 +1,8 @@
+SPOTIFY_CLIENT_ID=ec3a2aa161a6410a8961f1eaf4b3f2be
+SPOTIFY_CLIENT_SECRET=e34e28e4d41145a5bd934cfa511e902c
+MQTT_SERVER_URL=koin
+MQTT_SERVER_PORT=1883
+MQTT_LIBRESPOT_LISTEN_TOPIC=music/events/playing
+MQTT_ZODOM_LISTEN_TOPIC=music/votes
+MQTT_PUBLISH_TOPIC=music/current_song_info_localtest
+ZODOM_API_URL=http://localhost:3000

src/main/kotlin/gent/zeus/guitar/Application.kt

@@ -1,46 +1,24 @@
 package gent.zeus.guitar
 
-import gent.zeus.guitar.mqtt.MqttEnv
-import gent.zeus.guitar.spotify.SpotifyToken
-import org.springframework.boot.CommandLineRunner
+import gent.zeus.guitar.mqtt.MqttContext
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
-import org.springframework.core.Ordered
-import org.springframework.core.annotation.Order
-import org.springframework.stereotype.Component
-import kotlin.system.exitProcess
+import kotlin.time.Duration.Companion.seconds
 
 
 @SpringBootApplication
 open class Application
 
-fun main(args: Array<String>) {
-    runApplication<Application>(*args)
-}
-
-@Component
-@Order(Ordered.HIGHEST_PRECEDENCE)
-class DoStartupChecks : CommandLineRunner {
-
-    private val checklist: List<StartupCheck> = listOf(
-        SpotifyToken,
-        MqttEnv,
-    )
+suspend fun main(args: Array<String>): Unit = coroutineScope {
+    Environment.SPOTIFY_CLIENT_ID  // access variable to make singleton object
 
-    override fun run(vararg args: String?) {
-        Logging.log.info("running startup checks...")
-
-        checklist.map { it.checkOnStartup() }.map {
-            if (!it.checkPassed) {
-                Logging.log.error(it.message)
-            }
-            it
-        }.let { checklist ->
-            if (checklist.any { !it.checkPassed }) {
-                exitProcess(1)
-            }
-        }
-
-        Logging.log.info("startup checks complete!")
+    launch {
+        delay(1.seconds)
+        MqttContext().startMqtt()
     }
+
+    runApplication<Application>(*args)
 }

src/main/kotlin/gent/zeus/guitar/Environment.kt

@@ -0,0 +1,50 @@
+package gent.zeus.guitar
+
+import kotlin.system.exitProcess
+
+/**
+ * singleton object for environment variables
+ */
+object Environment {
+    private var loadFailed = false
+
+    val SPOTIFY_CLIENT_ID = loadRequired("SPOTIFY_CLIENT_ID")
+    val SPOTIFY_CLIENT_SECRET = loadRequired("SPOTIFY_CLIENT_SECRET")
+
+    val MQTT_HOST = load("MQTT_HOST".also { notifyDisabled("mqtt", it) })
+    val MQTT_PORT = load("MQTT_PORT")
+    val MQTT_LIBRESPOT_LISTEN_TOPIC = load("MQTT_LIBRESPOT_LISTEN_TOPIC")
+    val MQTT_ZODOM_LISTEN_TOPIC = load("MQTT_ZODOM_LISTEN_TOPIC")
+    val MQTT_PUBLISH_TOPIC = load("MQTT_PUBLISH_TOPIC")
+
+    val ZODOM_API_URL = load("ZODOM_API_URL".also { notifyDisabled("zodom data", it) })
+
+    init {
+        if (loadFailed) exitProcess(1)
+    }
+
+    /**
+     * load required environment variable
+     *
+     * if it is empty/not set, print an error and (indirectly) end the application
+     *
+     * @return the value of the variable
+     */
+    private fun loadRequired(key: String): String = System.getenv(key).takeUnless { it?.isEmpty() ?: true } ?: run {
+        logger.error("environment variable $key required but not set!")
+        loadFailed = true
+        return ""
+    }
+
+    /**
+     * load a non-required environment variable
+     *
+     * @return the value of the variable, or an empty string if it is not set
+     */
+    private fun load(key: String): String = System.getenv(key).takeUnless { it?.isEmpty() ?: true } ?: ""
+
+    private fun notifyDisabled(what: String, envVariableKey: String) {
+        if (!load(envVariableKey).isEmpty()) return
+        logger.warn("$what is disabled because environment variable $envVariableKey is not set")
+    }
+}

src/main/kotlin/gent/zeus/guitar/Errors.kt

@@ -0,0 +1,83 @@
+package gent.zeus.guitar
+
+/**
+ * error generated by the application that can be returned to the user
+ *
+ * @param message message of the error
+ * @param remoteError error from the remote that caused this error
+ */
+abstract class DataFetchError(val message: String, val remoteError: String?, val httpStatusCode: Int) {
+
+    override fun toString(): String {
+        return this::class.simpleName ?: "anonymous class"
+    }
+}
+
+/**
+ * error caused by user wrongdoing
+ */
+open class UserError(message: String, remoteError: String?, httpStatusCode: Int = 400) :
+    DataFetchError(message, remoteError, httpStatusCode)
+
+/**
+ * error caused by server mishaps
+ */
+open class ServerError(message: String, remoteError: String?, httpStatusCode: Int = 500) :
+    DataFetchError(message, remoteError, httpStatusCode)
+
+class MultiError(errors: List<DataFetchError>) : DataFetchError(
+    message = errors.joinToString(
+        ", ",
+        if (errors.size > 1) "multiple errors were encountered: " else "",
+    ) { "${it.message} (${it.httpStatusCode})" },
+    remoteError = errors.joinToString(
+        "; ",
+    ) { "${it.remoteError}" },
+    httpStatusCode = when {
+        errors.any { it is UserError && it.httpStatusCode == 404 } -> 404
+        errors.any { it is UserError } -> 400
+        else -> 500
+    }
+)
+
+/**
+ * success or error when handling musical data
+ */
+sealed class DataResult<out T> {
+    data class Ok<T>(val value: T) : DataResult<T>()
+    data class Error<E : DataFetchError>(val error: E) : DataResult<Nothing>()
+}
+
+/**
+ * log all the errors in the list
+ * @param pre: bit to put before the error message
+ */
+fun <E : DataFetchError> Iterable<E>.logErrors(pre: String) = onEach {
+    logger.error("$pre ${it.message} (${it.httpStatusCode})")
+}
+
+/**
+ * tries to execute the code block. if the code throws an exception, it makes an error log statement
+ * and re-throws the exception
+ *
+ * @param messageOnFail message to put in log statement (will append ` (stacktrace below)`)
+ * @param block code block to try executing
+ */
+inline fun logExceptionFail(messageOnFail: String, block: () -> Unit) {
+    try {
+        block()
+    } catch (e: Exception) {
+        logger.error("$messageOnFail: ${e.message} (stacktrace below)")
+        throw e
+    }
+}
+
+inline fun <R> logExceptionWarn(messageOnFail: String, block: () -> R) =
+    try {
+        block()
+    } catch (e: Exception) {
+        logger.warn("$messageOnFail: ${e.message} (stacktrace below)")
+        e.printStackTrace()
+        null
+    }
+

src/main/kotlin/gent/zeus/guitar/Global.kt

@@ -1,8 +1,4 @@
 package gent.zeus.guitar
 
-import org.springframework.web.client.RestClient
 
-val REST_CLIENT: RestClient = RestClient.create()
-
-const val SPOTIFY_API_URL = "https://api.spotify.com/v1"
-const val ZODOM_API_URL = "http://localhost:3000"
+const val SPOTIFY_API_URL = "https://api.spotify.com/v1"

src/main/kotlin/gent/zeus/guitar/Http.kt

@@ -0,0 +1,35 @@
+package gent.zeus.guitar
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import org.springframework.http.HttpHeaders
+import org.springframework.http.MediaType
+import org.springframework.http.ResponseEntity
+import org.springframework.web.client.HttpClientErrorException
+import org.springframework.web.client.RestClient
+import org.springframework.web.client.body
+import org.springframework.web.client.toEntity
+
+val REST_CLIENT: RestClient = RestClient.create()
+
+inline fun <reified T : Any> httpRequestIntoObj(uri: String, bearerToken: String? = null): HttpResponse<T> =
+    try {
+        REST_CLIENT.get()
+            .uri(uri)
+            .let {
+                bearerToken ?: return@let it
+                it.header(HttpHeaders.AUTHORIZATION, "Bearer $bearerToken")
+            }
+            .accept(MediaType.APPLICATION_JSON)
+            .retrieve()
+            .body<T>().let {
+                it ?: return HttpResponse.Error(500, "response body was null")
+                return HttpResponse.Ok(200, it)
+            }
+    } catch (e: HttpClientErrorException) {
+        HttpResponse.Error(e.statusCode.value(), e.responseBodyAsString)
+    }
+
+sealed class HttpResponse<out T> {
+    data class Ok<T>(val statusCode: Int, val body: T) : HttpResponse<T>()
+    data class Error(val statusCode: Int, val body: String) : HttpResponse<Nothing>()
+}

src/main/kotlin/gent/zeus/guitar/Logging.kt

@@ -1,8 +1,7 @@
 package gent.zeus.guitar
 
-import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import org.slf4j.Logger
+
 
-object Logging {
-    val log: Logger = LoggerFactory.getLogger("GUITAR")
-}
+val logger: Logger = LoggerFactory.getLogger("guitar log")