This adds a new hot experimental hot reload feature to Misk, that will

run `gradle compileKotlin --continuous` in the background, and when
classes are changed it will discard the current ClassLoader and restart
Misk.

To use the main method should call `runDevApplication`, and pass in a
method that creates the application.

This functionality is experimental, and will likely see significant
change over the coming weeks.

GitOrigin-RevId: 1dadbd4b25057a98ce65495c9fb7df1661262a8d

Author: stuartwdouglas

misk-tailwind/src/main/kotlin/misk/tailwind/TailwindHtmlLayout.kt

@@ -10,6 +10,15 @@ import kotlinx.html.script
 import kotlinx.html.title
 import misk.turbo.addHotwireHeadImports
 
+
+internal class DevMode {
+  companion object {
+    val devMode by lazy {
+      System.getProperty("misk.dev.running") == "true"
+    }
+  }
+}
+
 fun TagConsumer<*>.TailwindHtmlLayout(appRoot: String, title: String, playCdn: Boolean = false, appCssPath: String? = null, headBlock: TagConsumer<*>.() -> Unit = {}, bodyBlock: TagConsumer<*>.() -> Unit) {
   html {
     attributes["class"] = "h-full bg-white"
@@ -46,6 +55,12 @@ fun TagConsumer<*>.TailwindHtmlLayout(appRoot: String, title: String, playCdn: B
         rel = "stylesheet"
       }
       title(title)
+      if (DevMode.devMode) {
+        script {
+          type = "module"
+          src = "/static/js/refresh_dev.js"
+        }
+      }
 
       addHotwireHeadImports(appRoot)
       headBlock()

misk-tailwind/src/main/resources/web/static/js/refresh_dev.js

@@ -0,0 +1,51 @@
+// Endpoint polling and auto-refresh script. This is only used with live reload enabled.
+// When the liveness endpoint is not reachable, it will wait for the server to come back online and refresh the page.
+(function() {
+    // Configuration
+    const POLL_ENDPOINT = '/_liveness'; // Change this to your backend endpoint
+    const POLL_INTERVAL = 300;
+
+    let isServerDown = false;
+    let pollInterval;
+
+    // Function to check if the server is alive
+    async function checkServerStatus() {
+        try {
+            const response = await fetch(POLL_ENDPOINT, {
+                method: 'GET',
+                cache: 'no-cache',
+                // Short timeout to quickly detect connection issues
+                signal: AbortSignal.timeout(5000)
+            });
+
+            // If we get here, the server responded
+            if (isServerDown) {
+                // Server was down but is now back up
+                console.log('Server is back online! Refreshing page...');
+                clearInterval(pollInterval);
+                setTimeout(() => {
+                    window.location.reload();
+                }, 500); // Small delay before refresh
+            }
+
+            // Reset retry count on successful connection
+            retryCount = 0;
+
+        } catch (error) {
+            // Check if it's a connection error (server is down)
+            if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+                if (!isServerDown) {
+                    console.log('Server connection lost. Waiting for it to come back...');
+                    isServerDown = true;
+                }
+            }
+        }
+    }
+
+    // Start polling
+    console.log('Starting server status monitoring...');
+    pollInterval = setInterval(checkServerStatus, POLL_INTERVAL);
+
+    // Also check immediately
+    checkServerStatus();
+})();

misk/api/misk.api

@@ -795,6 +795,11 @@ public final class misk/concurrent/ExplicitReleaseDelayQueue : java/util/concurr
 	public fun toArray ([Ljava/lang/Object;)[Ljava/lang/Object;
 }
 
+public final class misk/dev/DevApplicationKt {
+	public static final fun isRunningDevApplication ()Z
+	public static final fun runDevApplication (Lkotlin/reflect/KFunction;)V
+}
+
 public final class misk/environment/DeploymentModule : misk/inject/KAbstractModule {
 	public fun <init> ()V
 	public fun <init> (Lwisp/deployment/Deployment;)V

misk/src/main/kotlin/misk/MiskApplication.kt

@@ -12,6 +12,9 @@ import misk.inject.getInstance
 import misk.web.jetty.JettyHealthService
 import misk.web.jetty.JettyService
 import wisp.logging.getLogger
+import java.io.Closeable
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
 import kotlin.concurrent.thread
 import kotlin.system.measureTimeMillis
 import kotlin.time.Duration.Companion.milliseconds
@@ -60,7 +63,6 @@ class MiskApplication private constructor(
    *
    * If no command line arguments are specified, the service starts and blocks until terminated.
    */
-  @VisibleForTesting
   internal fun doRun(args: Array<String>) {
     if (args.isEmpty()) {
       startServiceAndAwaitTermination()
@@ -79,7 +81,7 @@ class MiskApplication private constructor(
             binder().requireAtInjectOnConstructors()
           }
         },
-        *command.modules.toTypedArray()
+        *command.modules.toTypedArray(),
       )
 
       injector.injectMembers(command)
@@ -101,18 +103,36 @@ class MiskApplication private constructor(
    * exiting the process.
    */
   @VisibleForTesting
-  internal lateinit var shutdownHook : Thread
+  internal lateinit var shutdownHook: Thread
 
   /**
    * Provides internal testing the ability to get instances this used by the application.
    */
   @VisibleForTesting
-  internal lateinit var injector : Injector
+  internal lateinit var injector: Injector
 
-  private fun startServiceAndAwaitTermination() {
+  internal fun start(): RunningMiskApplication {
     log.info { "creating application injector" }
     injector = injectorGenerator()
     val serviceManager = injector.getInstance<ServiceManager>()
+
+
+    // We manage JettyHealthService outside ServiceManager because it must start and
+    // shutdown last to keep the container alive via liveness checks.
+    val jettyHealthService: JettyHealthService
+    measureTimeMillis {
+      log.info { "starting services" }
+      serviceManager.startAsync()
+      serviceManager.awaitHealthy()
+
+      // Start Health Service Last to ensure any dependencies are started.
+      jettyHealthService = injector.getInstance<JettyHealthService>()
+      jettyHealthService.startAsync()
+      jettyHealthService.awaitRunning()
+    }.also {
+      log.info { "all services started successfully in ${it.milliseconds}" }
+    }
+
     shutdownHook = thread(start = false) {
       measureTimeMillis {
         log.info { "received a shutdown hook! performing an orderly shutdown" }
@@ -135,29 +155,40 @@ class MiskApplication private constructor(
         log.info { "orderly shutdown complete in ${it.milliseconds}" }
       }
     }
+    val shutdown: RunningMiskApplication = object : RunningMiskApplication {
+      override fun stop() {
+        shutdownHook.start()
+      }
 
-    Runtime.getRuntime().addShutdownHook(shutdownHook)
-
-    // We manage JettyHealthService outside ServiceManager because it must start and
-    // shutdown last to keep the container alive via liveness checks.
+      override fun awaitTerminated() {
+        serviceManager.awaitStopped()
+        jettyHealthService.awaitTerminated()
+        log.info { "all services stopped" }
+      }
 
-    val jettyHealthService: JettyHealthService
-    measureTimeMillis {
-      log.info { "starting services" }
-      serviceManager.startAsync()
-      serviceManager.awaitHealthy()
+      override fun awaitTerminated(time : Long, timeUnit: TimeUnit) : Boolean{
+        val deadline : Long = timeUnit.toMillis(time) + System.currentTimeMillis()
+        try {
+          serviceManager.awaitStopped(time, timeUnit)
+          jettyHealthService.awaitTerminated(deadline - System.currentTimeMillis(), TimeUnit.MILLISECONDS)
+        } catch (_ : TimeoutException) {
+          return false
+        }
+        log.info { "all services stopped" }
+        return true
+      }
 
-      // Start Health Service Last to ensure any dependencies are started.
-      jettyHealthService = injector.getInstance<JettyHealthService>()
-      jettyHealthService.startAsync()
-      jettyHealthService.awaitRunning()
-    }.also {
-      log.info { "all services started successfully in ${it.milliseconds}" }
+      override fun app(): MiskApplication {
+        return this@MiskApplication
+      }
     }
+    return shutdown
+  }
 
-    serviceManager.awaitStopped()
-    jettyHealthService.awaitTerminated()
-    log.info { "all services stopped" }
+  private fun startServiceAndAwaitTermination() {
+    val app = start()
+    Runtime.getRuntime().addShutdownHook(shutdownHook)
+    app.awaitTerminated()
   }
 
   private companion object {
@@ -166,3 +197,13 @@ class MiskApplication private constructor(
 
   internal class CliException(message: String) : RuntimeException(message)
 }
+
+
+internal interface RunningMiskApplication {
+  fun stop()
+
+  fun awaitTerminated()
+
+  fun app() : MiskApplication
+  fun awaitTerminated(i: Long, seconds: TimeUnit): Boolean
+}

misk/src/main/kotlin/misk/client/GrpcClientProvider.kt

@@ -128,7 +128,7 @@ internal class GrpcClientProvider<T : Service, G : T>(
 
     return kclass.cast(
       Proxy.newProxyInstance(
-        ClassLoader.getSystemClassLoader(),
+        Thread.currentThread().contextClassLoader,
         arrayOf(kclass.java),
         invocationHandler
       )

misk/src/main/kotlin/misk/client/TypedHttpClientModule.kt

@@ -235,7 +235,7 @@ class TypedClientFactory @Inject constructor() {
 
     return kclass.cast(
       Proxy.newProxyInstance(
-        ClassLoader.getSystemClassLoader(),
+        kclass.java.classLoader,
         arrayOf(kclass.java),
         invocationHandler
       )

misk/src/main/kotlin/misk/dev/DevApplication.kt

@@ -0,0 +1,68 @@
+package misk.dev
+
+import misk.MiskApplication
+import misk.RunningMiskApplication
+import misk.web.actions.javaMethod
+import java.lang.reflect.Method
+import kotlin.reflect.KFunction
+
+internal class DevApplicationState {
+  companion object {
+     @Volatile
+     var isRunning = false
+  }
+}
+
+@misk.annotation.ExperimentalMiskApi
+fun isRunningDevApplication(): Boolean {
+  return DevApplicationState.isRunning
+}
+
+@misk.annotation.ExperimentalMiskApi
+fun runDevApplication(modules : KFunction<MiskApplication>) {
+  DevApplicationState.isRunning = true
+  System.setProperty("misk.dev.running", "true") // Some code may not depend on misk-core but still need to know about dev mode
+  val lock = Object()
+  var restart = false
+
+  runGradleAsyncCompile({
+    synchronized(lock) {
+      restart = true
+      lock.notifyAll()
+    }
+  })
+  val parent = Thread.currentThread().contextClassLoader
+  while (true) {
+    restart = false
+    val cl = DevClassLoader(parent)
+    var running: RunningMiskApplication? = null
+    try {
+      Thread.currentThread().contextClassLoader = cl
+      var javaMethod : Method? = null
+      try {
+         javaMethod = modules.javaMethod
+          ?: throw IllegalArgumentException("You cannot pass a lambda to runDevApplication, you must use a method reference")
+      } catch (e : ClassNotFoundException) {
+        throw java.lang.RuntimeException("Unable to init live reload, do you have kotlin-reflect as a dependency?",e)
+      }
+      val cls = cl.loadClass(javaMethod.declaringClass.name)!!
+
+      val app: MiskApplication = cls.getDeclaredMethod(javaMethod.name).invoke(cls) as MiskApplication
+      running = app.start()
+    } catch (e: Exception) {
+      if (e.cause is ClassNotFoundException || e.cause is NoClassDefFoundError) {
+        Thread.sleep(100)
+        continue
+      }
+      e.printStackTrace()
+    }
+    while (!restart) {
+      synchronized(lock) {
+        lock.wait()
+      }
+    }
+    running?.stop()
+
+  }
+
+}

misk/src/main/kotlin/misk/dev/DevClassLoader.kt

@@ -0,0 +1,63 @@
+package misk.dev
+
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ConcurrentSkipListSet
+
+/**
+ * A class loader that allows for hot reloads. If changes are detected in underlying class files this class loader
+ * can be discarded and a new instance created.
+ */
+internal class DevClassLoader(parent: ClassLoader) : ClassLoader(parent) {
+
+  // Map from class name to last modified time
+  private val classFiles: MutableMap<String, Long> = ConcurrentHashMap()
+  private val classRoots: MutableSet<String> = ConcurrentSkipListSet()
+
+  companion object {
+    init {
+      registerAsParallelCapable()
+    }
+  }
+
+  override fun loadClass(className: String, resolve: Boolean): Class<*>? {
+    val existing = findLoadedClass(className)
+    if (existing != null) return existing
+    val classPath = className.replace('.', '/') + ".class"
+    val uri = parent.getResource(classPath)
+    if (uri == null) {
+      return super.loadClass(className, resolve)
+    }
+    if (uri.protocol != "file") {
+      return super.loadClass(className, resolve)
+    }
+
+    val file = File(uri.toURI())
+    val root = file.absolutePath.substringBeforeLast(classPath)
+    synchronized(classRoots) {
+      // We want to scan for all class files eagerly
+      // If there is a problem on startup they might not be loaded
+      // And we still want to restart if they are changed
+      if (classRoots.add(root)) {
+        scanForClasses(root)
+      }
+    }
+
+    val data = file.readBytes()
+    val ret = defineClass(className, data, 0, data.size)
+
+    classFiles[file.absolutePath] = file.lastModified()
+    return ret
+  }
+
+  private fun scanForClasses(root: String) {
+    val rootDir = File(root)
+    if (!rootDir.exists() || !rootDir.isDirectory) return
+
+    rootDir.walkTopDown().forEach { file ->
+      if (file.isFile && file.extension == "class") {
+        classFiles[file.absolutePath] = file.lastModified()
+      }
+    }
+  }
+}