GH-2028 Move to Javalin 6.0 (Resolve #2028)

dzikoysk · Feb 4, 2024 · 8b32336 · 8b32336
1 parent 12c4736
commit 8b32336
Show file tree

Hide file tree

Showing 15 changed files with 199 additions and 255 deletions.
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-rc-1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/reposilite-backend/build.gradle.kts b/reposilite-backend/build.gradle.kts
@@ -43,15 +43,17 @@ dependencies {
     implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin")
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin")
 
-    val javalin = "5.6.3"
+    val javalin = "6.0.1"
     api("io.javalin:javalin:$javalin")
-    api("io.javalin.community.ssl:ssl-plugin:$javalin")
 
-    val javalinOpenApi = "5.6.3-2"
+    val javalinSsl = "6.0.1"
+    api("io.javalin.community.ssl:ssl-plugin:$javalinSsl")
+
+    val javalinOpenApi = "6.0.1"
     api("io.javalin.community.openapi:javalin-openapi-plugin:$javalinOpenApi")
     kapt("io.javalin.community.openapi:openapi-annotation-processor:$javalinOpenApi")
 
-    val javalinRouting = "5.6.2-RC.1"
+    val javalinRouting = "6.0.1"
     api("io.javalin.community.routing:routing-dsl:$javalinRouting")
 
     val bcrypt = "0.10.2"

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/console/application/ConsolePlugin.kt b/reposilite-backend/src/main/kotlin/com/reposilite/console/application/ConsolePlugin.kt
@@ -63,16 +63,18 @@ internal class ConsolePlugin : ReposilitePlugin() {
         }
 
         event { event: HttpServerInitializationEvent ->
-            event.javalin.ws(
-                "/api/console/sock",
-                CliEndpoint(
-                    journalist = reposilite().journalist,
-                    accessTokenFacade = facade(),
-                    authenticationFacade = facade(),
-                    consoleFacade = consoleFacade,
-                    forwardedIp = sharedConfigurationFacade.getDomainSettings<WebSettings>().computed { it.forwardedIp }
+            event.config.router.mount {
+                it.ws(
+                    "/api/console/sock",
+                    CliEndpoint(
+                        journalist = reposilite().journalist,
+                        accessTokenFacade = facade(),
+                        authenticationFacade = facade(),
+                        consoleFacade = consoleFacade,
+                        forwardedIp = sharedConfigurationFacade.getDomainSettings<WebSettings>().computed { it.forwardedIp }
+                    )
                 )
-            )
+            }
         }
 
         if (!parameters().testEnv) {

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/frontend/application/FrontendPlugin.kt b/reposilite-backend/src/main/kotlin/com/reposilite/frontend/application/FrontendPlugin.kt
@@ -79,8 +79,10 @@ internal class FrontendPlugin : ReposilitePlugin() {
         }
 
         event { event: HttpServerInitializationEvent ->
-            event.javalin.exception(NotFoundResponse::class.java, NotFoundHandler(frontendFacade))
-            event.javalin.error(404, NotFoundHandler(frontendFacade))
+            event.config.router.mount {
+                it.exception(NotFoundResponse::class.java, NotFoundHandler(frontendFacade))
+                it.error(404, NotFoundHandler(frontendFacade))
+            }
         }
 
         return frontendFacade

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/shared/extensions/NamedThreadPools.kt b/reposilite-backend/src/main/kotlin/com/reposilite/shared/extensions/NamedThreadPools.kt
@@ -38,7 +38,7 @@ open class NamedThreadFactory(private val prefix: String) : ThreadFactory {
 
 fun newFixedThreadPool(min: Int, max: Int, prefix: String): ExecutorService =
     when (LoomExtensions.isLoomAvailable()) {
-        true -> ConcurrencyUtil.executorService("$prefix (virtual) - ");
+        true -> ConcurrencyUtil.executorService("$prefix (virtual) - ", useLoom = false) // disable loom for now
         false -> ThreadPoolExecutor(
             min, max,
             0L, MILLISECONDS,

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/status/application/FailurePlugin.kt b/reposilite-backend/src/main/kotlin/com/reposilite/status/application/FailurePlugin.kt
@@ -30,7 +30,9 @@ internal class FailurePlugin : ReposilitePlugin() {
         val failureFacade = FailureComponents(this).failureFacade()
 
         event { event: HttpServerInitializationEvent ->
-            event.javalin.exception(Exception::class.java, FailureHandler(failureFacade))
+            event.config.router.mount {
+                it.exception(Exception::class.java, FailureHandler(failureFacade))
+            }
         }
 
         return failureFacade

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/web/HttpServer.kt b/reposilite-backend/src/main/kotlin/com/reposilite/web/HttpServer.kt
@@ -25,47 +25,44 @@ import com.reposilite.web.application.JavalinConfiguration
 import io.javalin.Javalin
 import io.javalin.util.ConcurrencyUtil
 import org.eclipse.jetty.io.EofException
-import org.eclipse.jetty.util.thread.ThreadPool
 
 class HttpServer {
 
-    private val servlet = false
     private var javalin: Javalin? = null
 
     fun start(reposilite: Reposilite) {
         val extensionsManagement = reposilite.extensions
         val localConfiguration = extensionsManagement.facade<LocalConfiguration>()
 
-        // Loom is enabled by default in Javalin 5.x & it's unstable on prd
-        ConcurrencyUtil.useLoom = false
-
         val webThreadPool = ConcurrencyUtil.jettyThreadPool(
             name = "Reposilite | Web (${localConfiguration.webThreadPool.get()}) -",
             minThreads = localConfiguration.webThreadPool.get(),
-            maxThreads = localConfiguration.webThreadPool.get()
+            maxThreads = localConfiguration.webThreadPool.get(),
+            useLoom = false
         )
 
-        this.javalin = createJavalin(reposilite, webThreadPool)
-            .exception(EofException::class.java) { _, _ -> reposilite.logger.warn("Client closed connection") }
-            .events { listener ->
-                listener.serverStopping { reposilite.logger.info("Server stopping...") }
-                listener.serverStopped { extensionsManagement.emitEvent(HttpServerStoppedEvent) }
+        this.javalin = Javalin.createAndStart { config ->
+            config.jetty.defaultHost = reposilite.parameters.hostname
+            config.jetty.defaultPort = reposilite.parameters.port
+
+            JavalinConfiguration.configure(reposilite, webThreadPool, config)
+
+            config.router.mount {
+                it.exception(EofException::class.java) { _, _ ->
+                    reposilite.logger.warn("Client closed connection")
+                }
             }
-            .also {
-                reposilite.extensions.emitEvent(HttpServerInitializationEvent(reposilite, it))
+
+            config.events {
+                it.serverStopping { reposilite.logger.info("Server stopping...") }
+                it.serverStopped { extensionsManagement.emitEvent(HttpServerStoppedEvent) }
             }
 
-        if (!servlet) {
-            javalin!!.start(reposilite.parameters.hostname, reposilite.parameters.port)
-            extensionsManagement.emitEvent(HttpServerStartedEvent)
+            reposilite.extensions.emitEvent(HttpServerInitializationEvent(reposilite, config))
         }
-    }
 
-    private fun createJavalin(reposilite: Reposilite, webThreadPool: ThreadPool): Javalin =
-        if (servlet)
-            Javalin.createStandalone { JavalinConfiguration.configure(reposilite, webThreadPool, it) }
-        else
-            Javalin.create { JavalinConfiguration.configure(reposilite, webThreadPool, it) }
+        extensionsManagement.emitEvent(HttpServerStartedEvent)
+    }
 
     fun stop() {
         javalin?.stop()

diff --git a/reposilite-backend/src/main/kotlin/com/reposilite/web/api/HttpServerEvents.kt b/reposilite-backend/src/main/kotlin/com/reposilite/web/api/HttpServerEvents.kt
@@ -18,12 +18,11 @@ package com.reposilite.web.api
 
 import com.reposilite.Reposilite
 import com.reposilite.plugin.api.Event
-import io.javalin.Javalin
 import io.javalin.config.JavalinConfig
 
-class HttpServerConfigurationEvent(val reposilite: Reposilite, val javalinConfig: JavalinConfig) : Event
+class HttpServerConfigurationEvent(val reposilite: Reposilite, val config: JavalinConfig) : Event
 
-class HttpServerInitializationEvent(val reposilite: Reposilite, val javalin: Javalin) : Event
+class HttpServerInitializationEvent(val reposilite: Reposilite, val config: JavalinConfig) : Event
 
 object HttpServerStartedEvent : Event