Implement pipe/socket transport for language server, Improve starting, stopping, restarting LSP client

Author: d-biehl

.vscode/launch.json

@@ -28,7 +28,9 @@
 				"host": "localhost",
 				"port": 5678
 			},
-			"justMyCode": false
+			"justMyCode": false,
+			"subProcess": true,
+			"showReturnValue": true,
 		},
 		{
 			"name": "Python: Attach Prompt",

CHANGELOG.md

@@ -7,6 +7,9 @@ All notable changes to the "robotcode" extension will be documented in this file
 ### 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  
 
 ### added
 

log.ini

@@ -6,8 +6,8 @@
 #keys: root, robotcode_utils
 #keys: root, diagnostics, document, jsonrpc2, jsonrpc2_message
 #keys: root, diagnostics, robot_diagnostics, robocop_diagnostics
-keys: root, discovering
-#keys: root
+#keys: root, discovering
+keys: root
 
 [formatters]
 #keys: detailed,simple,colored_simple

package-lock.json

@@ -71,7 +71,7 @@
         "id": "builtin",
         "description": "built in library, keyword or variable"
       }
-    ],        
+    ],
     "semanticTokenScopes": [
       {
         "language": "robotframework",
@@ -118,20 +118,19 @@
           "variable": [
             "variable.other.readwrite.robotframework"
           ],
-          "keywordCall": [            
+          "keywordCall": [
             "variable.function.keyword-call.robotframework"
           ],
-          "keywordCallInner": [            
+          "keywordCallInner": [
             "variable.function.keyword-call.inner.robotframework"
           ],
-          "nameCall": [            
+          "nameCall": [
             "variable.function.keyword-call.robotframework"
           ],
           "continuation": [
             "punctuation.separator.continuation.robotframework"
           ],
-          "separator": [            
-          ],
+          "separator": [],
           "terminator": [
             "punctuation.terminator.robotframework"
           ],
@@ -199,10 +198,12 @@
           },
           "robotcode.languageServer.mode": {
             "type": "string",
-            "default": "stdio",
+            "default": "pipe",
             "description": "Specifies the mode the language server is started. Requires a VSCode restart to take effect.",
             "enum": [
               "stdio",
+              "pipe",
+              "socket",
               "tcp"
             ],
             "scope": "resource"
@@ -628,18 +629,18 @@
   "dependencies": {
     "ansi-colors": "^4.1.1",
     "vscode-debugadapter": "^1.51.0",
-    "vscode-languageclient": "^7.0.0"
+    "vscode-languageclient": "^8.0.0-next"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0",
     "@types/mocha": "^9.0.0",
     "@types/node": "^14.16.0",
     "@types/vscode": "^1.61.0",
-    "@typescript-eslint/eslint-plugin": "^5.8.0",
-    "@typescript-eslint/parser": "^5.8.0",
-    "eslint": "^8.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.9.0",
+    "@typescript-eslint/parser": "^5.9.0",
+    "eslint": "^8.6.0",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-jsx-a11y": "^6.5.1",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^4.0.0",
@@ -650,10 +651,10 @@
     "replace-in-file": "^6.3.2",
     "ts-loader": "^9.2.6",
     "typescript": "^4.5.4",
-    "vsce": "^2.5.3",
+    "vsce": "^2.6.3",
     "vscode-debugadapter-testsupport": "^1.51.0",
     "vscode-dts": "^0.3.3",
-    "@vscode/test-electron": "^2.0.0",
+    "@vscode/test-electron": "^2.0.1",
     "webpack": "^5.65.0",
     "webpack-cli": "^4.9.1"
   }

package.json

@@ -143,6 +143,7 @@ class RpcMethodEntry(NamedTuple):
     name: str
     method: Callable[..., Any]
     param_type: Optional[Type[Any]]
+    cancelable: bool
 
 
 @runtime_checkable
@@ -159,12 +160,18 @@ def rpc_method(_func: _F) -> _F:
 
 
 @overload
-def rpc_method(*, name: Optional[str] = None, param_type: Optional[Type[Any]] = None) -> Callable[[_F], _F]:
+def rpc_method(
+    *, name: Optional[str] = None, param_type: Optional[Type[Any]] = None, cancelable: bool = True
+) -> Callable[[_F], _F]:
     ...
 
 
 def rpc_method(
-    _func: Optional[_F] = None, *, name: Optional[str] = None, param_type: Optional[Type[Any]] = None
+    _func: Optional[_F] = None,
+    *,
+    name: Optional[str] = None,
+    param_type: Optional[Type[Any]] = None,
+    cancelable: bool = True,
 ) -> Callable[[_F], _F]:
     def _decorator(func: _F) -> Callable[[_F], _F]:
 
@@ -182,7 +189,7 @@ def _decorator(func: _F) -> Callable[[_F], _F]:
         if real_name is None or not real_name:
             raise ValueError("name is empty.")
 
-        cast(RpcMethod, f).__rpc_method__ = RpcMethodEntry(real_name, f, param_type)
+        cast(RpcMethod, f).__rpc_method__ = RpcMethodEntry(real_name, f, param_type, cancelable)
         return func
 
     if _func is None:
@@ -248,6 +255,7 @@ def get_methods(obj: Any) -> Dict[str, RpcMethodEntry]:
                     rpc_method.__rpc_method__.name,
                     method,
                     rpc_method.__rpc_method__.param_type,
+                    rpc_method.__rpc_method__.cancelable,
                 )
                 for method, rpc_method in map(
                     lambda m1: (m1, cast(RpcMethod, m1)),
@@ -288,10 +296,12 @@ def methods(self) -> Dict[str, RpcMethodEntry]:
 
         return self.__methods
 
-    def add_method(self, name: str, func: Callable[..., Any], param_type: Optional[Type[Any]] = None) -> None:
+    def add_method(
+        self, name: str, func: Callable[..., Any], param_type: Optional[Type[Any]] = None, cancelable: bool = True
+    ) -> None:
         self.__ensure_initialized()
 
-        self.__methods[name] = RpcMethodEntry(name, func, param_type)
+        self.__methods[name] = RpcMethodEntry(name, func, param_type, cancelable)
 
     def remove_method(self, name: str) -> Optional[RpcMethodEntry]:
         self.__ensure_initialized()
@@ -323,6 +333,7 @@ class ReceivedRequestEntry(NamedTuple):
     future: asyncio.Future[Any]
     request: Optional[Any]
     cancel_token: CancelationToken
+    cancelable: bool
 
 
 class JsonRPCProtocolBase(asyncio.Protocol, ABC):
@@ -650,10 +661,13 @@ def handle_request(self, message: JsonRPCRequest) -> Optional[asyncio.Task[_T]]:
         cancel_token = CancelationToken()
 
         task = create_sub_task(
-            ensure_coroutine(e.method)(*params[0], cancel_token=cancel_token, **params[1]), name=message.method
+            ensure_coroutine(e.method)(
+                *params[0], **({"cancel_token": cancel_token} if e.cancelable else {}), **params[1]
+            ),
+            name=message.method,
         )
         with self._received_request_lock:
-            self._received_request[message.id] = ReceivedRequestEntry(task, message, cancel_token)
+            self._received_request[message.id] = ReceivedRequestEntry(task, message, cancel_token, e.cancelable)
 
         def done(t: asyncio.Task[Any]) -> None:
             try:
@@ -663,7 +677,6 @@ def done(t: asyncio.Task[Any]) -> None:
             except (SystemExit, KeyboardInterrupt):
                 raise
             except JsonRPCErrorException as ex:
-                self._logger.exception(ex)
                 self.send_error(ex.code, ex.message, id=message.id, data=ex.data)
             except BaseException as e:
                 self._logger.exception(e)
@@ -689,8 +702,9 @@ def cancel_request(self, id: Union[int, str, None]) -> None:
     @_logger.call
     async def cancel_all_received_request(self) -> None:
         for entry in self._received_request.values():
-            if entry is not None and entry.future is not None and not entry.future.cancelled():
-                entry.cancel_token.cancel()
+            if entry is not None and entry.cancelable and entry.future is not None and not entry.future.cancelled():
+                if entry.cancel_token:
+                    entry.cancel_token.cancel()
                 entry.future.cancel()
 
     @_logger.call

robotcode/jsonrpc2/protocol.py

@@ -20,11 +20,15 @@
 from ..utils.logging import LoggingDescriptor
 from .protocol import JsonRPCException
 
-__all__ = ["StdOutTransportAdapter", "JsonRpcServerMode", "TcpParams", "JsonRPCServer"]
+__all__ = ["JsonRpcServerMode", "TcpParams", "JsonRPCServer"]
 
 TProtocol = TypeVar("TProtocol", bound=asyncio.Protocol)
 
 
+class NotSupportedError(Exception):
+    pass
+
+
 class StdOutTransportAdapter(asyncio.Transport):
     def __init__(self, rfile: BinaryIO, wfile: BinaryIO) -> None:
         super().__init__()
@@ -43,6 +47,8 @@ def write(self, data: bytes) -> None:
 class JsonRpcServerMode(Enum):
     STDIO = "stdio"
     TCP = "tcp"
+    SOCKET = "socket"
+    PIPE = "pipe"
 
 
 class TcpParams(NamedTuple):
@@ -57,9 +63,11 @@ def __init__(
         self,
         mode: JsonRpcServerMode = JsonRpcServerMode.STDIO,
         tcp_params: TcpParams = TcpParams(None, 0),
+        pipe_name: Optional[str] = None,
     ):
         self.mode = mode
         self.tcp_params = tcp_params
+        self.pipe_name = pipe_name
 
         self._run_func: Optional[Callable[[], None]] = None
         self._server: Optional[asyncio.AbstractServer] = None
@@ -77,6 +85,10 @@ def start(self) -> None:
             self.start_stdio()
         elif self.mode == JsonRpcServerMode.TCP:
             self.start_tcp(self.tcp_params.host, self.tcp_params.port)
+        elif self.mode == JsonRpcServerMode.PIPE:
+            self.start_pipe(self.pipe_name)
+        elif self.mode == JsonRpcServerMode.SOCKET:
+            self.start_socket(self.tcp_params.port)
         else:
             raise JsonRPCException(f"Unknown server mode {self.mode}")
 
@@ -105,11 +117,6 @@ def __exit__(
     def create_protocol(self) -> TProtocol:
         ...
 
-    @_logger.call
-    def shutdown_protocol(self, protocol: TProtocol) -> None:
-        if self.mode == JsonRpcServerMode.STDIO and self._stdio_stop_event is not None:
-            self._stdio_stop_event.set()
-
     stdio_executor: Optional[ThreadPoolExecutor] = None
 
     @_logger.call
@@ -135,11 +142,7 @@ async def aio_readline(rfile: BinaryIO, protocol: asyncio.Protocol) -> None:
                         )
                         protocol.data_received(data)
 
-            self._logger.debug("starting run_io_nonblocking")
-            try:
-                self.loop.run_until_complete(aio_readline(sys.__stdin__.buffer, protocol))
-            finally:
-                self._logger.debug("exiting run_io_nonblocking")
+            self.loop.run_until_complete(aio_readline(transport.rfile, protocol))
 
         self._run_func = run_io_nonblocking
 
@@ -148,11 +151,38 @@ def start_tcp(self, host: Optional[str] = None, port: int = 0) -> None:
         self.mode = JsonRpcServerMode.TCP
 
         self._server = self.loop.run_until_complete(
-            self.loop.create_server(lambda: self.create_protocol(), host, port, reuse_address=True)
+            self.loop.create_server(self.create_protocol, host, port, reuse_address=True)
         )
 
         self._run_func = self.loop.run_forever
 
+    @_logger.call
+    def start_pipe(self, pipe_name: Optional[str]) -> None:
+        if pipe_name is None:
+            raise ValueError("pipe name missing.")
+
+        self.mode = JsonRpcServerMode.PIPE
+
+        try:
+            if sys.platform == "win32" and getattr(self.loop, "create_pipe_connection", None):
+                self.loop.run_until_complete(
+                    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))
+        except NotImplementedError:
+            raise NotSupportedError("Pipe transport is not supported on this platform.")
+
+        self._run_func = self.loop.run_forever
+
+    @_logger.call
+    def start_socket(self, port: int) -> None:
+        self.mode = JsonRpcServerMode.SOCKET
+
+        self.loop.run_until_complete(self.loop.create_connection(self.create_protocol, port=port))
+
+        self._run_func = self.loop.run_forever
+
     @_logger.call
     def run(self) -> None:
         if self._run_func is None: