feat: add check_availablity for server

Author: observerw

src/lsp_client/client/abc.py

@@ -2,8 +2,8 @@
 
 import os
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator, Iterable
-from contextlib import asynccontextmanager
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager, suppress
 from pathlib import Path
 from typing import Any, Literal, Self, override
 
@@ -62,12 +62,13 @@ class Client(
     _workspace: Workspace = field(init=False)
     _buffer: LSPFileBuffer = field(factory=LSPFileBuffer, init=False)
 
-    def _iter_candidate_servers(self) -> Iterable[Server]:
+    async def _iter_candidate_servers(self) -> AsyncGenerator[Server]:
         """
         Server candidates in order of priority:
         1. User-provided server
-        2. Containerized server
-        3. Local server (maybe with auto-installation)
+        2. Local server (if available)
+        3. Containerized server
+        4. Local server with auto-install (if enabled)
         """
 
         defaults = self.create_default_servers()
@@ -80,6 +81,10 @@ def _iter_candidate_servers(self) -> Iterable[Server]:
             case Server() as server:
                 yield server
 
+        with suppress(ServerRuntimeError):
+            await defaults.local.check_availability()
+            yield defaults.local
+
         yield defaults.container
         yield defaults.local
 
@@ -230,13 +235,13 @@ async def _run_server(
     ) -> AsyncGenerator[tuple[Server, Receiver[ServerRequest]]]:
         async with channel[ServerRequest].create() as (sender, receiver):
             errors: list[ServerRuntimeError] = []
-            for server in self._iter_candidate_servers():
+            async for candidate in self._iter_candidate_servers():
                 try:
-                    async with server.run(self._workspace, sender=sender) as s:  # ty: ignore[invalid-argument-type]
-                        yield s, receiver
+                    async with candidate.run(self._workspace, sender=sender) as server:  # ty: ignore[invalid-argument-type]
+                        yield server, receiver
                         return
                 except ServerRuntimeError as e:
-                    logger.debug("Failed to start server {}: {}", server, e)
+                    logger.debug("Failed to start server {}: {}", candidate, e)
                     errors.append(e)
 
             raise ExceptionGroup(

src/lsp_client/server/abc.py

@@ -27,6 +27,10 @@ class Server(ABC):
 
     _resp_table: ResponseTable = field(factory=ResponseTable, init=False)
 
+    @abstractmethod
+    async def check_availability(self) -> None:
+        """Check if the server runtime is available."""
+
     @abstractmethod
     async def send(self, package: RawPackage) -> None:
         """Send a package to the runtime."""

src/lsp_client/server/container.py

@@ -5,6 +5,7 @@
 from pathlib import Path
 from typing import Literal, final, override
 
+import anyio
 from attrs import Factory, define, field
 from loguru import logger
 
@@ -191,6 +192,20 @@ async def receive(self) -> RawPackage | None:
     async def kill(self) -> None:
         await self._local.kill()
 
+    @override
+    async def check_availability(self) -> None:
+        try:
+            await anyio.run_process(
+                [self.backend, "pull", self.image],
+                stdout=anyio.streams.devnull.DevnullStream(),
+                stderr=anyio.streams.devnull.DevnullStream(),
+            )
+        except anyio.ProcessError as e:
+            raise RuntimeError(
+                f"Container backend '{self.backend}' is not available or image '{self.image}' "
+                "could not be pulled."
+            ) from e
+
     @override
     @asynccontextmanager
     async def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:

src/lsp_client/server/local.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-import shutil
 from collections.abc import AsyncGenerator, Sequence
 from contextlib import asynccontextmanager
 from functools import cached_property
 from pathlib import Path
 from typing import Protocol, final, override
 
+import aioshutil
 import anyio
 from anyio.abc import AnyByteSendStream, Process
 from anyio.streams.buffered import BufferedByteReceiveStream
@@ -80,27 +80,27 @@ async def kill(self) -> None:
             self._process.kill()
             await self._process.aclose()
 
+    @override
+    async def check_availability(self) -> None:
+        if not await aioshutil.which(self.program):
+            raise ServerRuntimeError(
+                self, f"Program '{self.program}' not found in PATH."
+            )
+
     @override
     @asynccontextmanager
     async def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:
-        if not shutil.which(self.program):
+        try:
+            await self.check_availability()
+        except ServerRuntimeError as e:
             if disable_auto_installation():
-                raise ServerRuntimeError(
-                    self,
-                    f"Program '{self.program}' not found in PATH and auto-installation is disabled.",
-                )
+                raise ServerRuntimeError(self, "auto-installation is disabled.") from e
             elif self.ensure_installed:
-                try:
-                    await self.ensure_installed()
-                except (OSError, RuntimeError) as e:
-                    raise ServerRuntimeError(
-                        self, f"Failed to install '{self.program}'"
-                    ) from e
+                await self.ensure_installed()
             else:
                 raise ServerRuntimeError(
-                    self,
-                    f"Program '{self.program}' not found in PATH and no installation method is provided.",
-                )
+                    self, "no installation method is provided."
+                ) from e
 
         command = [self.program, *self.args]
         logger.debug("Running with command: {}", command)