diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5089d8e..ebdeea1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -18,6 +18,18 @@ on: description: Include all supported Python versions type: boolean default: false + transport_ref: + description: linkerbot-transport branch, tag or commit (empty uses dependency_ref/main) + type: string + default: "" + hand_ref: + description: linkerbot-hand-python-sdk branch, tag or commit (empty uses dependency_ref/main) + type: string + default: "" + ros_ref: + description: linkerbot-arm-ros2-sdk branch, tag or commit (empty uses dependency_ref/main) + type: string + default: "" schedule: - cron: "17 3 * * 1" @@ -90,7 +102,7 @@ jobs: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-transport path: .ci/transport - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.transport_ref || env.CI_DEPENDENCY_REF }} - uses: actions/setup-python@v7 with: python-version: ${{ matrix.python }} @@ -143,7 +155,7 @@ jobs: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-transport path: .ci/transport - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.transport_ref || env.CI_DEPENDENCY_REF }} - uses: mamba-org/setup-micromamba@v3 with: environment-name: arm-ci @@ -192,7 +204,7 @@ jobs: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-transport path: .ci/transport - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.transport_ref || env.CI_DEPENDENCY_REF }} - uses: actions/setup-python@v7 with: python-version: "3.10" @@ -237,13 +249,13 @@ jobs: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-transport path: .ci/transport - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.transport_ref || env.CI_DEPENDENCY_REF }} - uses: actions/checkout@v7 with: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-hand-python-sdk path: .ci/hand - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.hand_ref || env.CI_DEPENDENCY_REF }} - name: Pin dependency revisions for all integration jobs id: revisions run: | @@ -305,13 +317,13 @@ jobs: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-transport path: .ci/transport - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.transport_ref || env.CI_DEPENDENCY_REF }} - uses: actions/checkout@v7 with: persist-credentials: false repository: ${{ env.CI_DEPENDENCY_OWNER }}/linkerbot-arm-ros2-sdk path: .ci/ros - ref: ${{ env.CI_DEPENDENCY_REF }} + ref: ${{ inputs.ros_ref || env.CI_DEPENDENCY_REF }} - name: Build and test this SDK with latest ROS wrapper run: bash ".ci/ros/docker/verify.sh" "${{ matrix.ros }}" "$PWD" "$PWD/.ci/transport" "$PWD/reports/${{ matrix.ros }}" - uses: actions/upload-artifact@v7 diff --git a/src/linkerbot_arm/comm/can/can.py b/src/linkerbot_arm/comm/can/can.py index 69acc75..259ff85 100644 --- a/src/linkerbot_arm/comm/can/can.py +++ b/src/linkerbot_arm/comm/can/can.py @@ -133,7 +133,7 @@ def _submit_target_frames(self, frames, **options): raise CANError(*error.args) from error return self._tx.submit_fifo_batch(frames, endpoint_id="arm", **options) - def _handle_bus_error(self, error: Exception) -> None: + def _notify_bus_error(self, error: Exception) -> None: # Wake checked-send waiters before callbacks acquire an arm's locks. # Otherwise a lifecycle caller can wait on the TX thread while its # fault callback is waiting for that same caller's motion lock. @@ -142,7 +142,7 @@ def _handle_bus_error(self, error: Exception) -> None: self._tx.abort(error) except Exception: logger.exception("Failed to drain arm transmitter after bus error") - super()._handle_bus_error(error) + super()._notify_bus_error(error) periodic = getattr(self, "_arm_periodic_scheduler", None) if periodic is not None: periodic.close() diff --git a/src/linkerbot_arm/comm/canfd/dispatcher.py b/src/linkerbot_arm/comm/canfd/dispatcher.py index 91505a4..4196d6c 100644 --- a/src/linkerbot_arm/comm/canfd/dispatcher.py +++ b/src/linkerbot_arm/comm/canfd/dispatcher.py @@ -13,7 +13,6 @@ from linkerbot_transport.canfd.dispatcher import ( DEFAULT_MAX_CONSECUTIVE_ERRORS, THREAD_JOIN_TIMEOUT_S, - _QueuedSend, ) from linkerbot_transport.canfd.dispatcher import ( ERROR_BACKOFF_BASE_S as ERROR_BACKOFF_BASE_S, @@ -42,7 +41,7 @@ from linkerbot_transport.canfd.dispatcher import ( time as time, ) -from linkerbot_transport.errors import TransportError +from linkerbot_transport.errors import QueueFullError, TransportError from linkerbot_arm.exceptions import CANError, StateError, ValidationError @@ -56,7 +55,7 @@ def __init__(self, error: BaseException) -> None: class CANFDSendReceipt(Future[None]): - """Original, non-cancellable queued-send Future with transport tracker hooks.""" + """Original Future[None] view of a Transport-owned send receipt.""" def _dispatch(self) -> None: self.set_result(None) @@ -64,13 +63,8 @@ def _dispatch(self) -> None: def _fail(self, error: BaseException) -> None: if isinstance(error, _PreservedFailure): error = error.error - elif not isinstance(error, CANError): - if isinstance(error, TransportError): - mapped = CANError(*error.args) - mapped.__cause__ = error.__cause__ or error.cause or error - error = mapped - else: - error = _send_error(error, "CANFD background send failed") + else: + error = _send_error(error, "CANFD background send failed") self.set_exception(error) @@ -117,17 +111,30 @@ def send(self, message: CANFDMessage) -> CANFDSendReceipt: the returned receipt when the caller must observe backend failures. """ receipt = CANFDSendReceipt() + receipt.set_running_or_notify_cancel() with self._error_lock: if self._bus_error is not None: raise CANError(f"CANFD bus unavailable: {self._bus_error}") if not self._running: raise RuntimeError("Cannot send on a stopped CANFDMessageDispatcher") - self._register_receipt(receipt) + try: + source = super().send(message) + except QueueFullError as error: + raise queue.Full() from error + except TransportError as error: + raise _send_error(error, "CANFD send failed") from error + + def completed(source): try: - self._send_queue.put_nowait(_QueuedSend(message, receipt)) - except BaseException: - self._discard_receipt(receipt) - raise + source.result() + except BaseException as error: + receipt._fail(error) + else: + receipt._dispatch() + + # add_done_callback also handles a send completed before registration. + # Only the Transport receipt participates in its claim/queue lifecycle. + source.add_done_callback(completed) return receipt def stop(self) -> None: @@ -178,13 +185,9 @@ def stop(self) -> None: self._subscribers.clear() self._filtered_subscribers.clear() - def _handle_bus_error(self, error: Exception) -> None: - with self._error_lock: - if self._error_reported: - return - self._error_reported = True - self._running = False - self._bus_error = error + def _notify_bus_error(self, error: Exception) -> None: + # Transport latches both RX and TX faults before entering this hook. + error = _send_error(error, "CANFD bus unavailable") self._fail_all_receipts(_send_error(error, "CANFD bus unavailable")) self._logger.error(f"CANFD bus fatal error, stopping dispatcher: {error}") if self._on_bus_error is not None: @@ -193,22 +196,6 @@ def _handle_bus_error(self, error: Exception) -> None: except Exception as callback_error: self._logger.error(f"Error in on_bus_error callback: {callback_error}") - def _register_receipt(self, receipt: CANFDSendReceipt) -> None: - receipt.set_running_or_notify_cancel() - self._receipts.register(receipt) - - def _discard_receipt(self, receipt: CANFDSendReceipt) -> None: - self._receipts.discard(receipt) - - def _complete_receipt(self, receipt: CANFDSendReceipt) -> None: - self._receipts.succeed(receipt) - - def _fail_receipt(self, receipt: CANFDSendReceipt, error: BaseException) -> None: - self._receipts.fail(receipt, _PreservedFailure(error)) - - def _take_receipt(self, receipt: CANFDSendReceipt) -> bool: - return self._receipts._take(receipt) - def _fail_all_receipts(self, error: BaseException) -> None: self._receipts.fail_all(_PreservedFailure(error)) @@ -216,6 +203,13 @@ def _fail_all_receipts(self, error: BaseException) -> None: def _send_error(error: BaseException, operation: str) -> CANError: if isinstance(error, CANError): return error + if isinstance(error, TransportError): + cause = error.__cause__ or error.cause + if isinstance(cause, CANError): + return cause + wrapped = CANError(*error.args) + wrapped.__cause__ = cause or error + return wrapped wrapped = CANError(f"{operation}: {error}") wrapped.__cause__ = error return wrapped diff --git a/tests/compat/canfd/test_backends.py b/tests/compat/canfd/test_backends.py index e97f7a2..be2ae60 100644 --- a/tests/compat/canfd/test_backends.py +++ b/tests/compat/canfd/test_backends.py @@ -367,7 +367,7 @@ def test_socketcan_models_errors_and_retryable_shutdown(monkeypatch, caplog): transport_socket, "_read_link_state", lambda channel: transport_socket._LinkState( - up=True, fd=True, bitrate=1000000, data_bitrate=5000000 + kind="can", up=True, fd=True, bitrate=1000000, data_bitrate=5000000 ), ) monkeypatch.setattr(can, "Bus", lambda **kw: bus) @@ -444,7 +444,7 @@ def test_socketcan_deferred_receive_error_preserves_arm_frames(monkeypatch): transport_socket, "_read_link_state", lambda channel: transport_socket._LinkState( - up=True, fd=True, bitrate=1000000, data_bitrate=5000000 + kind="can", up=True, fd=True, bitrate=1000000, data_bitrate=5000000 ), ) interface = SocketCANFDBackend("deferred-frame-test") diff --git a/tests/compat/canfd/test_dispatcher.py b/tests/compat/canfd/test_dispatcher.py index 73e23e2..6c16838 100644 --- a/tests/compat/canfd/test_dispatcher.py +++ b/tests/compat/canfd/test_dispatcher.py @@ -518,6 +518,94 @@ def test_receipt_wraps_non_can_backend_errors(error): assert caught.value.__cause__ is error +@pytest.mark.parametrize("early_result", ["success", "failure", "stop"]) +def test_receipt_bridge_handles_completion_before_callback_registration( + monkeypatch, early_result +): + from linkerbot_transport import SendReceipt + + from linkerbot_arm.comm.canfd import CANFDSendReceipt + + parent = dispatcher_module._dispatcher.CANFDMessageDispatcher + original_send = parent.send + native_receipts = [] + interface = FakeInterface() + expected = CANError("physical send failed") + if early_result == "failure": + interface.send_error = expected + + def send_and_complete(self, message): + source = original_send(self, message) + native_receipts.append(source) + if early_result == "stop": + self.stop() + else: + try: + source.result(1) + except CANError: + pass + assert source.done() + return source + + # Keep the stop case queued so its result is independent of worker timing. + if early_result == "stop": + interface.send = lambda *args, **kwargs: release.wait(2) + release = threading.Event() + monkeypatch.setattr(parent, "send", send_and_complete) + monkeypatch.setattr(dispatcher_module, "THREAD_JOIN_TIMEOUT_S", 0.01) + dispatcher = CANFDMessageDispatcher(interface=interface) + try: + receipt = dispatcher.send(CANFDMessage(1, b"x")) + assert type(receipt) is CANFDSendReceipt + assert type(native_receipts[0]) is SendReceipt + assert receipt is not native_receipts[0] + assert receipt.cancel() is False + completed = [] + receipt.add_done_callback(completed.append) + if early_result == "failure": + with pytest.raises(CANError) as caught: + receipt.result(0) + assert caught.value is expected + elif early_result == "stop": + with pytest.raises(StateError, match="stopped before queued send"): + receipt.result(0) + else: + assert receipt.result(0) is None + assert native_receipts[0].claimed_at_s is not None + assert completed == [receipt] + finally: + release.set() + dispatcher._send_thread.join(1) + dispatcher.stop() + + +def test_receipt_callback_stop_preserves_successful_native_batch(): + interface = _BatchInterface() + gate = interface.install_first_send_gate() + dispatcher = CANFDMessageDispatcher(interface=interface) + callback_finished = threading.Event() + + def stop(_): + try: + dispatcher.stop() + finally: + callback_finished.set() + + try: + primer = dispatcher.send(CANFDMessage(0, b"primer")) + wait_until(lambda: interface._gate_count == 1) + receipts = [dispatcher.send(CANFDMessage(i, b"x")) for i in range(1, 4)] + receipts[0].add_done_callback(stop) + gate.set() + assert primer.result(1) is None + assert all(receipt.result(1) is None for receipt in receipts) + assert callback_finished.wait(1) + assert len(interface.batch_calls) == 1 + finally: + gate.set() + dispatcher.stop() + + def test_stop_preserves_best_effort_close_error(caplog): class FailingClose(FakeInterface): def close(self): diff --git a/tests/compat/test_api.py b/tests/compat/test_api.py index 330eb3b..9ab3da8 100644 --- a/tests/compat/test_api.py +++ b/tests/compat/test_api.py @@ -41,8 +41,16 @@ "_lifecycle_release", }, "linkerbot/comm/canfd/socketcan_backend.py": { + "_LinkState.__init__", "SocketCANFDBackend._frame_flags", }, + "linkerbot/comm/canfd/dispatcher.py": { + "CANFDMessageDispatcher._register_receipt", + "CANFDMessageDispatcher._discard_receipt", + "CANFDMessageDispatcher._complete_receipt", + "CANFDMessageDispatcher._fail_receipt", + "CANFDMessageDispatcher._take_receipt", + }, }