meshagent-api 0.42.2__tar.gz → 0.43.0__tar.gz

{meshagent_api-0.42.2/meshagent_api.egg-info → meshagent_api-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.42.2
+Version: 0.43.0
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com

{meshagent_api-0.42.2 → meshagent_api-0.43.0}/meshagent/api/protocol.py

@@ -145,6 +145,8 @@ class Protocol:
     async def _send_payload(self, message_id: int, data: bytes) -> None:
         packets = compute_packets(data)
         for i in range(packets):
+            if not self.is_open:
+                return
             packet = bytearray()
             packet.extend(message_id.to_bytes(8))
             packet.extend(int(i + 1).to_bytes(4))
@@ -188,6 +190,8 @@ class Protocol:
         header_data.extend(bytes(type, "utf-8"))
 
         await self.send_packet(header_data)
+        if not self.is_open:
+            return
 
         logger.debug("publishing message payload %s", message_id)
         await self._send_payload(message_id=message_id, data=data)
@@ -341,7 +345,7 @@ class Protocol:
 
 
 class ClientProtocol(Protocol):
-    def __init__(self, *, token: str):
+    def __init__(self, *, token: str | None):
         super().__init__()
         self._token = token
 

meshagent_api-0.43.0/meshagent/api/version.py

@@ -0,0 +1 @@
+__version__ = "0.43.0"

{meshagent_api-0.42.2 → meshagent_api-0.43.0}/meshagent/api/websocket_protocol.py

@@ -1,6 +1,7 @@
 import contextlib
 import urllib.parse
 from aiohttp import ClientSession, WSMsgType, web, ClientWebSocketResponse
+from aiohttp.client_exceptions import ClientConnectionResetError
 import asyncio
 import logging
 import os
@@ -80,12 +81,18 @@ def _format_websocket_close_reason(
     return None
 
 
+def _format_send_close_reason(exc: BaseException | None = None) -> str:
+    if exc is None:
+        return "websocket closed before send completed"
+    return str(exc).strip() or repr(exc)
+
+
 class WebSocketClientProtocol(ClientProtocol):
     def __init__(
         self,
         *,
         url: str,
-        token: str,
+        token: str | None,
         heartbeat: float | None = None,
         session: ClientSession | None = None,
     ):
@@ -104,6 +111,16 @@ class WebSocketClientProtocol(ClientProtocol):
     def url(self):
         return self._url
 
+    @classmethod
+    def withIAP(
+        cls,
+        *,
+        url: str = "./.well-known/meshagent/room/connect",
+        heartbeat: float | None = None,
+        session: ClientSession | None = None,
+    ):
+        return cls(url=url, token=None, heartbeat=heartbeat, session=session)
+
     def create_factory(self):
         session = self._session if self._session_external else None
 
@@ -129,7 +146,6 @@ class WebSocketClientProtocol(ClientProtocol):
 
             url_parts = urllib.parse.urlparse(self._url)
             query_dict = urllib.parse.parse_qs(url_parts.query)
-            query_dict.update({"token": self.token})
             query_dict.update({"v": __version__})
             new_query_string = urllib.parse.urlencode(query_dict, doseq=True)
             url_with_params = urllib.parse.urlunparse(
@@ -143,8 +159,16 @@ class WebSocketClientProtocol(ClientProtocol):
                 )
             )
 
+            headers = (
+                None
+                if self.token is None
+                else {"Authorization": f"Bearer {self.token}"}
+            )
             self._ws_ctx = self._session.ws_connect(
-                url_with_params, heartbeat=self._heartbeat, compress=15
+                url_with_params,
+                headers=headers,
+                heartbeat=self._heartbeat,
+                compress=15,
             )
             self._ws = await self._ws_ctx.__aenter__()
             self._ws_entered = True
@@ -220,7 +244,21 @@ class WebSocketClientProtocol(ClientProtocol):
         await super().__aexit__(exc_type, exc, tb)
 
     async def send_packet(self, data: bytes) -> None:
-        await self._ws.send_bytes(data)
+        if not self.is_open or self._ws is None or self._ws.closed:
+            self._set_close_state(
+                kind=ProtocolCloseKind.SERVER,
+                reason="websocket closed before send completed",
+            )
+            self._shutdown()
+            return
+        try:
+            await self._ws.send_bytes(data)
+        except (ClientConnectionResetError, ConnectionResetError) as exc:
+            self._set_close_state(
+                kind=ProtocolCloseKind.SERVER,
+                reason=_format_send_close_reason(exc),
+            )
+            self._shutdown()
 
 
 class WebSocketServerProtocol(Protocol):
@@ -301,4 +339,18 @@ class WebSocketServerProtocol(Protocol):
         await super().__aexit__(exc_type=exc_type, exc=exc, tb=tb)
 
     async def send_packet(self, data: bytes) -> None:
-        await self.socket.send_bytes(data)
+        if not self.is_open or self.socket.closed:
+            self._set_close_state(
+                kind=ProtocolCloseKind.CLIENT,
+                reason="websocket closed before send completed",
+            )
+            self._shutdown()
+            return
+        try:
+            await self.socket.send_bytes(data)
+        except (ClientConnectionResetError, ConnectionResetError) as exc:
+            self._set_close_state(
+                kind=ProtocolCloseKind.CLIENT,
+                reason=_format_send_close_reason(exc),
+            )
+            self._shutdown()

{meshagent_api-0.42.2 → meshagent_api-0.43.0}/meshagent/api/websocket_protocol_test.py

@@ -1,11 +1,14 @@
 import importlib
 
+import aiohttp
 import pytest
 
+from meshagent.api.protocol import ProtocolCloseKind
 from meshagent.api.websocket_protocol import (
     DEFAULT_WEBSOCKET_HEARTBEAT,
     WEBSOCKET_HEARTBEAT_ENV,
     WebSocketClientProtocol,
+    WebSocketServerProtocol,
     resolve_websocket_heartbeat,
 )
 
@@ -24,7 +27,9 @@ class _FakeSession:
     def __init__(self) -> None:
         self.entered = False
         self.exited = False
-        self.ws_connect_calls: list[tuple[str, float | None, int | None]] = []
+        self.ws_connect_calls: list[
+            tuple[str, dict[str, str] | None, float | None, int | None]
+        ] = []
 
     async def __aenter__(self):
         self.entered = True
@@ -34,12 +39,26 @@ class _FakeSession:
         self.exited = True
 
     def ws_connect(
-        self, url: str, *, heartbeat: float | None = None, compress: int | None = None
+        self,
+        url: str,
+        *,
+        headers: dict[str, str] | None = None,
+        heartbeat: float | None = None,
+        compress: int | None = None,
     ):
-        self.ws_connect_calls.append((url, heartbeat, compress))
+        self.ws_connect_calls.append((url, headers, heartbeat, compress))
         return _FailingWebsocketContext()
 
 
+class _ClosingWebSocket:
+    closed = False
+
+    async def send_bytes(self, data: bytes) -> None:
+        raise aiohttp.client_exceptions.ClientConnectionResetError(
+            "Cannot write to closing transport"
+        )
+
+
 def test_resolve_websocket_heartbeat_uses_default(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -107,4 +126,51 @@ async def test_websocket_client_protocol_keeps_external_session_open_when_enter_
     assert session.entered is False
     assert session.exited is False
     assert len(session.ws_connect_calls) == 1
-    assert session.ws_connect_calls[0][2] == 15
+    assert session.ws_connect_calls[0][1] == {"Authorization": "Bearer token"}
+    assert session.ws_connect_calls[0][3] == 15
+
+
+@pytest.mark.asyncio
+async def test_websocket_client_protocol_with_iap_omits_authorization_header():
+    session = _FakeSession()
+    protocol = WebSocketClientProtocol.withIAP(session=session)
+
+    with pytest.raises(RuntimeError, match="websocket failed"):
+        await protocol.__aenter__()
+
+    assert protocol.url == "./.well-known/meshagent/room/connect"
+    assert protocol.token is None
+    assert len(session.ws_connect_calls) == 1
+    assert session.ws_connect_calls[0][0].startswith(
+        "./.well-known/meshagent/room/connect?v="
+    )
+    assert session.ws_connect_calls[0][1] is None
+
+
+@pytest.mark.asyncio
+async def test_websocket_client_protocol_treats_closing_transport_as_server_close():
+    protocol = WebSocketClientProtocol(
+        url="ws://example.test/room",
+        token="token",
+        session=_FakeSession(),
+    )
+    protocol._open = True
+    protocol._ws = _ClosingWebSocket()
+
+    await protocol.send_packet(b"hello")
+
+    assert protocol.close_kind() == ProtocolCloseKind.SERVER
+    assert protocol.close_reason() == "Cannot write to closing transport"
+    assert protocol.is_open is False
+
+
+@pytest.mark.asyncio
+async def test_websocket_server_protocol_treats_closing_transport_as_client_close():
+    protocol = WebSocketServerProtocol(socket=_ClosingWebSocket())
+    protocol._open = True
+
+    await protocol.send_packet(b"hello")
+
+    assert protocol.close_kind() == ProtocolCloseKind.CLIENT
+    assert protocol.close_reason() == "Cannot write to closing transport"
+    assert protocol.is_open is False

{meshagent_api-0.42.2 → meshagent_api-0.43.0/meshagent_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-api
-Version: 0.42.2
+Version: 0.43.0
 Summary: Python Server API for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com

meshagent_api-0.42.2/meshagent/api/version.py

@@ -1 +0,0 @@
-__version__ = "0.42.2"