Add JARs path detection for Kotlin Notebook plugin

Author: ileasile

build-plugin/src/build/InstallTasksConfigurator.kt

@@ -18,11 +18,10 @@ class InstallTasksConfigurator(
         project.tasks.register<Copy>(COPY_RUN_KERNEL_PY_TASK) {
             group = LOCAL_INSTALL_GROUP
             dependsOn(makeTaskName(settings.cleanInstallDirTaskPrefix, true))
-            from(settings.runKernelDir.resolve(settings.runKernelPy))
-            from(settings.distributionDir.resolve(settings.kotlinKernelModule)) {
-                into(settings.kotlinKernelModule)
-            }
+            moduleFromDistributionDir(settings.runKotlinKernelModule)
+            moduleFromDistributionDir(settings.kotlinKernelModule)
             into(settings.localInstallDir)
+            from(settings.distributionDir.resolve(settings.localRunPy))
         }
 
         project.tasks.register<Copy>(COPY_NB_EXTENSION_TASK) {
@@ -49,21 +48,21 @@ class InstallTasksConfigurator(
             dependsOn(cleanDirTask, updateLibrariesTask)
             group = groupName
             from(settings.librariesDir)
-            into(mainInstallPath.resolve(settings.librariesDir))
+            into(mainInstallPath.librariesDir)
         }
 
         project.tasks.register<Copy>(makeTaskName(settings.installLibsTaskPrefix, local)) {
             dependsOn(cleanDirTask)
             group = groupName
             from(project.configurations["deploy"])
-            into(mainInstallPath.resolve(settings.jarsPath))
+            into(mainInstallPath.localJarsDir)
         }
 
         project.tasks.register<Copy>(makeTaskName(settings.installKernelTaskPrefix, local)) {
             dependsOn(cleanDirTask, shadowJar)
             group = groupName
             from(shadowJar.get().outputs)
-            into(mainInstallPath.resolve(settings.jarsPath))
+            into(mainInstallPath.localJarsDir)
         }
 
         listOf(true, false).forEach { debug ->
@@ -72,8 +71,16 @@ class InstallTasksConfigurator(
         }
     }
 
-    private fun registerTaskForSpecs(debug: Boolean, local: Boolean, group: String, cleanDir: TaskProvider<*>, shadowJar: TaskProvider<*>, specPath: File, mainInstallPath: File): String {
-        val taskName = makeTaskName(if (debug) "createDebugSpecs" else "createSpecs", local)
+    private fun registerTaskForSpecs(
+        debug: Boolean,
+        local: Boolean,
+        group: String,
+        cleanDir: TaskProvider<*>,
+        shadowJar: TaskProvider<*>,
+        specPath: File,
+        mainInstallPath: File
+    ): String {
+        val taskName = makeTaskName("create${debugStr(debug)}Specs", local)
         project.tasks.register(taskName) {
             this.group = group
             dependsOn(cleanDir, shadowJar)
@@ -82,8 +89,8 @@ class InstallTasksConfigurator(
 
                 val libsCp = project.files(project.configurations["deploy"]).files.map { it.name }
 
-                makeDirs(mainInstallPath.resolve(settings.jarsPath))
-                makeDirs(mainInstallPath.resolve(settings.configDir))
+                makeDirs(mainInstallPath.localJarsDir)
+                makeDirs(mainInstallPath.configDir)
                 makeDirs(specPath)
 
                 writeJson(
@@ -93,7 +100,7 @@ class InstallTasksConfigurator(
                         "classPath" to libsCp,
                         "debuggerConfig" to if (debug) settings.debuggerConfig else ""
                     ),
-                    mainInstallPath.resolve(settings.jarArgsFile)
+                    mainInstallPath.jarArgsFile
                 )
                 makeKernelSpec(specPath, local)
             }
@@ -103,7 +110,7 @@ class InstallTasksConfigurator(
 
     private fun registerMainInstallTask(debug: Boolean, local: Boolean, group: String, specsTaskName: String) {
         val taskNamePrefix = if (local) "install" else "prepare"
-        val taskNameMiddle = if (debug) "Debug" else ""
+        val taskNameMiddle = debugStr(debug)
         val taskNameSuffix = if (local) "" else "Package"
         val taskName = "$taskNamePrefix$taskNameMiddle$taskNameSuffix"
 
@@ -121,24 +128,21 @@ class InstallTasksConfigurator(
     }
 
     private fun makeKernelSpec(installPath: File, localInstall: Boolean) {
-        val argv = if (localInstall) {
-            listOf(
-                "python",
-                installPath.resolve(settings.runKernelPy).toString(),
-                "{connection_file}",
-                installPath.resolve(settings.jarArgsFile).toString(),
-                installPath.toString()
-            )
-        } else {
-            listOf("python", "-m", "run_kotlin_kernel", "{connection_file}")
-        }
+        val firstArg = if (localInstall) installPath.resolve(settings.localRunPy).toString() else "-m"
+        fun execPythonArgs(vararg args: String) = listOf("python", firstArg, *args)
+
+        val argv = execPythonArgs(settings.runKotlinKernelModule, "{connection_file}")
+        val jarsPathDetectorArgv = execPythonArgs(settings.kotlinKernelModule, "detect-jars-location")
 
         writeJson(
             mapOf(
                 "display_name" to "Kotlin",
                 "language" to "kotlin",
                 "interrupt_mode" to "message",
-                "argv" to argv
+                "argv" to argv,
+                "metadata" to mapOf(
+                    "jar_path_detect_command" to jarsPathDetectorArgv,
+                ),
             ),
             installPath.resolve(settings.kernelFile)
         )
@@ -148,4 +152,17 @@ class InstallTasksConfigurator(
             into(installPath)
         }
     }
+
+    private val File.localJarsDir get() = resolve(settings.runKotlinKernelModule).resolve(settings.jarsPath)
+    private val File.librariesDir get() = resolve(settings.runKotlinKernelModule).resolve(settings.librariesDir)
+    private val File.configDir get() = resolve(settings.runKotlinKernelModule).resolve(settings.configDir)
+    private val File.jarArgsFile get() = resolve(settings.runKotlinKernelModule).resolve(settings.jarArgsFile)
+
+    private fun debugStr(isDebug: Boolean) = if (isDebug) "Debug" else ""
+
+    private fun Copy.moduleFromDistributionDir(moduleName: String) {
+        from(settings.distributionDir.resolve(moduleName)) {
+            into(moduleName)
+        }
+    }
 }

build-plugin/src/build/KernelBuildConfigurator.kt

@@ -83,7 +83,7 @@ internal class KernelBuildConfigurator(private val project: Project) {
 
         /****** Distribution ******/
         registerDistributionTasks()
-        installTasksConfigurator.registerInstallTasks(false, settings.distribKernelDir, settings.runKernelDir)
+        installTasksConfigurator.registerInstallTasks(false, settings.distribKernelDir, settings.distribBuildDir)
         registerPythonPackageTasks()
         registerAggregateUploadTasks()
 

build-plugin/src/build/RootSettingsExtension.kt

@@ -73,7 +73,6 @@ class RootSettingsExtension(
     val resourcesDir: File = project.file("resources")
     val distribBuildDir: File = project.buildDir.resolve("distrib-build")
     val distribKernelDir: File = distribBuildDir.resolve("kernel")
-    val runKernelDir: File = distribBuildDir.resolve("run_kotlin_kernel")
     val logosDir: File = resourcesDir.resolve("logos")
     val nbExtensionDir: File = resourcesDir.resolve("notebook-extension")
     val distributionDir: File = project.file("distrib")
@@ -83,10 +82,11 @@ class RootSettingsExtension(
     val jarsPath: String = "jars"
     val configDir: String = "config"
     val jarArgsFile: String = "$configDir/jar_args.json"
-    val runKernelPy: String = "run_kernel.py"
+    val runKotlinKernelModule = "run_kotlin_kernel"
     val kotlinKernelModule: String = "kotlin_kernel"
     val kernelFile: String = "kernel.json"
     val setupPy: String = "setup.py"
+    val localRunPy: String = "local_run.py"
 
     val installKernelTaskPrefix: String = "installKernel"
     val cleanInstallDirTaskPrefix: String = "cleanInstallDir"

distrib/kotlin_kernel/__main__.py

@@ -1,17 +1,39 @@
-from kotlin_kernel.install_user import install_user
+from typing import Dict, List
+from typing import Callable
+
 from kotlin_kernel.add_kernel import add_kernel
+from kotlin_kernel.detect_jars_location import detect_jars_location
+from kotlin_kernel.install_user import install_user
 
 import sys
 
-if __name__ == "__main__":
-    if len(sys.argv) == 2 and sys.argv[1] == "fix-kernelspec-location":
-        install_user()
-    elif len(sys.argv) >= 2 and sys.argv[1] == "add-kernel":
-        add_kernel()
+commands: Dict[str, Callable[[List[str]], None]] = {
+    "add-kernel": lambda x: add_kernel(x),
+    "detect-jars-location": lambda x: detect_jars_location(),
+    "fix-kernelspec-location": lambda x: install_user(),
+}
+
+
+def show_help(args):
+    if len(args) < 2:
+        print("Must specify a command", file=sys.stderr)
     else:
-        if len(sys.argv) < 2:
-            print("Must specify a command", file=sys.stderr)
+        commands_str = ", ".join(commands.keys())
+        print("Unknown command " + args[1] + ", known commands: " + commands_str + ".",
+              file=sys.stderr)
+    exit(1)
+
+
+def main(args):
+    if len(args) >= 2:
+        command = args[1]
+        if command in commands:
+            commands[command](args)
         else:
-            print("Unknown command " + sys.argv[1] + ", known commands are fix-kernelspec-location and add-kernel.",
-                  file=sys.stderr)
-        exit(1)
+            show_help(args)
+    else:
+        show_help(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv)

distrib/kotlin_kernel/add_kernel.py

@@ -11,7 +11,7 @@
 from kotlin_kernel.install_user import install_base_kernel
 
 
-def add_kernel():
+def add_kernel(sys_args):
     parser = argparse.ArgumentParser(
         prog="add-kernel",
         description="Add a kernel with specified JDK, JVM args, and environment",
@@ -31,11 +31,11 @@ def add_kernel():
     parser.add_argument("--force", action="store_true", default=False,
                         help="Overwrite an existing kernel with the same name.")
 
-    if len(sys.argv) == 2:
+    if len(sys_args) == 2:
         parser.print_usage()
         exit(0)
 
-    args = parser.parse_args(sys.argv[2:])
+    args = parser.parse_args(sys_args[2:])
 
     jdk = args.jdk
     if jdk is not None:

distrib/kotlin_kernel/detect_jars_location.py

@@ -0,0 +1,14 @@
+import os
+from typing import AnyStr
+
+from run_kotlin_kernel.run_kernel import module_install_path
+
+
+def detect_jars_location() -> None:
+    run_kernel_path = module_install_path()
+    jars_dir: AnyStr = os.path.join(run_kernel_path, "jars")
+    print(str(jars_dir))
+
+
+if __name__ == "__main__":
+    detect_jars_location()

distrib/local_run.py

@@ -0,0 +1,17 @@
+import sys
+
+import kotlin_kernel.__main__
+import run_kotlin_kernel.__main__
+
+
+def main():
+    module_name = sys.argv[1]
+    args = sys.argv[1:]
+    if module_name == "kotlin_kernel":
+        kotlin_kernel.__main__.main(args)
+    elif module_name == "run_kotlin_kernel":
+        run_kotlin_kernel.__main__.main(args)
+
+
+if __name__ == "__main__":
+    main()

distrib/run_kotlin_kernel/__main__.py

@@ -1,5 +1,11 @@
-from sys import argv
+import sys
+
 from run_kotlin_kernel.run_kernel import run_kernel
 
+
+def main(args):
+    run_kernel(*(args[1:]))
+
+
 if __name__ == "__main__":
-    run_kernel(*(argv[1:]))
+    main(sys.argv)

distrib/run_kotlin_kernel/run_kernel.py

@@ -3,7 +3,7 @@
 import shlex
 import subprocess
 import sys
-from typing import List
+from typing import List, AnyStr
 
 from kotlin_kernel import env_names
 
@@ -16,10 +16,16 @@ def run_kernel(*args) -> None:
         try:
             sys.exit(130)
         except SystemExit:
-            # noinspection PyProtectedMember
+            # noinspection PyProtectedMember,PyUnresolvedReferences
             os._exit(130)
 
 
+def module_install_path() -> str:
+    abspath: AnyStr = os.path.abspath(__file__)
+    current_dir: AnyStr = os.path.dirname(abspath)
+    return str(current_dir)
+
+
 def run_kernel_impl(connection_file: str, jar_args_file: str = None, executables_dir: str = None) -> None:
     abspath = os.path.abspath(__file__)
     current_dir = os.path.dirname(abspath)