feat(mps-model-server-plugin): new IDEA plugin for running the LightModelServer

slisson · slisson · commit d219a993e9fc · 2023-08-06T11:27:48.000+02:00
Currently, it's implemented in https://github.com/modelix/modelix/tree/mps/2020.3/mps/org.modelix.model.server.mpsplugin which publishes a separate version for each MPS version and has dependencies on MPS-extensions. The new plugin doesn't have any dependencies on MPS modules and there is only one version of the plugin for all MPS versions. This makes it much easier and faster to deploy changes. This is also one step towards the goal of MODELIX-177 to split the modelix/modelix repository into multiple repositories that don't have MPS version specific releases.
diff --git a/commitlint.config.js b/commitlint.config.js
@@ -16,6 +16,8 @@ module.exports = {
         "model-server",
         "model-sync-lib",
         "mps-model-adapters",
+        "mps-model-server",
+        "mps-model-server-plugin",
         "ts-model-api",
       ],
     ],
diff --git a/model-server-lib/src/main/kotlin/org/modelix/model/server/light/LightModelServer.kt b/model-server-lib/src/main/kotlin/org/modelix/model/server/light/LightModelServer.kt
@@ -21,22 +21,13 @@ import io.ktor.server.application.*
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import io.ktor.server.plugins.cors.routing.*
+import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import io.ktor.server.websocket.*
-import io.ktor.util.*
 import io.ktor.websocket.*
 import kotlinx.coroutines.*
-import org.modelix.model.api.ConceptReference
-import org.modelix.model.api.IConceptReference
-import org.modelix.model.api.INode
-import org.modelix.model.api.INodeReference
-import org.modelix.model.api.INodeReferenceSerializer
-import org.modelix.model.api.IRole
-import org.modelix.model.api.key
-import org.modelix.model.api.remove
-import org.modelix.model.api.serialize
-import org.modelix.model.api.usesRoleIds
+import org.modelix.model.api.*
 import org.modelix.model.server.api.AddNewChildNodeOpData
 import org.modelix.model.server.api.ChangeSetId
 import org.modelix.model.server.api.DeleteNodeOpData
@@ -56,10 +47,49 @@ import java.time.Duration
 import java.util.*
 import kotlin.time.Duration.Companion.seconds
 
