nanokvm: address review comments

Author: mangelajo

packages/jumpstarter-driver-nanokvm/jumpstarter_driver_nanokvm/driver.py

@@ -86,14 +86,9 @@ async def _get_client(self) -> NanoKVMAPIClient:
     def close(self):
         """Clean up resources"""
         # Schedule cleanup of client
-        if self._client is not None:
+        if self._client_ctx is not None:
             try:
-                import asyncio
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._client_ctx.__aexit__(None, None, None))
-                else:
-                    loop.run_until_complete(self._client_ctx.__aexit__(None, None, None))
+                anyio.from_thread.run(self._client_ctx.__aexit__(None, None, None))
             except Exception as e:
                 self.logger.debug(f"Error closing client: {e}")
 
@@ -215,14 +210,9 @@ async def _get_client(self) -> NanoKVMAPIClient:
     def close(self):
         """Clean up resources"""
         # Schedule cleanup of client
-        if self._client is not None:
+        if self._client_ctx is not None:
             try:
-                import asyncio
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._client_ctx.__aexit__(None, None, None))
-                else:
-                    loop.run_until_complete(self._client_ctx.__aexit__(None, None, None))
+                anyio.from_thread.run(self._client_ctx.__aexit__(None, None, None))
             except Exception as e:
                 self.logger.debug(f"Error closing client: {e}")
 
@@ -397,13 +387,14 @@ def __post_init__(self):
             ),
         }
 
+        super().__post_init__()
+
         # Optionally add serial console access
         if self.enable_serial:
             # Note: This is a placeholder - actual serial console access via SSH
             # would require additional implementation in the nanokvm library
             self.logger.warning("Serial console access not yet fully implemented")
 
-        super().__post_init__()
 
     @classmethod
     def client(cls) -> str:
@@ -415,26 +406,44 @@ async def get_info(self):
         # Get info from the video driver's client
         video_driver = self.children["video"]
 
-        @with_reauth
-        async def _get_info_impl(driver):
-            client = await driver._get_client()
-            info = await client.get_info()
+        def _format_info(info):
+            """Format device info into a dictionary"""
             return {
-                "ips": [{"name": ip.name, "addr": ip.addr, "version": ip.version, "type": ip.type} for ip in info.ips],
+                "ips": [
+                    {"name": ip.name, "addr": ip.addr, "version": ip.version, "type": ip.type}
+                    for ip in info.ips
+                ],
                 "mdns": info.mdns,
                 "image": info.image,
                 "application": info.application,
                 "device_key": info.device_key,
             }
 
-        return await _get_info_impl(video_driver)
+        try:
+            client = await video_driver._get_client()
+            info = await client.get_info()
+            return _format_info(info)
+        except Exception as e:
+            if _is_unauthorized_error(e):
+                self.logger.warning("Received 401 Unauthorized, re-authenticating...")
+                await video_driver._reset_client()
+                # Retry once after re-authentication
+                client = await video_driver._get_client()
+                info = await client.get_info()
+                return _format_info(info)
+            raise
 
     @export
     async def reboot(self):
         """Reboot the NanoKVM device"""
         video_driver = self.children["video"]
-        client = await video_driver._get_client()
-        await client.reboot_system()
+
+        @with_reauth
+        async def _reboot_impl(driver):
+            client = await driver._get_client()
+            await client.reboot_system()
+
+        await _reboot_impl(video_driver)
         self.logger.info("NanoKVM device rebooted")
 
     @export

packages/jumpstarter-driver-nanokvm/jumpstarter_driver_nanokvm/driver_test.py

@@ -18,6 +18,7 @@ def mock_nanokvm_client():
         # Mock authentication
         mock_client.authenticate = AsyncMock()
         mock_client.logout = AsyncMock()
+        mock_client.close = AsyncMock()
 
         # Mock info
         mock_info = MagicMock()
@@ -43,6 +44,8 @@ async def mock_stream():
         # Mock HID functions
         mock_client.paste_text = AsyncMock()
         mock_client.reset_hid = AsyncMock()
+        mock_client.mouse_move_abs = AsyncMock()
+        mock_client.mouse_click = AsyncMock()
 
         # Mock reboot
         mock_client.reboot_system = AsyncMock()
