embeddedci 2.7.0__tar.gz → 2.7.1__tar.gz

{embeddedci-2.7.0 → embeddedci-2.7.1}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog — `embeddedci`
 
+## 2.7.1
+
+- Over the cloud, a UART console (`open_uart`) can stay open while a capture, power profile or
+  DAC replay runs, as on the LAN. Each streaming tunnel tells the server what it is for
+  (`?kind=uart|capture|dac|flash`). A server without kind support still answers HTTP 409
+  ("device is busy") for the second tunnel, as before.
+
 ## 2.7.0
 
 - `UartSession.write` on a link that is gone (a reset connection, an unplugged pod, a closed

{embeddedci-2.7.0 → embeddedci-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: embeddedci
-Version: 2.7.0
+Version: 2.7.1
 Summary: BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing
 Project-URL: Homepage, https://embeddedci.com
 Project-URL: Repository, https://github.com/embeddedci-com/embeddedci-python

{embeddedci-2.7.0 → embeddedci-2.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "embeddedci"
-version = "2.7.0"
+version = "2.7.1"
 description = "BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing"
 readme = "README.md"
 requires-python = ">=3.10"

{embeddedci-2.7.0 → embeddedci-2.7.1}/src/embeddedci/benchpod/transport/cloud.py

@@ -343,9 +343,13 @@ class CloudTransport(TcpTransport):
             self._expires_at = None
         return True
 
-    def _ws_url(self) -> str:
+    def _ws_url(self, kind: Optional[str] = None) -> str:
         """The tunnel URL. It carries no credentials: those go in :meth:`_ws_headers`, so the
-        token never reaches an access log or an error message."""
+        token never reaches an access log or an error message.
+
+        ``kind`` (``uart``/``capture``/``dac``/``flash``) tells the server what the tunnel is
+        for, so a UART console and a capture or DAC replay may be open together, as on the LAN.
+        Without it the server treats the tunnel as exclusive."""
         base = self.api_base
         if base.startswith("https://"):
             ws_base = "wss://" + base[len("https://"):]
@@ -353,7 +357,10 @@ class CloudTransport(TcpTransport):
             ws_base = "ws://" + base[len("http://"):]
         else:
             ws_base = base
-        return f"{ws_base}/api/cloud/devices/ws?device={quote(self.device_name, safe='')}"
+        url = f"{ws_base}/api/cloud/devices/ws?device={quote(self.device_name, safe='')}"
+        if kind:
+            url += f"&kind={quote(kind, safe='')}"
+        return url
 
     def _ws_headers(self, token: str) -> "list[str]":
         """Headers for the tunnel's WebSocket upgrade: the session token as a Bearer header
@@ -364,18 +371,19 @@ class CloudTransport(TcpTransport):
             headers.append(f"X-Benchpod-Lease: {self.lease_id}")
         return headers
 
-    def _open_tunnel(self) -> _WsTunnelSocket:
+    def _open_tunnel(self, kind: Optional[str] = None) -> _WsTunnelSocket:
         token = self._session_token()
-        return _WsTunnelSocket(self._ws_url(), self.timeout, headers=self._ws_headers(token),
+        return _WsTunnelSocket(self._ws_url(kind), self.timeout, headers=self._ws_headers(token),
                                secrets=(token,))
 
-    def _dial(self, timeout: Optional[float] = None) -> _WsTunnelSocket:  # type: ignore[override]
+    def _dial(self, timeout: Optional[float] = None,  # type: ignore[override]
+              kind: Optional[str] = None) -> _WsTunnelSocket:
         try:
-            sock = self._open_tunnel()
+            sock = self._open_tunnel(kind)
         except TransportError as exc:
             status = getattr(exc, "status", None)
             if status == 401 and self._invalidate_token():
-                sock = self._open_tunnel()
+                sock = self._open_tunnel(kind)
             else:
                 body = getattr(exc, "body", None) or b""
                 if isinstance(body, bytes):

{embeddedci-2.7.0 → embeddedci-2.7.1}/src/embeddedci/benchpod/transport/tcp.py

@@ -107,8 +107,12 @@ class TcpTransport(Transport):
         except ValueError:
             raise TransportError(f"invalid port in address {self.addr!r}") from None
 
-    def _dial(self, timeout: Optional[float] = None) -> socket.socket:
-        """Connect, with ``timeout`` (default: the transport's) on every later read."""
+    def _dial(self, timeout: Optional[float] = None, kind: Optional[str] = None) -> socket.socket:
+        """Connect, with ``timeout`` (default: the transport's) on every later read.
+
+        ``kind`` names what the connection is for (``"uart"``, ``"capture"``, ``"dac"``,
+        ``"flash"``). The cloud transport passes it to the server so a UART console and a capture
+        can share the pod as they do here; a LAN socket needs no such hint and ignores it."""
         host, port = self._split_addr()
         deadline = time.monotonic() + self.dial_timeout
         last: Optional[Exception] = None
@@ -194,7 +198,7 @@ class TcpTransport(Transport):
     def samples(self, req: dict) -> List[int]:
         """Send a command whose reply is a chunked sample array."""
         timeout = request_timeout(req, self.timeout)
-        sock = self._dial(timeout)
+        sock = self._dial(timeout, kind="capture")
         buf = bytearray()
         out: List[int] = []
         try:
@@ -225,7 +229,7 @@ class TcpTransport(Transport):
         ``la_upto``) of a ``capture_dual`` — can see them. Raises on an error chunk.
         """
         timeout = request_timeout(req, self.timeout)
-        sock = self._dial(timeout)
+        sock = self._dial(timeout, kind="capture")
         buf = bytearray()
         cmd = req.get("cmd")
         try:
@@ -264,7 +268,7 @@ class TcpTransport(Transport):
         v18). Returns the ``replay`` reply data.
         """
         timeout = max(self.timeout, _UPLOAD_TIMEOUT)
-        sock = self._dial(timeout)
+        sock = self._dial(timeout, kind="dac")
         buf = bytearray()
         try:
             begin = {"cmd": "load_bin", "total": len(data)}
@@ -326,7 +330,7 @@ class TcpTransport(Transport):
             req["delay_ms"] = int(delay_ms)
         self.command(req)
 
-    def _raw_handshake(self, req: dict, cmd: str) -> RawLink:
+    def _raw_handshake(self, req: dict, cmd: str, kind: str) -> RawLink:
         """Send a mode-switch command and hand back the raw byte link.
 
         Shared by ``dap_start`` and ``uart_proxy_start``: both ack one JSON line
@@ -337,7 +341,7 @@ class TcpTransport(Transport):
         hanging; only after it does the timeout come off.
         """
         timeout = request_timeout(req, self.timeout)
-        sock = self._dial(timeout)
+        sock = self._dial(timeout, kind=kind)
         try:
             with _io_errors(cmd, timeout):
                 sock.sendall(encode_request(req))
@@ -364,12 +368,12 @@ class TcpTransport(Transport):
             req["packet_count"] = packet_count
         if wait_ms:
             req["wait_ms"] = wait_ms
-        return self._raw_handshake(req, "dap_start")
+        return self._raw_handshake(req, "dap_start", "flash")
 
     def uart_proxy_start(self, rx: int, tx: int, baud: int) -> RawLink:
         return self._raw_handshake(
             {"cmd": "uart_proxy_start", "rx": rx, "tx": tx, "baud": baud},
-            "uart_proxy_start",
+            "uart_proxy_start", "uart",
         )
 
     def close(self) -> None:

{embeddedci-2.7.0 → embeddedci-2.7.1}/tests/test_cloud.py

@@ -39,6 +39,65 @@ def test_cloud_ws_url():
     t = CloudTransport("dev-a", api_base="https://example.test", token="abc")
     url = t._ws_url()
     assert url == "wss://example.test/api/cloud/devices/ws?device=dev-a"
+    assert t._ws_url("uart") == "wss://example.test/api/cloud/devices/ws?device=dev-a&kind=uart"
+
+
+def test_tunnel_url_carries_the_kind_hint(monkeypatch):
+    calls = _fake_websocket_module(monkeypatch)
+    t = CloudTransport("dev-a", api_base="https://example.test", token="tok")
+    t._dial(kind="capture")
+    t._dial()
+    assert calls[0][0].endswith("?device=dev-a&kind=capture")
+    assert calls[1][0].endswith("?device=dev-a")
+
+
+def _recording_dial(monkeypatch, t, sock):
+    kinds = []
+
+    def dial(timeout=None, kind=None):
+        kinds.append(kind)
+        return sock
+
+    monkeypatch.setattr(t, "_dial", dial)
+    return kinds
+
+
+@pytest.mark.parametrize("call, reply, kind", [
+    (lambda t: t.uart_proxy_start(rx=1, tx=2, baud=115200), b'{"status":"ok"}\n', "uart"),
+    (lambda t: t.dap_start(swclk=11, swdio=12), b'{"status":"ok"}\n', "flash"),
+    (lambda t: t.samples({"cmd": "capture", "samples": 4}),
+     b'{"status":"ok","data":[1,2],"more":false}\n', "capture"),
+    (lambda t: list(t.stream_chunks({"cmd": "power_profile"})),
+     b'{"status":"ok","data":{},"more":false}\n', "capture"),
+])
+def test_streaming_sessions_name_their_tunnel_kind(monkeypatch, call, reply, kind):
+    """Each streaming session tells the server what it is for, so a UART console and a capture
+    or power profile can share the pod over the cloud as they do on the LAN."""
+    t = CloudTransport("dev-a", api_base="https://example.test", token="x")
+    kinds = _recording_dial(monkeypatch, t, _FakeSock(reply))
+    call(t)
+    assert kinds == [kind]
+
+
+def test_load_replay_names_the_dac_kind_and_staging_stays_exclusive(monkeypatch):
+    sock, _ = _sending_socket(monkeypatch)
+    sock._ws = _FakeWS([
+        b'{"status":"ok","data":{"ready":4}}\n',
+        b'{"status":"ok","data":{"total":4}}\n',
+        b'{"status":"ok","data":{}}\n',
+    ])
+    t = CloudTransport("dev-a", api_base="https://example.test", token="x")
+    kinds = _recording_dial(monkeypatch, t, sock)
+    t.load_replay(data=b"\x00" * 4, replay={"cmd": "replay"})
+    assert kinds == ["dac"]
+
+    sock._ws = _FakeWS([
+        b'{"status":"ok","data":{"ready":4}}\n',
+        b'{"status":"ok","data":{"total":4}}\n',
+    ])
+    t.stage_psram(b"\x00" * 4)
+    # PSRAM staging for an SPI session has no kind: the server keeps it exclusive.
+    assert kinds == ["dac", None]
 
 
 def _fake_websocket_module(monkeypatch, fail=None):
@@ -209,7 +268,7 @@ def test_cloud_transport_dap_handshake_returns_raw_link(monkeypatch):
     # dap_start acks one JSON line, then the same tunnel carries raw bytes.
     t = CloudTransport("dev-a", api_base="https://example.test", token="x")
     fake = _FakeSock(b'{"status":"ok"}\nRAWBYTES')
-    monkeypatch.setattr(t, "_dial", lambda *_a: fake)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: fake)
 
     link = t.dap_start(swclk=11, swdio=12)
     # Bytes after the ack newline are the raw CMSIS-DAP stream and must survive.
@@ -313,7 +372,7 @@ def test_cloud_load_replay_skips_the_tunnel_ack_lines(monkeypatch):
         b'{"status":"ok","data":{"replaying":true}}\n',
     ])
     t = CloudTransport("dev-a", api_base="https://example.test", token="abc")
