python server

2025-07-15 22:11:41 +02:00
parent 12ed7ff2bc
commit 9febcebddb
23 changed files with 900 additions and 256 deletions
@@ -14,43 +14,105 @@ import {
    diagnosticHandler,
    tclDocumentSymbolProvider
 } from "./common/handlers"
-import * as path from "path"
+import { registerLogger, traceError, traceLog, traceVerbose } from "./common/log/logging"
+import {
+    checkVersion,
+    getInterpreterDetails,
+    initializePython,
+    onDidChangePythonInterpreter,
+    resolveInterpreter
+} from "./common/python"
+import { restartServer } from "./common/server"
+import { checkIfConfigurationChanged, getInterpreterFromSetting } from "./common/settings"
+import { loadServerDefaults } from "./common/setup"
+import { getLSClientTraceLevel } from "./common/utilities"
+import { createOutputChannel, onDidChangeConfiguration, registerCommand } from "./common/vscodeapi"

 let client: LanguageClient

-export function activate(context: vscode.ExtensionContext) {
-    // The server is implemented in node
-    const serverModule = context.asAbsolutePath(path.join("out", "server", "src", "server.js"))
-    console.log(context.asAbsolutePath(path.join("server", "src", "server.js")))
-    // If the extension is launched in debug mode then the debug server options are used
-    // Otherwise the run options are used
-    const serverOptions: ServerOptions = {
-        run: { module: serverModule, transport: TransportKind.ipc },
-        debug: {
-            module: serverModule,
-            transport: TransportKind.ipc
-        }
-    }
-    // Options to control the language client
-    const clientOptions: LanguageClientOptions = {
-        // Register the server for plain text documents
-        documentSelector: [{ scheme: "file", language: "tcl" }],
-        synchronize: {
-            // Notify the server about file changes to '.clientrc files contained in the workspace
-            fileEvents: vscode.workspace.createFileSystemWatcher("**/.clientrc")
-        }
+export async function activate(context: vscode.ExtensionContext) {
+    // This is required to get server name and module. This should be
+    // the first thing that we do in this extension.
+    const serverInfo = loadServerDefaults()
+    const serverName = serverInfo.name
+    const serverId = serverInfo.module
+
+    // Setup logging
+    const outputChannel = createOutputChannel(serverName)
+    context.subscriptions.push(outputChannel, registerLogger(outputChannel))
+
+    const changeLogLevel = async (c: vscode.LogLevel, g: vscode.LogLevel) => {
+        const level = getLSClientTraceLevel(c, g)
+        await client?.setTrace(level)
    }

-    // Create the language client and start the client.
-    client = new LanguageClient(
-        "languageServerExample",
-        "Language Server Example",
-        serverOptions,
-        clientOptions
+    context.subscriptions.push(
+        outputChannel.onDidChangeLogLevel(async (e) => {
+            await changeLogLevel(e, vscode.env.logLevel)
+        }),
+        vscode.env.onDidChangeLogLevel(async (e) => {
+            await changeLogLevel(outputChannel.logLevel, e)
+        })
    )

-    // Start the client. This will also launch the server
-    client.start()
+    // Log Server information
+    traceLog(`Name: ${serverInfo.name}`)
+    traceLog(`Module: ${serverInfo.module}`)
+    traceVerbose(`Full Server Info: ${JSON.stringify(serverInfo)}`)
+
+    const runServer = async () => {
+        const interpreter = getInterpreterFromSetting(serverId)
+        if (interpreter && interpreter.length > 0) {
+            if (checkVersion(await resolveInterpreter(interpreter))) {
+                traceVerbose(
+                    `Using interpreter from ${serverInfo.module}.interpreter: ${interpreter.join(" ")}`
+                )
+                client = await restartServer(serverId, serverName, outputChannel, client)
+            }
+            return
+        }
+
+        const interpreterDetails = await getInterpreterDetails()
+        if (interpreterDetails.path) {
+            traceVerbose(
+                `Using interpreter from Python extension: ${interpreterDetails.path.join(" ")}`
+            )
+            client = await restartServer(serverId, serverName, outputChannel, client)
+            return
+        }
+
+        traceError(
+            "Python interpreter missing:\r\n" +
+                "[Option 1] Select python interpreter using the ms-python.python.\r\n" +
+                `[Option 2] Set an interpreter using "${serverId}.interpreter" setting.\r\n` +
+                "Please use Python 3.8 or greater."
+        )
+    }
+
+    context.subscriptions.push(
+        onDidChangePythonInterpreter(async () => {
+            await runServer()
+        }),
+        onDidChangeConfiguration(async (e: vscode.ConfigurationChangeEvent) => {
+            if (checkIfConfigurationChanged(e, serverId)) {
+                await runServer()
+            }
+        }),
+        registerCommand(`${serverId}.restart`, async () => {
+            await runServer()
+        })
+    )
+
+    setImmediate(async () => {
+        const interpreter = getInterpreterFromSetting(serverId)
+        if (interpreter === undefined || interpreter.length === 0) {
+            traceLog(`Python extension loading`)
+            await initializePython(context.subscriptions)
+            traceLog(`Python extension loaded`)
+        } else {
+            await runServer()
+        }
+    })

    //
    const formatCdlProvider = vscode.languages.registerDocumentFormattingEditProvider(