-class LightModelServer @JvmOverloads constructor (val port: Int, val rootNode: INode, val ignoredRoles: Set<IRole> = emptySet(), additionalHealthChecks: List<IHealthCheck> = emptyList()) {
+class LightModelServerBuilder {
+    private var port: Int = 48302
+    private var rootNodeProvider: () -> INode? = { null }
+    private var ignoredRoles: Set<IRole> = emptySet()
+    private var additionalHealthChecks: List<LightModelServer.IHealthCheck> = emptyList()
+
+    fun port(port: Int): LightModelServerBuilder {
+        this.port = port
+        return this
+    }
+
+    fun rootNode(provider: () -> INode?): LightModelServerBuilder {
+        this.rootNodeProvider = provider
+        return this
+    }
+
+    fun rootNode(node: INode): LightModelServerBuilder {
+        this.rootNodeProvider = { node }
+        return this
+    }
+
+    fun ignoreRole(role: IRole): LightModelServerBuilder {
+        this.ignoredRoles += role
+        return this
+    }
+
+    fun healthCheck(check: LightModelServer.IHealthCheck): LightModelServerBuilder {
+        this.additionalHealthChecks += check
+        return this
+    }
+
+    fun build(): LightModelServer {
+        return LightModelServer(port, rootNodeProvider, ignoredRoles, additionalHealthChecks)
+    }
+}
+
+class LightModelServer @JvmOverloads constructor (val port: Int, val rootNodeProvider: () -> INode?, val ignoredRoles: Set<IRole> = emptySet(), additionalHealthChecks: List<IHealthCheck> = emptyList()) {
+    constructor (port: Int, rootNode: INode, ignoredRoles: Set<IRole> = emptySet(), additionalHealthChecks: List<IHealthCheck> = emptyList()) :
+            this(port, { rootNode}, ignoredRoles, additionalHealthChecks)
 
     companion object {
         private val LOG = mu.KotlinLogging.logger {  }
+        fun builder(): LightModelServerBuilder = LightModelServerBuilder()
     }
 
     private var server: NettyApplicationEngine? = null
@@ -70,18 +100,26 @@ class LightModelServer @JvmOverloads constructor (val port: Int, val rootNode: I
         override val enabledByDefault: Boolean = true
 
         override fun run(output: StringBuilder): Boolean {
+            val n = rootNodeProvider()
+            if (n == null) {
+                output.appendLine("root node not available yet")
+                return false
+            }
             val count = getArea().executeRead { rootNode.allChildren.count() }
             output.appendLine("root node has $count children")
             return true
         }
     }) + additionalHealthChecks
 
-    fun start() {
+    val rootNode: INode get() = rootNodeProvider() ?: throw IllegalStateException("Root node not available yet")
+
+    @JvmOverloads
+    fun start(wait: Boolean = false) {
         LOG.trace { "server starting on port $port ..." }
         server = embeddedServer(Netty, port = port) {
-            init()
+            installHandlers()
         }
-        server!!.start()
+        server!!.start(wait)
         LOG.trace { "server started" }
     }
 
@@ -116,7 +154,7 @@ class LightModelServer @JvmOverloads constructor (val port: Int, val rootNode: I
 
     private fun getArea() = rootNode.getArea()
 
-    private fun Application.init() {
+    fun Application.installHandlers() {
         install(WebSockets) {
             pingPeriod = Duration.ofSeconds(15)
             timeout = Duration.ofSeconds(15)
@@ -169,7 +207,7 @@ class LightModelServer @JvmOverloads constructor (val port: Int, val rootNode: I
                     } else {
                         call.respond(HttpStatusCode.InternalServerError, "unhealthy\n\n$output")
                     }
-                } catch (ex: Exception) {
+                } catch (ex: Throwable) {
                     output.appendLine()
                     output.appendLine(ex.stackTraceToString())
                     call.respond(HttpStatusCode.InternalServerError, "unhealthy\n\n$output")
diff --git a/mps-model-server-plugin/README.md b/mps-model-server-plugin/README.md
@@ -0,0 +1,31 @@
+To test changes during development
+add the property `mps.plugins.dir` to `~/.gradle.gradle.properties`, for example
+when using the JetBrains toolbox on Mac this would be similar to this:
+```
+mps.plugins.dir=/Users/yourUserName/Library/Application Support/JetBrains/Toolbox/apps/MPS/ch-2/211.7628.1509/MPS 2021.1.app.plugins/
+```
+
+Then run the task `installMpsPlugin` and restart MPS.
+Automatically reloading the plugin is not supported yet, 
+because failing to unloading the classes of the ktor server prevents that.
+
+Alternatively you can install the plugin manually by first running the task `buildPlugin`
+and then choosing the folder `mps-model-server/build/distributions/` in MPS.
+
+To execute a query you can create a Kotlin scratch file with the classpath
+of the module `modelql-client.jvmMain` and some code like this:
+
+```kotlin
+import kotlinx.coroutines.runBlocking
+import org.modelix.modelql.client.ModelQLClient
+import org.modelix.modelql.core.count
+import org.modelix.modelql.untyped.children
+
+val client = ModelQLClient.builder().url("http://localhost:48305/query").build()
+val result = runBlocking {
+    client.query {
+        it.children("modules").count()
+    }
+}
+println(result)
+```
diff --git a/mps-model-server-plugin/build.gradle.kts b/mps-model-server-plugin/build.gradle.kts
@@ -0,0 +1,76 @@
+plugins {
+    id("org.jetbrains.kotlin.jvm")
+    id("org.jetbrains.intellij") version "1.13.3"
+    alias(libs.plugins.ktlint)
+}
+
+dependencies {
+    implementation(project(":model-server-lib"))
+    implementation(project(":mps-model-adapters"))
+    compileOnly("com.jetbrains:mps-openapi:2021.1.4")
+    compileOnly("com.jetbrains:mps-core:2021.1.4")
+    compileOnly("com.jetbrains:mps-environment:2021.1.4")
+}
+
+// Configure Gradle IntelliJ Plugin
+// Read more: https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html
+intellij {
+
+    // IDEA platform version used in MPS 2021.1.4: https://github.com/JetBrains/MPS/blob/2021.1.4/build/version.properties#L11
+    version.set("211.7628.21")
+
+    // type.set("IC") // Target IDE Platform
+
+    // plugins.set(listOf("jetbrains.mps.core", "com.intellij.modules.mps"))
+}
+
+tasks {
+    withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+        kotlinOptions.jvmTarget = "11"
+    }
+
+    patchPluginXml {
+        sinceBuild.set("211")
+        untilBuild.set("231.*")
+    }
+
+    buildSearchableOptions {
+        enabled = false
+    }
+
+//    signPlugin {
+//        certificateChain.set(System.getenv("CERTIFICATE_CHAIN"))
+//        privateKey.set(System.getenv("PRIVATE_KEY"))
+//        password.set(System.getenv("PRIVATE_KEY_PASSWORD"))
+//    }
+//
+//    publishPlugin {
+//        token.set(System.getenv("PUBLISH_TOKEN"))
+//    }
+
+    runIde {
+        autoReloadPlugins.set(true)
+    }
+
+    val mpsPluginDir = project.findProperty("mps.plugins.dir")?.toString()?.let { file(it) }
+    if (mpsPluginDir != null && mpsPluginDir.isDirectory) {
+        create<Sync>("installMpsPlugin") {
+            dependsOn(prepareSandbox)
+            from(buildDir.resolve("idea-sandbox/plugins/mps-model-server-plugin"))
+            into(mpsPluginDir.resolve("mps-model-server-plugin"))
+        }
+    }
+}
+
+group = "org.modelix.mps"
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            artifactId = "model-server-plugin"
+            artifact(tasks.buildPlugin) {
+                extension = "zip"
+            }
+        }
+    }
+}
diff --git a/mps-model-server-plugin/src/main/kotlin/org/modelix/model/server/mps/MPSModelServer.kt b/mps-model-server-plugin/src/main/kotlin/org/modelix/model/server/mps/MPSModelServer.kt
@@ -0,0 +1,114 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.modelix.model.server.mps
+
+import com.intellij.ide.AppLifecycleListener
+import com.intellij.ide.plugins.DynamicPluginListener
+import com.intellij.ide.plugins.IdeaPluginDescriptor
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.service
+import com.intellij.openapi.project.Project
+import jetbrains.mps.project.ProjectBase
+import jetbrains.mps.project.ProjectManager
+import jetbrains.mps.smodel.MPSModuleRepository
+import org.modelix.model.api.INode
+import org.modelix.model.api.runSynchronized
+import org.modelix.model.mpsadapters.MPSRepositoryAsNode
+import org.modelix.model.server.light.LightModelServer
+
+@Service(Service.Level.APP)
+class MPSModelServer : Disposable {
+    init {
+        println("modelix server created")
+    }
+
+    private var server: LightModelServer? = null
+
+    fun ensureStarted() {
+        runSynchronized(this) {
+            if (server != null) return
+
+            println("starting modelix server")
+
+            val rootNodeProvider: () -> INode? = { MPSModuleRepository.getInstance()?.let { MPSRepositoryAsNode(it) } }
+            server = LightModelServer.builder()
+                .port(48305)
+                .rootNode(rootNodeProvider)
+                .healthCheck(object : LightModelServer.IHealthCheck {
+                    override val id: String
+                        get() = "projects"
+                    override val enabledByDefault: Boolean
+                        get() = false
+
+                    override fun run(output: StringBuilder): Boolean {
+                        val projects = ProjectManager.getInstance().openedProjects
+                        output.append("${projects.size} projects found")
+                        projects.forEach { output.append("  ${it.name}") }
+                        return ProjectManager.getInstance().openedProjects.isNotEmpty()
+                    }
+                })
+                .healthCheck(object : LightModelServer.IHealthCheck {
+                    override val id: String
+                        get() = "virtualFolders"
+                    override val enabledByDefault: Boolean
+                        get() = false
+
+                    override fun run(output: StringBuilder): Boolean {
+                        val projects = ProjectManager.getInstance().openedProjects.filterIsInstance<ProjectBase>()
+                        for (project in projects) {
+                            val modules = project.projectModules
+                            val virtualFolders = modules
+                                .mapNotNull { project.getPath(it)?.virtualFolder }
+                                .filter { it.isNotEmpty() }
+                            output.append("project ${project.name} contains ${modules.size} modules with ${virtualFolders.size} virtual folders")
+                            if (virtualFolders.isNotEmpty()) return true
+                        }
+                        return false
+                    }
+                })
+                .build()
+            server!!.start()
+        }
+    }
+
+    fun ensureStopped() {
+        runSynchronized(this) {
+            if (server == null) return
+            println("stopping modelix server")
+            server?.stop()
+            server = null
+        }
+    }
+
+    override fun dispose() {
+        ensureStopped()
+    }
+}
+
+class MPSModelServerDynamicPluginListener : DynamicPluginListener {
+    override fun pluginLoaded(pluginDescriptor: IdeaPluginDescriptor) {
+        service<MPSModelServer>().ensureStarted()
+    }
+}
+
+class MPSModelServerAppLifecycleListener : AppLifecycleListener {
+    override fun appStarting(projectFromCommandLine: Project?) {
+        service<MPSModelServer>().ensureStarted()
+    }
+
+    override fun appStarted() {
+        service<MPSModelServer>().ensureStarted()
+    }
+}
diff --git a/mps-model-server-plugin/src/main/resources/META-INF/plugin.xml b/mps-model-server-plugin/src/main/resources/META-INF/plugin.xml
@@ -0,0 +1,38 @@
+<!-- Plugin Configuration File. Read more: https://plugins.jetbrains.com/docs/intellij/plugin-configuration-file.html -->
+<idea-plugin require-restart="true">
+    <!-- Unique identifier of the plugin. It should be FQN. It cannot be changed between the plugin versions. -->
+    <id>org.modelix.model.server.mps</id>
+
+    <!-- Public plugin name should be written in Title Case.
+         Guidelines: https://plugins.jetbrains.com/docs/marketplace/plugin-overview-page.html#plugin-name -->
+    <name>MPS as Modelix Model Server</name>
+
+    <!-- A displayed Vendor name or Organization ID displayed on the Plugins Page. -->
+    <vendor email="modelix@itemis.de" url="https://modelix.org/">itemis AG</vendor>
+
+    <!-- Description of the plugin displayed on the Plugin Page and IDE Plugin Manager.
+         Simple HTML elements (text formatting, paragraphs, and lists) can be added inside of <![CDATA[ ]]> tag.
+         Guidelines: https://plugins.jetbrains.com/docs/marketplace/plugin-overview-page.html#plugin-description -->
+    <description><![CDATA[
+    Modelix compatible model server for MPS models
+  ]]></description>
+
+    <!-- Product and plugin compatibility requirements.
+         Read more: https://plugins.jetbrains.com/docs/intellij/plugin-compatibility.html -->
+    <depends>com.intellij.modules.platform</depends>
+
+    <applicationListeners>
+        <listener
+                class="org.modelix.model.server.mps.MPSModelServerDynamicPluginListener"
+                topic="com.intellij.ide.plugins.DynamicPluginListener"/>
+        <listener
+                class="org.modelix.model.server.mps.MPSModelServerAppLifecycleListener"
+                topic="com.intellij.ide.AppLifecycleListener"/>
+    </applicationListeners>
+
+    <!-- Extension points defined by the plugin.
+         Read more: https://plugins.jetbrains.com/docs/intellij/plugin-extension-points.html -->
+    <extensions defaultExtensionNs="com.intellij">
+
+    </extensions>
+</idea-plugin>
diff --git a/mps-model-server-plugin/src/main/resources/META-INF/pluginIcon.svg b/mps-model-server-plugin/src/main/resources/META-INF/pluginIcon.svg
diff --git a/settings.gradle.kts b/settings.gradle.kts