-    monkeypatch.setattr(t, "_dial", lambda *_a: sock)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: sock)
     data = t.load_replay(data=b"\x00" * 20000, replay={"cmd": "replay"}, psram=True)
     assert data == {"replaying": True}
     frames = sock._ws.frames
@@ -613,7 +672,7 @@ def test_cloud_tunnel_command_times_out_as_transport_timeout(monkeypatch):
 
     t = CloudTransport("dev-a", api_base="https://example.test", token="x", timeout=5)
     sock = _tunnel_socket(_RaisingWS(websocket.WebSocketTimeoutException("timed out")))
-    monkeypatch.setattr(t, "_dial", lambda *_a: sock)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: sock)
     with pytest.raises(TransportTimeout, match="within 5 s"):
         list(t.stream_chunks({"cmd": "capture", "samples": 16}))
 

{embeddedci-2.7.0 → embeddedci-2.7.1}/tests/test_transport_failures.py

@@ -345,7 +345,7 @@ def test_a_tunnel_closing_mid_upload_is_connection_closed_through_load_replay(mo
     ws.fail_with = websocket.WebSocketConnectionClosedException("gone")
     sock, _ = _tunnel(monkeypatch, ws, clock)
     t = CloudTransport("dev-a", api_base="https://example.test", token="x")
-    monkeypatch.setattr(t, "_dial", lambda *_a: sock)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: sock)
     with pytest.raises(ConnectionClosedError, match="closed while sending"):
         t.load_replay(data=b"\x00" * 20000, replay={"cmd": "replay"})
     assert len(ws.sent) == 5  # the load_bin line and four data frames, then nothing
