v4.2.7 RC

v4.2.7 RC

Author: NovaFox161

build.gradle.kts

@@ -1,4 +1,5 @@
 import org.gradle.api.tasks.wrapper.Wrapper.DistributionType.ALL
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -27,7 +28,7 @@ buildscript {
 allprojects {
     //Project props
     group = "org.dreamexposure.discal"
-    version = "4.2.6"
+    version = "4.2.7"
     description = "DisCal"
 
     //Plugins
@@ -50,6 +51,7 @@ allprojects {
     val googleServicesCalendarVersion: String by properties
     val googleOauthClientVersion: String by properties
     // Various libs
+    val okhttpVersion: String by properties
     val copyDownVersion: String by properties
     val jsoupVersion: String by properties
 
@@ -88,7 +90,7 @@ allprojects {
         implementation("org.springframework.boot:spring-boot-starter-actuator")
 
         // Database
-        implementation("io.asyncer:r2dbc-mysql")
+        implementation("io.asyncer:r2dbc-mysql:1.3.0") // TODO: Remove hard coded version once spring includes this in bom as it is a breaking change
         implementation("com.mysql:mysql-connector-j")
 
         // Serialization
@@ -101,6 +103,7 @@ allprojects {
         implementation("ch.qos.logback.contrib:logback-json-classic:$logbackContribVersion")
         implementation("ch.qos.logback.contrib:logback-jackson:$logbackContribVersion")
         implementation("io.micrometer:micrometer-registry-prometheus")
+        implementation("io.projectreactor:reactor-core-micrometer")
 
         // Google libs
         implementation("com.google.api-client:google-api-client:$googleApiClientVersion")
@@ -111,6 +114,7 @@ allprojects {
 
         // Various Libs
         implementation("com.squareup.okhttp3:okhttp")
+        implementation("com.squareup.okhttp3:okhttp-coroutines:$okhttpVersion")
         implementation("io.github.furstenheim:copy_down:$copyDownVersion")
         implementation("org.jsoup:jsoup:$jsoupVersion")
     }
@@ -135,9 +139,9 @@ allprojects {
 subprojects {
     tasks {
         withType<KotlinCompile> {
-            kotlinOptions {
-                freeCompilerArgs = listOf("-Xjsr305=strict")
-                jvmTarget = java.targetCompatibility.majorVersion
+            compilerOptions {
+                freeCompilerArgs.set(listOf("-Xjsr305=strict"))
+                jvmTarget.set(JvmTarget.fromTarget(java.targetCompatibility.majorVersion))
             }
         }
     }
@@ -146,7 +150,7 @@ subprojects {
 tasks {
     wrapper {
         distributionType = ALL
-        gradleVersion = "8.2.1"
+        gradleVersion = "8.10.2"
     }
 
     bootJar {

cam/src/main/kotlin/org/dreamexposure/discal/cam/Cam.kt

@@ -27,7 +27,7 @@ class Cam {
                         .run(*args)
                 LOGGER.info(GlobalVal.STATUS, "CAM is now online")
             } catch (e: Exception) {
-                LOGGER.error(GlobalVal.DEFAULT, "'Spring error' by PANIC! at the CAM")
+                LOGGER.error(GlobalVal.DEFAULT, "'Spring error' by PANIC! at the CAM", e)
                 exitProcess(4)
             }
         }

cam/src/main/kotlin/org/dreamexposure/discal/cam/business/cronjob/HeartbeatCronJob.kt

@@ -12,7 +12,7 @@ import org.dreamexposure.discal.core.logger.LOGGER
 import org.dreamexposure.discal.core.`object`.network.discal.InstanceData
 import org.dreamexposure.discal.core.`object`.rest.HeartbeatRequest
 import org.dreamexposure.discal.core.`object`.rest.HeartbeatType
-import org.dreamexposure.discal.core.utils.GlobalVal
+import org.dreamexposure.discal.core.utils.GlobalVal.DEFAULT
 import org.dreamexposure.discal.core.utils.GlobalVal.JSON
 import org.springframework.boot.ApplicationArguments
 import org.springframework.boot.ApplicationRunner
@@ -31,26 +31,30 @@ class HeartbeatCronJob(
     override fun run(args: ApplicationArguments?) {
         Flux.interval(Config.HEARTBEAT_INTERVAL.getLong().asSeconds())
             .flatMap { heartbeat() }
-            .doOnError {  LOGGER.error(GlobalVal.DEFAULT, "[Heartbeat] Failed to heartbeat", it) }
+            .doOnError {  LOGGER.error(DEFAULT, "[Heartbeat] Failed to heartbeat", it) }
             .onErrorResume { Mono.empty() }
             .subscribe()
     }
 
     private fun heartbeat() = mono {
-        val requestBody = HeartbeatRequest(HeartbeatType.CAM, instanceData = InstanceData())
+        try {
+            val requestBody = HeartbeatRequest(HeartbeatType.CAM, instanceData = InstanceData())
 
-        val request = Request.Builder()
-            .url("$apiUrl/v3/status/heartbeat")
-            .post(objectMapper.writeValueAsString(requestBody).toRequestBody(JSON))
-            .header("Authorization", "Int ${Config.SECRET_DISCAL_API_KEY.getString()}")
-            .header("Content-Type", "application/json")
-            .build()
+            val request = Request.Builder()
+                .url("$apiUrl/v3/status/heartbeat")
+                .post(objectMapper.writeValueAsString(requestBody).toRequestBody(JSON))
+                .header("Authorization", "Int ${Config.SECRET_DISCAL_API_KEY.getString()}")
+                .header("Content-Type", "application/json")
+                .build()
 
-        Mono.fromCallable(httpClient.newCall(request)::execute)
-            .map(Response::close)
-            .subscribeOn(Schedulers.boundedElastic())
-            .doOnError { LOGGER.error(GlobalVal.DEFAULT, "[Heartbeat] Failed to heartbeat", it) }
-            .onErrorResume { Mono.empty() }
-            .subscribe()
+            Mono.fromCallable(httpClient.newCall(request)::execute)
+                .map(Response::close)
+                .subscribeOn(Schedulers.boundedElastic())
+                .doOnError { LOGGER.error(DEFAULT, "[Heartbeat] Failed to heartbeat", it) }
+                .onErrorResume { Mono.empty() }
+                .subscribe()
+        } catch (ex: Exception) {
+            LOGGER.error(DEFAULT, "[Heartbeat] Failed to heartbeat", ex)
+        }
     }
 }

cam/src/main/kotlin/org/dreamexposure/discal/cam/business/google/GoogleAuthService.kt

@@ -0,0 +1,52 @@
+package org.dreamexposure.discal.cam.business.google
+
+import org.dreamexposure.discal.core.business.CalendarService
+import org.dreamexposure.discal.core.business.CredentialService
+import org.dreamexposure.discal.core.business.google.GoogleAuthApiWrapper
+import org.dreamexposure.discal.core.exceptions.EmptyNotAllowedException
+import org.dreamexposure.discal.core.exceptions.NotFoundException
+import org.dreamexposure.discal.core.extensions.isExpiredTtl
+import org.dreamexposure.discal.core.logger.LOGGER
+import org.dreamexposure.discal.core.`object`.new.CalendarMetadata
+import org.dreamexposure.discal.core.`object`.new.model.discal.cam.TokenV1Model
+import org.springframework.stereotype.Component
+import java.time.Duration
+import java.time.Instant
+
+@Component
+class GoogleAuthService(
+    private val credentialService: CredentialService,
+    private val calendarService: CalendarService,
+    private val googleAuthApiWrapper: GoogleAuthApiWrapper,
+) {
+    suspend fun requestNewAccessToken(calendar: CalendarMetadata): TokenV1Model? {
+        if (!calendar.secrets.expiresAt.isExpiredTtl()) return TokenV1Model(calendar.secrets.accessToken, calendar.secrets.expiresAt)
+
+        LOGGER.debug("Refreshing access token | guildId:{} | calendar:{}", calendar.guildId, calendar.number)
+
+        val refreshed = googleAuthApiWrapper.refreshAccessToken(calendar.secrets.refreshToken).entity ?: return null
+        calendar.secrets.accessToken = refreshed.accessToken
+        calendar.secrets.expiresAt = Instant.now().plusSeconds(refreshed.expiresIn.toLong()).minus(Duration.ofMinutes(5)) // Add some wiggle room
+        calendarService.updateCalendarMetadata(calendar)
+
+        LOGGER.debug("Refreshed access token | guildId:{} | calendar:{}, validUntil:{}", calendar.guildId, calendar.number, calendar.external)
+
+        return TokenV1Model(calendar.secrets.accessToken, calendar.secrets.expiresAt)
+    }
+
+    suspend fun requestNewAccessToken(credentialId: Int): TokenV1Model {
+        val credential = credentialService.getCredential(credentialId) ?: throw NotFoundException()
+        if (!credential.expiresAt.isExpiredTtl()) return TokenV1Model(credential.accessToken, credential.expiresAt)
+
+        LOGGER.debug("Refreshing access token | credentialId:$credentialId")
+
+        val refreshed = googleAuthApiWrapper.refreshAccessToken(credential.refreshToken).entity ?: throw EmptyNotAllowedException()
+        credential.accessToken = refreshed.accessToken
+        credential.expiresAt = Instant.now().plusSeconds(refreshed.expiresIn.toLong()).minus(Duration.ofMinutes(5)) // Add some wiggle room
+        credentialService.updateCredential(credential)
+
+        LOGGER.debug("Refreshed access token | credentialId:{} | validUntil:{}", credentialId, credential.expiresAt)
+
+        return TokenV1Model(credential.accessToken, credential.expiresAt)
+    }
+}

cam/src/main/kotlin/org/dreamexposure/discal/cam/controllers/v1/SecurityController.kt

@@ -2,10 +2,10 @@ package org.dreamexposure.discal.cam.controllers.v1
 
 import org.dreamexposure.discal.cam.business.SecurityService
 import org.dreamexposure.discal.core.annotations.SecurityRequirement
+import org.dreamexposure.discal.core.`object`.new.model.discal.cam.SecurityValidateV1Request
+import org.dreamexposure.discal.core.`object`.new.model.discal.cam.SecurityValidateV1Response
 import org.dreamexposure.discal.core.`object`.new.security.Scope.INTERNAL_CAM_VALIDATE_TOKEN
 import org.dreamexposure.discal.core.`object`.new.security.TokenType.INTERNAL
-import org.dreamexposure.discal.core.`object`.rest.v1.security.ValidateRequest
-import org.dreamexposure.discal.core.`object`.rest.v1.security.ValidateResponse
 import org.springframework.http.HttpStatus
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
@@ -19,13 +19,13 @@ class SecurityController(
 ) {
     @SecurityRequirement(schemas = [INTERNAL], scopes = [INTERNAL_CAM_VALIDATE_TOKEN])
     @PostMapping("/validate", produces = ["application/json"])
-    suspend fun validate(@RequestBody request: ValidateRequest): ValidateResponse {
+    suspend fun validate(@RequestBody request: SecurityValidateV1Request): SecurityValidateV1Response {
         val result = securityService.authenticateAndAuthorizeToken(
             request.token,
             request.schemas,
             request.scopes,
         )
 
-        return ValidateResponse(result.first == HttpStatus.OK, result.first, result.second)
+        return SecurityValidateV1Response(result.first == HttpStatus.OK, result.first, result.second)
     }
 }

cam/src/main/kotlin/org/dreamexposure/discal/cam/controllers/v1/TokenController.kt

@@ -4,7 +4,7 @@ import discord4j.common.util.Snowflake
 import org.dreamexposure.discal.cam.managers.CalendarAuthManager
 import org.dreamexposure.discal.core.annotations.SecurityRequirement
 import org.dreamexposure.discal.core.enums.calendar.CalendarHost
-import org.dreamexposure.discal.core.`object`.network.discal.CredentialData
+import org.dreamexposure.discal.core.`object`.new.model.discal.cam.TokenV1Model
 import org.dreamexposure.discal.core.`object`.new.security.Scope.CALENDAR_TOKEN_READ
 import org.dreamexposure.discal.core.`object`.new.security.TokenType.INTERNAL
 import org.springframework.web.bind.annotation.GetMapping
@@ -19,7 +19,7 @@ class TokenController(
 ) {
     @SecurityRequirement(schemas = [INTERNAL], scopes = [CALENDAR_TOKEN_READ])
     @GetMapping(produces = ["application/json"])
-    suspend fun getToken(@RequestParam host: CalendarHost, @RequestParam id: Int, @RequestParam guild: Snowflake?): CredentialData? {
+    suspend fun getToken(@RequestParam host: CalendarHost, @RequestParam id: Int, @RequestParam guild: Snowflake?): TokenV1Model? {
         return calendarAuthManager.getCredentialData(host, id, guild)
     }
 }