From 28ff528af3fcee3c1ba911f322fd86c49664c984 Mon Sep 17 00:00:00 2001 From: Mike Langmayr Date: Mon, 16 Nov 2026 17:19:32 -0800 Subject: [PATCH] Serialize the DDS binary field in one copy --- libby/cyclonedds_transport.py | 19 +++++++++++++++++-- tests/test_cyclonedds_transport.py | 19 +++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/libby/cyclonedds_transport.py b/libby/cyclonedds_transport.py index 43b5a49..b6c1a8a 100644 --- a/libby/cyclonedds_transport.py +++ b/libby/cyclonedds_transport.py @@ -15,6 +15,7 @@ ReadCondition, SampleState, ViewState, WaitSet) from cyclonedds.domain import Domain, DomainParticipant from cyclonedds.idl import IdlStruct, types +from cyclonedds.idl._machinery import BytesMachine from cyclonedds.pub import DataWriter, Publisher from cyclonedds.sub import DataReader, Subscriber from cyclonedds.topic import Topic @@ -61,6 +62,21 @@ class DdsEnvelope(IdlStruct, typename="libby.Envelope"): # pylint: disable=too- binary: types.sequence[types.uint8] +def _write_binary_in_one_copy() -> None: + """Serialize ``binary`` with ``BytesMachine``, which emits the same CDR as ``sequence``. + + cyclonedds-python packs an octet sequence element by element (8.75 ms per + 512 KB) and cannot build a DDS type object for a ``bytes`` field. + """ + idl = DdsEnvelope.__idl__ # pylint: disable=no-member # set by IdlStruct's metaclass + idl.populate() + for machine in (idl.v1_machine, idl.v2_machine): + machine.members_machines["binary"] = BytesMachine() + + +_write_binary_in_one_copy() + + def to_sample(msg: Message) -> DdsEnvelope: """Encode a bamboo message as a DDS sample.""" env = msg.env @@ -93,8 +109,7 @@ def to_message(sample: DdsEnvelope) -> Message: traceparent=sample.traceparent or None, tracestate=sample.tracestate or None, ) - # An octet sequence reads back as a list of ints - return Message(envelope, bytes(sample.binary) if sample.binary else None) + return Message(envelope, sample.binary or None) def _qos(*partitions: str) -> Qos: diff --git a/tests/test_cyclonedds_transport.py b/tests/test_cyclonedds_transport.py index 49ecab8..9efc689 100644 --- a/tests/test_cyclonedds_transport.py +++ b/tests/test_cyclonedds_transport.py @@ -15,6 +15,8 @@ from bamboo import Envelope, Message, MessageBuilder try: + from cyclonedds.idl import IdlStruct + from cyclonedds.idl._machinery import BytesMachine from libby.cyclonedds_transport import (CycloneDdsTransport, DdsEnvelope, _matched_readers, to_message, to_sample) except ImportError: # cyclonedds is an optional extra @@ -61,6 +63,23 @@ def test_sample_type_covers_every_envelope_field(self): sample_fields = {field.name for field in dataclasses.fields(DdsEnvelope)} self.assertEqual(sample_fields, envelope_fields | {"binary"}) + def test_binary_keeps_the_octet_sequence_wire_format(self): + """Write ``binary`` in one copy, byte-identical to a plain ``sequence``. + + Fails if a cyclonedds upgrade moves the internals the swap relies on. + """ + idl = DdsEnvelope.__idl__ # pylint: disable=no-member # set by IdlStruct's metaclass + self.assertIsInstance(idl.v2_machine.members_machines["binary"], BytesMachine) + # Same fields, built the default way, so binary uses the element-wise machine + reference = dataclasses.dataclass(type( + "ReferenceEnvelope", (IdlStruct,), + {"__annotations__": dict(DdsEnvelope.__annotations__)}, + typename="test.ReferenceEnvelope")) + sample = to_sample(MessageBuilder("hsfei.client").pub("frames", {}) + .binary(bytes(range(256)) * 4).to(None).build()) + self.assertEqual(sample.serialize(), + reference(**dataclasses.asdict(sample)).serialize()) + @unittest.skipIf(CycloneDdsTransport is None, "cyclonedds not installed") class DeliveryTests(unittest.TestCase):