@@ -360,7 +360,7 @@ def test_a_tunnel_that_stops_taking_data_is_a_transport_timeout(monkeypatch):
     ws.fail_with = websocket.WebSocketTimeoutException("send timed out")
     sock, _ = _tunnel(monkeypatch, ws, clock)
     t = CloudTransport("dev-a", api_base="https://example.test", token="x", timeout=5)
-    monkeypatch.setattr(t, "_dial", lambda *_a: sock)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: sock)
     with pytest.raises(TransportTimeout):
         t.stage_psram(b"\x01" * 5000)
 
@@ -376,7 +376,7 @@ def test_a_large_download_frame_carrying_many_lines_is_split_correctly(monkeypat
     clock = [0.0]
     sock, _ = _tunnel(monkeypatch, _WS([blob[:cut], blob[cut:]]), clock)
     t = CloudTransport("dev-a", api_base="https://example.test", token="x")
-    monkeypatch.setattr(t, "_dial", lambda *_a: sock)
+    monkeypatch.setattr(t, "_dial", lambda *_a, **_k: sock)
     assert t.samples({"cmd": "capture", "samples": 20000}) == list(range(20000))
 
 
@@ -451,7 +451,7 @@ def test_measure_power_over_the_cloud_tunnel_waits_for_its_duration(monkeypatch)
     t = CloudTransport("dev-a", api_base="https://example.test", token="x", timeout=30)
     ws = _WS([b'{"status":"ok","data":{"stats":{"n":1}},"more":false}\n'])
     sock, _ = _tunnel(monkeypatch, ws, [0.0])
-    monkeypatch.setattr(t, "_open_tunnel", lambda: sock)
+    monkeypatch.setattr(t, "_open_tunnel", lambda *_a: sock)
     list(t.stream_chunks({"cmd": "power_profile", "efuse": 1, "duration_ms": 600_000}))
     assert ws.timeout == pytest.approx(630)