implement using free port for socket connections

Author: d-biehl

CHANGELOG.md

@@ -4,17 +4,18 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ## [Unreleased]
 
-##  0.4.0
-
 ### added
-  - Big speed improvements
-    - introduce some classes for threadsafe asyncio
-  - Implement pipe/socket transport for language server
-    - default is now pipe transport
-  - Improve starting, stopping, restarting language server client, if ie. python environment changed, arguments changed or server crashed  
+- for socket connections now a free port is used
+
+##  0.4.0
 
 ### added
 
+- Big speed improvements
+  - introduce some classes for threadsafe asyncio
+- Implement pipe/socket transport for language server
+  - default is now pipe transport
+- Improve starting, stopping, restarting language server client, if ie. python environment changed, arguments changed or server crashed  
 - some refactoring to speedup loading and parsing documents
 - semantic tokens now highlight 
   - builtin keywords

mypy.ini

@@ -4,7 +4,7 @@
 [mypy]
 python_version = 3.8
 warn_redundant_casts = True
-warn_unused_ignores = True
+warn_unused_ignores = False
 strict = True
 
 # Needed because of bug in MyPy

poetry.lock

@@ -164,9 +164,10 @@ def start_pipe(self, pipe_name: Optional[str]) -> None:
         self.mode = JsonRpcServerMode.PIPE
 
         try:
-            if sys.platform == "win32" and getattr(self.loop, "create_pipe_connection", None):
+            if sys.platform == "win32" and hasattr(self.loop, "create_pipe_connection"):
+                # this is a proactor event loop and we can use the not documented method create_pipe_connection
                 self.loop.run_until_complete(
-                    self.loop.create_pipe_connection(self.create_protocol, pipe_name)  # type: ignore
+                    self.loop.create_pipe_connection(self.create_protocol, pipe_name),  # type: ignore
                 )
             else:
                 self.loop.run_until_complete(self.loop.create_unix_connection(self.create_protocol, pipe_name))

robotcode/jsonrpc2/server.py

@@ -19,6 +19,7 @@ import {
 import { sleep, Mutex } from "./utils";
 import { CONFIG_SECTION } from "./config";
 import { PythonManager } from "./pythonmanger";
+import { getAvailablePort } from "./net_utils";
 
 const LANGUAGE_SERVER_DEFAULT_TCP_PORT = 6610;
 const LANGUAGE_SERVER_DEFAULT_HOST = "127.0.0.1";
@@ -141,7 +142,7 @@ export class LanguageClientsManager {
     return serverOptions;
   }
 
-  private getServerOptions(folder: vscode.WorkspaceFolder, mode: string) {
+  private async getServerOptions(folder: vscode.WorkspaceFolder, mode: string): Promise<ServerOptions> {
     const config = vscode.workspace.getConfiguration(CONFIG_SECTION, folder);
 
     const pythonCommand = this.pythonManager.getPythonCommand(folder);
@@ -168,26 +169,35 @@ export class LanguageClientsManager {
 
     const transport = { stdio: TransportKind.stdio, pipe: TransportKind.pipe, socket: TransportKind.socket }[mode];
 
-    const serverOptions: ServerOptions = {
+    const getPort = async () => {
+      return getAvailablePort(["127.0.0.1"]);
+    };
+
+    return {
       run: {
         command: pythonCommand,
         args: [...args, ...serverArgs],
         options: {
           cwd: folder.uri.fsPath,
         },
 
-        transport: transport !== TransportKind.socket ? transport : { kind: TransportKind.socket, port: 6610 },
+        transport:
+          transport !== TransportKind.socket
+            ? transport
+            : { kind: TransportKind.socket, port: (await getPort()) ?? -1 },
       },
       debug: {
         command: pythonCommand,
         args: [...args, ...debug_args, ...serverArgs],
         options: {
           cwd: folder.uri.fsPath,
         },
-        transport: transport !== TransportKind.socket ? transport : { kind: TransportKind.socket, port: 6610 },
+        transport:
+          transport !== TransportKind.socket
+            ? transport
+            : { kind: TransportKind.socket, port: (await getPort()) ?? -1 },
       },
     };
-    return serverOptions;
   }
 
   public async getLanguageClientForDocument(document: vscode.TextDocument): Promise<LanguageClient | undefined> {
@@ -215,7 +225,7 @@ export class LanguageClientsManager {
       const mode = config.get<string>("languageServer.mode", "stdio");
 
       const serverOptions: ServerOptions =
-        mode === "tcp" ? this.getServerOptionsTCP(workspaceFolder) : this.getServerOptions(workspaceFolder, mode);
+        mode === "tcp" ? this.getServerOptionsTCP(workspaceFolder) : await this.getServerOptions(workspaceFolder, mode);
 
       const name = `RobotCode Language Server mode=${mode} for folder "${workspaceFolder.name}"`;
 

vscode-client/languageclientsmanger.ts

@@ -0,0 +1,54 @@
+import * as os from "os";
+import * as net from "net";
+
+export function getLocalHosts(): Set<string | undefined> {
+  const interfaces = os.networkInterfaces();
+
+  // Add undefined value for createServer function to use default host,
+  // and default IPv4 host in case createServer defaults to IPv6.
+  const results = new Set([undefined, "0.0.0.0"]);
+
+  for (const _interface of Object.values(interfaces)) {
+    if (_interface) {
+      for (const config of _interface) {
+        results.add(config.address);
+      }
+    }
+  }
+
+  return results;
+}
+
+function checkAvailablePort(port?: number, host?: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+
+    server.listen(port, host, () => {
+      const p = server.address() as net.AddressInfo;
+
+      server.close(() => {
+        resolve(p.port);
+      });
+    });
+  });
+}
+
+export function isErrnoException(object: unknown): object is NodeJS.ErrnoException {
+  return Object.prototype.hasOwnProperty.call(object, "code") || Object.prototype.hasOwnProperty.call(object, "errno");
+}
+
+export async function getAvailablePort(hosts: string[], port?: number): Promise<number | undefined> {
+  for (const host of hosts) {
+    try {
+      port = await checkAvailablePort(port, host);
+    } catch (error) {
+      if (!isErrnoException(error) || error.code === undefined || !["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+        throw error;
+      }
+    }
+  }
+
+  return port;
+}