open documentation server in a port range and with external uri conversion

Author: d-biehl

robotcode/debugger/__main__.py

@@ -86,10 +86,10 @@ async def start_debugpy_async(
 ) -> None:
     from ..utils.async_tools import run_coroutine_from_thread_async
     from ..utils.debugpy import enable_debugpy, wait_for_debugpy_connected
-    from ..utils.net import check_free_port
+    from ..utils.net import find_free_port
     from .dap_types import Event
 
-    port = check_free_port(debugpy_port)
+    port = find_free_port(debugpy_port)
     if port != debugpy_port:
         _logger.warning(f"start debugpy session on port {port}")
 

robotcode/language_server/common/parts/diagnostics.py

@@ -242,6 +242,7 @@ async def force_refresh_document(self, document: TextDocument, refresh: bool = T
             await self.refresh()
 
     @_logger.call
+    @threaded()
     async def on_did_close(self, sender: Any, document: TextDocument) -> None:
         if await self.get_diagnostics_mode(document.uri) == DiagnosticsMode.WORKSPACE:
             return

robotcode/language_server/common/parts/documents.py

@@ -134,7 +134,7 @@ async def get_or_open_document(
     ) -> TextDocument:
         uri = Uri.from_path(path).normalized()
 
-        result = await self.parent.documents.get(uri)
+        result = await self.get(uri)
         if result is not None:
             return result
 

robotcode/language_server/common/text_document.py

@@ -236,6 +236,9 @@ async def remove_cache_entry(
     def set_data(self, key: Any, data: Any) -> None:
         self._data[key] = data
 
+    def remove_data(self, key: Any) -> None:
+        self._data.pop(key)
+
     def get_data(self, key: Any, default: Optional[_T] = None) -> _T:
         return self._data.get(key, default)
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -827,6 +827,11 @@ async def ensure_initialized(self) -> bool:
                     except BaseException as e:
                         if not isinstance(e, asyncio.CancelledError):
                             self._logger.exception(e, level=logging.DEBUG)
+
+                        if self.document is not None:
+                            self.document.remove_data(Namespace)
+                            self.document.remove_data(Namespace.DataEntry)
+
                         await self.invalidate()
                         raise
 

robotcode/language_server/robotframework/parts/code_action.py

@@ -4,14 +4,15 @@
 import socket
 import threading
 import traceback
+import urllib.parse
 from concurrent.futures import ProcessPoolExecutor
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from threading import Thread
 from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Union, cast
 from urllib.parse import parse_qs, urlparse
 
 from ....utils.logging import LoggingDescriptor
-from ....utils.net import check_free_port
+from ....utils.net import find_free_port
 from ...common.decorators import code_action_kinds, language_id
 from ...common.lsp_types import (
     CodeAction,
@@ -182,8 +183,9 @@ async def shutdown(self, sender: Any) -> None:
                 self._documentation_server = None
 
     def _run_server(self) -> None:
-        self._documentation_server_port = check_free_port(3100)
-        with DualStackServer(("", self._documentation_server_port), LibDocRequestHandler) as server:
+        self._documentation_server_port = find_free_port(3100, 3200)
+
+        with DualStackServer(("127.0.0.1", self._documentation_server_port), LibDocRequestHandler) as server:
             self._documentation_server = server
             try:
                 server.serve_forever()
@@ -316,14 +318,11 @@ async def build_url(
         except BaseException:
             pass
 
-        url_args = f"&args={'::'.join(args)}" if args else ""
+        url_args = "::".join(args) if args else ""
 
-        url = (
-            f"http://localhost:{self._documentation_server_port}"
-            f"/?name={name}"
-            f"{url_args}"
-            f"&basedir={base_dir}"
-            f"{'#{target}' if target else ''}"
-        )
+        base_url = f"http://localhost:{self._documentation_server_port}"
+        params = urllib.parse.urlencode({"name": name, "args": url_args, "basedir": base_dir})
+
+        url = f"{base_url}" f"/?&{params}" f"{f'#{target}' if target else ''}"
 
         return url

robotcode/utils/debugpy.py

@@ -1,5 +1,5 @@
 from .logging import LoggingDescriptor
-from .net import check_free_port
+from .net import find_free_port
 
 _logger = LoggingDescriptor(name=__name__)
 
@@ -38,7 +38,7 @@ def start_debugpy(port: int, wait_for_client: bool) -> bool:
     if is_debugpy_installed():
         import debugpy
 
-        real_port = check_free_port(port)
+        real_port = find_free_port(port)
         if real_port != port:
             _logger.warning(f"start debugpy session on port {real_port}")
         debugpy.listen(real_port)

robotcode/utils/net.py

@@ -1,27 +1,34 @@
+import contextlib
 import socket
 from contextlib import closing
-from typing import cast
+from typing import Optional, cast
 
 from .logging import LoggingDescriptor
 
 _logger = LoggingDescriptor(name=__name__)
 
 
-def find_free_port() -> int:
-    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
-        s.bind(("127.0.0.1", 0))
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        return cast(int, s.getsockname()[1])
+def find_free_port(start: Optional[int] = None, end: Optional[int] = None) -> int:
+    port = start
+    if port is None:
+        port = 0
+    if end is None:
+        end = port
 
+    try:
+        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
+            with contextlib.suppress(Exception):
+                s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
 
-def check_free_port(port: int) -> int:
-    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
-        try:
             s.bind(("127.0.0.1", port))
+
             s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             return cast(int, s.getsockname()[1])
-        except (SystemExit, KeyboardInterrupt):
-            raise
-        except BaseException:
-            _logger.warning(f"Port {port} is not free. Try to find a free port.")
-            return find_free_port()
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except BaseException:
+        if port and end > port:
+            return find_free_port(port + 1, end)
+        elif start and start > 0:
+            return find_free_port(None)
+        raise

robotcode/utils/uri.py

@@ -108,8 +108,8 @@ def _to_path_str(self) -> str:
         invalid characters and semantics. Will *not* look at the scheme of this URI.
         """
         # scheme://netloc/path;parameters?query#fragment
-        netloc = parse.unquote(self._parts.netloc)
-        path = parse.unquote(self._parts.path)
+        netloc = parse.unquote(self.netloc)
+        path = parse.unquote(self.path)
 
         if self._parts.scheme != "file":
             raise InvalidUriError(f"Invalid URI scheme '{str(self)}'.")

vscode-client/extension.ts

@@ -31,8 +31,9 @@ export async function activateAsync(context: vscode.ExtensionContext): Promise<v
     debugManager,
     testControllerManger,
     vscode.commands.registerCommand("robotcode.showDocumentation", async (url: string) => {
-      // await vscode.env.openExternal(vscode.Uri.parse(url));
-      await vscode.commands.executeCommand("simpleBrowser.api.open", url, {
+      const uri = vscode.Uri.parse(url);
+      const external_uri = await vscode.env.asExternalUri(uri);
+      await vscode.commands.executeCommand("simpleBrowser.api.open", external_uri.toString(true), {
         preserveFocus: true,
         viewColumn: vscode.ViewColumn.Beside,
       });