@@ -52,14 +55,19 @@ async def mock_stream():
         mock_images.files = ["/data/alpine-standard-3.23.2-x86_64.iso", "/data/cs10-js.iso"]
         mock_client.get_images = AsyncMock(return_value=mock_images)
 
-        mock_client_class.return_value = mock_client
+        # Mock context manager behavior
+        mock_context = AsyncMock()
+        mock_context.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_context.__aexit__ = AsyncMock(return_value=None)
+        mock_client_class.return_value = mock_context
+
         yield mock_client
 
 
 @pytest.fixture
 def mock_aiohttp_session():
     """Create a mock aiohttp ClientSession"""
-    with patch("jumpstarter_driver_nanokvm.driver.ClientSession") as mock_session_class:
+    with patch("aiohttp.ClientSession") as mock_session_class:
         mock_session = AsyncMock()
         mock_session.close = AsyncMock()
         mock_session_class.return_value = mock_session
@@ -173,42 +181,28 @@ def test_nanokvm_client_creation():
 
 def test_nanokvm_mouse_move_abs(mock_nanokvm_client, mock_aiohttp_session):
     """Test mouse absolute movement"""
-    with patch("jumpstarter_driver_nanokvm.driver.ClientSession") as mock_session_class:
-        mock_ws = AsyncMock()
-        mock_ws.send_json = AsyncMock()
-        mock_session = AsyncMock()
-        mock_session.ws_connect = AsyncMock(return_value=mock_ws)
-        mock_session.close = AsyncMock()
-        mock_session_class.return_value = mock_session
-
-        hid = NanoKVMHID(host="test.local", username="admin", password="admin")
+    hid = NanoKVMHID(host="test.local", username="admin", password="admin")
 
-        with serve(hid) as client:
-            # Move mouse to absolute position
-            client.mouse_move_abs(32768, 32768)
+    with serve(hid) as client:
+        # Move mouse to absolute position (normalized 0.0-1.0 coordinates)
+        client.mouse_move_abs(0.5, 0.5)
 
-            # Verify WebSocket message was sent
-            mock_ws.send_json.assert_called()
+        # Verify the mock was called
+        mock_nanokvm_client.mouse_move_abs.assert_called_once_with(0.5, 0.5)
 
 
 def test_nanokvm_mouse_click(mock_nanokvm_client, mock_aiohttp_session):
     """Test mouse click"""
-    with patch("jumpstarter_driver_nanokvm.driver.ClientSession") as mock_session_class:
-        mock_ws = AsyncMock()
-        mock_ws.send_json = AsyncMock()
-        mock_session = AsyncMock()
-        mock_session.ws_connect = AsyncMock(return_value=mock_ws)
-        mock_session.close = AsyncMock()
-        mock_session_class.return_value = mock_session
+    from nanokvm.models import MouseButton
 
-        hid = NanoKVMHID(host="test.local", username="admin", password="admin")
+    hid = NanoKVMHID(host="test.local", username="admin", password="admin")
 
-        with serve(hid) as client:
-            # Click left button
-            client.mouse_click("left")
+    with serve(hid) as client:
+        # Click left button
+        client.mouse_click("left")
 
-            # Verify WebSocket messages were sent (down and up)
-            assert mock_ws.send_json.call_count >= 2
+        # Verify the mock was called
+        mock_nanokvm_client.mouse_click.assert_called_once_with(MouseButton.LEFT, None, None)
 
 
 def test_nanokvm_get_images(mock_nanokvm_client, mock_aiohttp_session):

packages/jumpstarter-driver-nanokvm/pyproject.toml

@@ -21,6 +21,9 @@ dependencies = [
     "click",
 ]
 
+[project.entry-points."jumpstarter.drivers"]
+NanoKVM = "jumpstarter_driver_nanokvm.driver:NanoKVM"
+
 [tool.hatch.version]
 source = "vcs"
 raw-options = { 'root' = '../../'}

pyproject.toml

@@ -19,6 +19,7 @@ jumpstarter-driver-http-power = { workspace = true }
 jumpstarter-driver-gpiod = { workspace = true }
 jumpstarter-driver-ridesx = { workspace = true }
 jumpstarter-driver-network = { workspace = true }
+jumpstarter-driver-nanokvm = { workspace = true }
 jumpstarter-driver-opendal = { workspace = true }
 jumpstarter-driver-power = { workspace = true }
 jumpstarter-driver-probe-rs = { workspace = true }