fix: only spawn one runner process and shut it down properly (#1009)

### Summary of Changes

Now the runner process is fully handled by the language server. The
additional services used by the client get notified once the runner is
available and connect to it.

packages/safe-ds-lang/src/language/index.ts

@@ -1,3 +1,5 @@
+import { RPC_RUNNER_STARTED } from './runner/safe-ds-runner.js';
+
 // Services
 export type { SafeDsServices } from './safe-ds-module.js';
 export { createSafeDsServices } from './safe-ds-module.js';
@@ -17,3 +19,8 @@ export { locationToString, positionToString, rangeToString } from '../helpers/lo
 
 // Messages
 export * as messages from './runner/messages.js';
+
+// Remote procedure calls
+export const rpc = {
+    runnerStarted: RPC_RUNNER_STARTED,
+};

packages/safe-ds-lang/src/language/runner/safe-ds-runner.ts

@@ -22,6 +22,8 @@ import { SafeDsMessagingProvider } from '../lsp/safe-ds-messaging-provider.js';
 
 // Most of the functionality cannot be tested automatically as a functioning runner setup would always be required
 
+export const RPC_RUNNER_STARTED = 'runner/started';
+
 const LOWEST_SUPPORTED_VERSION = '0.8.0';
 const LOWEST_UNSUPPORTED_VERSION = '0.9.0';
 const npmVersionRange = `>=${LOWEST_SUPPORTED_VERSION} <${LOWEST_UNSUPPORTED_VERSION}`;
@@ -62,8 +64,7 @@ export class SafeDsRunner {
         this.registerMessageLoggingCallbacks();
 
         services.workspace.SettingsProvider.onRunnerCommandUpdate(async (newValue) => {
-            this.updateRunnerCommand(newValue);
-            await this.startPythonServer();
+            await this.updateRunnerCommand(newValue);
         });
 
         services.shared.lsp.Connection?.onShutdown(async () => {
@@ -117,17 +118,32 @@ export class SafeDsRunner {
             );
         }, 'runtime_error');
     }
-    /* c8 ignore stop */
+
+    async connectToPort(port: number): Promise<void> {
+        if (this.isPythonServerAvailable()) {
+            return;
+        }
+
+        this.port = port;
+        try {
+            await this.connectToWebSocket();
+        } catch (error) {
+            await this.stopPythonServer();
+        }
+    }
 
     /**
      * Change the command to start the runner process. This will not cause the runner process to restart, if it is already running.
      *
      * @param command New Runner Command.
      */
-    /* c8 ignore start */
-    public updateRunnerCommand(command: string | undefined): void {
+    public async updateRunnerCommand(command: string | undefined): Promise<void> {
         if (command) {
             this.runnerCommand = command;
+            await this.startPythonServer();
+            if (this.isPythonServerAvailable()) {
+                await this.messaging.sendNotification(RPC_RUNNER_STARTED, this.port);
+            }
         }
     }
 
@@ -136,6 +152,11 @@ export class SafeDsRunner {
      * Uses the 'safe-ds.runner.command' setting to execute the process.
      */
     public async startPythonServer(): Promise<void> {
+        if (this.isPythonServerAvailable()) {
+            this.info('As the Safe-DS Runner is currently successfully running, no attempt to start it will be made');
+            return;
+        }
+
         this.acceptsConnections = false;
         const runnerCommandParts = this.runnerCommand.split(/\s/u);
         const runnerCommand = runnerCommandParts.shift()!; // After shift, only the actual args are left

packages/safe-ds-vscode/src/extension/mainClient.ts

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import * as vscode from 'vscode';
 import type { LanguageClientOptions, ServerOptions } from 'vscode-languageclient/node.js';
 import { LanguageClient, TransportKind } from 'vscode-languageclient/node.js';
-import { ast, createSafeDsServices, getModuleMembers, messages, SafeDsServices } from '@safe-ds/lang';
+import { ast, createSafeDsServices, getModuleMembers, messages, rpc, SafeDsServices } from '@safe-ds/lang';
 import { NodeFileSystem } from 'langium/node';
 import { initializeLog, logError, logOutput, printOutputMessage } from './output.js';
 import crypto from 'crypto';
@@ -23,22 +23,25 @@ let lastSuccessfulPipelineNode: ast.SdsPipeline | undefined;
 // This function is called when the extension is activated.
 export const activate = async function (context: vscode.ExtensionContext) {
     initializeLog();
-    client = startLanguageClient(context);
-    const runnerCommandSetting = vscode.workspace.getConfiguration('safe-ds.runner').get<string>('command')!; // Default is set
     services = (
         await createSafeDsServices(NodeFileSystem, {
             logger: {
                 info: logOutput,
                 error: logError,
             },
-            runnerCommand: runnerCommandSetting,
             userMessageProvider: {
                 showErrorMessage: vscode.window.showErrorMessage,
             },
         })
     ).SafeDs;
-    await services.runtime.Runner.startPythonServer();
-    acceptRunRequests(context);
+
+    client = createLanguageClient(context);
+    client.onNotification(rpc.runnerStarted, async (port: number) => {
+        await services.runtime.Runner.connectToPort(port);
+    });
+    await client.start();
+
+    registerVSCodeCommands(context);
 };
 
 // This function is called when the extension is deactivated.
@@ -50,7 +53,7 @@ export const deactivate = async function (): Promise<void> {
     return;
 };
 
-const startLanguageClient = function (context: vscode.ExtensionContext): LanguageClient {
+const createLanguageClient = function (context: vscode.ExtensionContext): LanguageClient {
     const serverModule = context.asAbsolutePath(path.join('dist', 'extension', 'mainServer.cjs'));
     // The debug options for the server
     // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging.
@@ -82,19 +85,8 @@ const startLanguageClient = function (context: vscode.ExtensionContext): Languag
         outputChannel: vscode.window.createOutputChannel('Safe-DS Language Client', 'log'),
     };
 
-    // Create the language client and start the client.
-    const result = new LanguageClient('safe-ds', 'Safe-DS', serverOptions, clientOptions);
-
-    // Start the client. This will also launch the server
-    result.start();
-    return result;
-};
-
-const acceptRunRequests = async function (context: vscode.ExtensionContext) {
-    // Register VS Code Entry Points
-    registerVSCodeCommands(context);
-    // Register watchers
-    registerVSCodeWatchers();
+    // Create the language client
+    return new LanguageClient('safe-ds', 'Safe-DS', serverOptions, clientOptions);
 };
 
 const registerVSCodeCommands = function (context: vscode.ExtensionContext) {
@@ -420,25 +412,6 @@ const validateDocuments = async function (
     return undefined;
 };
 
-const registerVSCodeWatchers = function () {
-    vscode.workspace.onDidChangeConfiguration((event) => {
-        if (event.affectsConfiguration('safe-ds.runner.command')) {
-            // Try starting runner
-            logOutput('Safe-DS Runner Command was updated');
-            services.runtime.Runner.updateRunnerCommand(
-                vscode.workspace.getConfiguration('safe-ds.runner').get<string>('command')!,
-            );
-            if (!services.runtime.Runner.isPythonServerAvailable()) {
-                services.runtime.Runner.startPythonServer();
-            } else {
-                logOutput(
-                    'As the Safe-DS Runner is currently successfully running, no attempt to start it will be made',
-                );
-            }
-        }
-    });
-};
-
 const isRangeEqual = function (lhs: Range, rhs: Range): boolean {
     return (
         lhs.start.character === rhs.start.character &&