Added debugging

Author: Stefterv

app/build.gradle.kts

@@ -128,7 +128,6 @@ dependencies {
     testImplementation(libs.junitJupiterParams)
 
     implementation(gradleApi())
-    runtimeOnly(libs.slf4j.simple)
 }
 
 tasks.test {

app/src/processing/app/Base.java

@@ -67,7 +67,7 @@ public class Base {
    */
   static public boolean DEBUG = System.getenv().containsKey("DEBUG");
 
-  static public boolean GRADLE = false;
+  static public boolean GRADLE = true;
 
   /** True if running via Commander. */
   static private boolean commandLine;

app/src/processing/app/gradle/GradleService.kt

@@ -2,6 +2,10 @@ package processing.app.gradle
 
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
+import com.sun.jdi.Bootstrap
+import com.sun.jdi.VirtualMachine
+import com.sun.jdi.VirtualMachineManager
+import com.sun.jdi.connect.AttachingConnector
 import kotlinx.coroutines.*
 import org.gradle.tooling.BuildLauncher
 import org.gradle.tooling.GradleConnector
@@ -19,12 +23,12 @@ import javax.swing.event.DocumentEvent
 import javax.swing.event.DocumentListener
 import kotlin.io.path.writeText
 
-// TODO: Embed the core, gradle plugin, and preprocessor in a custom .m2 repository
-// Right now the gradle service only works if you publish those to the local maven repository
 class GradleService(val editor: Editor) {
     val availableTasks = mutableStateListOf<String>()
     val finishedTasks = mutableStateListOf<String>()
     val running = mutableStateOf(false)
+    var vm: VirtualMachine? = null
+    val debugPort = (30000..60000).random()
 
     private var connection: ProjectConnection? = null
     private var preparation: Job? = null
@@ -35,7 +39,9 @@ class GradleService(val editor: Editor) {
 
     val folder: File get() = editor.sketch.folder
 
+
     fun prepare(){
+        Messages.log("Preparing sketch")
         if(preparing) return
         preparation?.cancel()
         preparation = CoroutineScope(Dispatchers.IO).launch {
@@ -44,60 +50,45 @@ class GradleService(val editor: Editor) {
             preparing = true
 
             connection.newSketchBuild()
-                .forTasks("build")
+                .forTasks("jar")
                 .run()
 
             preparing = false
+            Messages.log("Preparation finished")
         }
     }
 
     fun run(){
         val connection = connection ?: return
-        if(!preparing) preparation?.cancel()
+        Messages.log("Running sketch")
+        startRun {
+            connection.newSketchBuild()
+                .addDebugging()
+                .forTasks("run")
+                .withCancellationToken(cancel.token())
+                .run()
+            Messages.log("Running finished")
+        }
 
-        run?.cancel()
-        run = CoroutineScope(Dispatchers.IO).launch {
-            running.value = true
-            preparation?.join()
-            cancel.cancel()
-            cancel = GradleConnector.newCancellationTokenSource()
-            try {
-                connection.newSketchBuild()
-                    .forTasks("run")
-                    .withCancellationToken(cancel.token())
-                    .run()
-            }catch (e: Exception){
-                Messages.log(e.toString())
-            }
+    }
+
+    fun export(){
+        val connection = connection ?: return
+        Messages.log("Exporting sketch")
+        startRun {
+            connection.newSketchBuild()
+                .forTasks("runDistributable")
+                .withCancellationToken(cancel.token())
+                .run()
+            Messages.log("Exporting finished")
         }
-        run?.invokeOnCompletion { running.value = run?.isActive ?: false }
     }
 
     fun stop(){
         cancel.cancel()
     }
 
-    fun export(){
-        val connection = connection ?: return
-        if(!preparing) preparation?.cancel()
 
-        run?.cancel()
-        run = CoroutineScope(Dispatchers.IO).launch {
-            running.value = true
-            preparation?.join()
-            cancel.cancel()
-            cancel = GradleConnector.newCancellationTokenSource()
-            try {
-                connection.newSketchBuild()
-                    .forTasks("runDistributable")
-                    .withCancellationToken(cancel.token())
-                    .run()
-            }catch (e: Exception){
-                Messages.log(e.toString())
-            }
-        }
-        run?.invokeOnCompletion { running.value = run?.isActive ?: false }
-    }
 
     fun startService(){
         Messages.log("Starting Gradle service at ${folder}")
@@ -108,8 +99,6 @@ class GradleService(val editor: Editor) {
 
         // TODO: recreate connection if sketch folder changes
 
-        // TODO: Run the sketch with the latest changes
-
         SwingUtilities.invokeLater {
             editor.sketch.code.forEach {
                 it.document.addDocumentListener(object : DocumentListener {
@@ -129,11 +118,37 @@ class GradleService(val editor: Editor) {
 
             // TODO: Attach listener if new tab is created
         }
-
-        // TODO: Attach a debugger (to gradle, and the running sketch)
     }
 
+    private fun startRun(action: () -> Unit){
+        running.value = true
+        run?.cancel()
+        run = CoroutineScope(Dispatchers.IO).launch {
+            preparation?.join()
+
+            cancel.cancel()
+            cancel = GradleConnector.newCancellationTokenSource()
+            action()
+        }
+        run?.invokeOnCompletion { running.value = run?.isActive ?: false }
+    }
 
+    private fun BuildLauncher.addDebugging(): BuildLauncher{
+        this.addProgressListener(ProgressListener { event ->
+            if(event !is TaskStartEvent) return@ProgressListener
+            if(event.descriptor.name != ":run") return@ProgressListener
+
+            Messages.log("Running sketch")
+            val connector = Bootstrap.virtualMachineManager().allConnectors()
+                .firstOrNull { it.name() == "com.sun.jdi.SocketAttach" }
+                    as AttachingConnector?
+                ?: return@ProgressListener
+            val args = connector.defaultArguments()
+            args["port"]?.setValue(debugPort.toString())
+            vm = connector.attach(args)
+        })
+        return this
+    }
 
 
     private fun ProjectConnection.newSketchBuild(): BuildLauncher{
@@ -160,7 +175,8 @@ class GradleService(val editor: Editor) {
             "sketchFolder" to folder.absolutePath,
             "workingDir" to workingDir.toAbsolutePath().toString(),
             "settings" to Platform.getSettingsFolder().absolutePath.toString(),
-            "unsaved" to unsaved.joinToString(",")
+            "unsaved" to unsaved.joinToString(","),
+            "debugPort" to debugPort.toString()
         )
         val repository = Platform.getContentFile("repository").absolutePath
 
@@ -204,9 +220,13 @@ class GradleService(val editor: Editor) {
                 """.trimIndent()
             buildGradle.writeText(content)
         }
+        val settingsGradle = folder.resolve("settings.gradle.kts")
+        if(!settingsGradle.exists()) {
+            settingsGradle.createNewFile()
+        }
 
         return this.newBuild()
-            .setJavaHome(Platform.getJavaHome())
+//            .setJavaHome(Platform.getJavaHome())
             .withArguments(
                 "--init-script", initGradle.toAbsolutePath().toString(),
                 *variables.entries.map { "-Pprocessing.${it.key}=${it.value}" }.toTypedArray()

app/src/processing/app/gradle/ui/Toolbar.kt

@@ -85,7 +85,7 @@ class Toolbar(val editor: Editor) {
                 val color = LocalContentColor.current
                 Fading(visible = isRunning) {
                     CircularProgressIndicator(
-                        progress = finished.count().toFloat() / (available.count() - 1),
+                        //progress = finished.count().toFloat() / (available.count() - 1),
                         color = color
                     )
                 }

gradle/libs.versions.toml

@@ -33,8 +33,6 @@ kotlinGradlePlugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", ver
 kotlinComposePlugin = { module = "org.jetbrains.kotlin.plugin.compose:org.jetbrains.kotlin.plugin.compose.gradle.plugin", version.ref = "kotlin" }
 markdown = { module = "com.mikepenz:multiplatform-markdown-renderer-m2", version = "0.31.0" }
 markdownJVM = { module = "com.mikepenz:multiplatform-markdown-renderer-jvm", version = "0.31.0" }
-gradle-tooling-api = { module = "org.gradle:gradle-tooling-api", version = "8.12" }
-slf4j-simple = { module = "org.slf4j:slf4j-simple", version = "1.7.10" }
 
 [plugins]
 jetbrainsCompose = { id = "org.jetbrains.compose", version.ref = "compose-plugin" }

java/gradle/src/main/kotlin/ProcessingPlugin.kt

@@ -23,6 +23,7 @@ class ProcessingPlugin @Inject constructor(private val objectFactory: ObjectFact
         val processingVersion = project.findProperty("processing.version") as String? ?: "4.3.4"
         val processingGroup = project.findProperty("processing.group") as String? ?: "org.processing"
         val workingDir = project.findProperty("processing.workingDir") as String?
+        val debugPort = project.findProperty("processing.debugPort") as String?
 
         // Grab the settings from the most likely location
         var settingsFolder = (project.findProperty("processing.settings") as String?)?.let { File(it) }
@@ -111,6 +112,9 @@ class ProcessingPlugin @Inject constructor(private val objectFactory: ObjectFact
                 // Set the class to be executed initially
                 application.mainClass = sketchName
                 application.nativeDistributions.modules("java.management")
+                if(debugPort != null) {
+                    application.jvmArgs("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=$debugPort")
+                }
             }
         }