rosotacom-dev 2.5.dev70__tar.gz → 2.5.dev72__tar.gz

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev70
+Version: 2.5.dev72
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/docs/findings/cyclone-fragment-equal-to-max-drops-fragmented-samples.md

@@ -73,6 +73,21 @@ the same MTU budget the 1200 B was chosen for — only the header room is added
 and the value works on both versions, so it is one number rather than a branch
 on the distribution.
 
+The 1200 B profile stays reachable, deliberately. It is what every 0.10.5 run
+before 2026-08-20 carried, so a comparison against one of those runs has to be
+able to reproduce it rather than approximate it:
+
+```yaml
+shared:
+  rmw:
+    ota:
+      cyclone: {config: cyclonedds_tuned.xml, fragment_size: 1200B}
+```
+
+`get_ota_xml.py` warns on stderr whenever the rendered fragment reaches the
+datagram cap, naming 11.0.1 — a profile worth choosing on purpose is not one
+worth choosing by accident.
+
 ## Publication notes
 
 A distribution bump silently changed what a profile *means*, and the profile

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/docs/ota-pcap.md

@@ -87,6 +87,16 @@ reached the packet.
 }
 ```
 
+`stopped_because` reads `running` until something stops the capture, and that
+is deliberate: **neither file depends on a clean shutdown.** A session usually
+ends by its container being stopped, which does not reach this process as a
+signal it can act on — the first bench run ended exactly that way and left a
+pcap truncated at a buffer boundary and no sidecar at all. The pcap is flushed
+once a second and the sidecar is written at the start and rewritten on the same
+interval, so a killed capture still leaves a readable file and a description of
+it. Verified by `SIGKILL`ing a running capture: `capinfos` reads the pcap and
+the sidecar reports the packets up to the last checkpoint.
+
 **`kernel_drops` is a gap in the file, not on the link.** A capture that fell
 behind looks exactly like radio loss to anyone reading the pcap months later,
 so subtract it before reading any loss out of the capture. Zero is the normal

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/ota_configs/cyclonedds_scoped.xml.template

@@ -47,8 +47,9 @@ template, not a replacement, and a session that does not name it is unchanged.
       </Interfaces>
       <MulticastRecvNetworkInterfaceAddresses>none</MulticastRecvNetworkInterfaceAddresses>
       <!-- Strictly below MaxMessageSize; see cyclonedds_tuned.xml for what
-           making them equal cost. -->
-      <FragmentSize>1024B</FragmentSize>
+           making them equal cost, and for why the number is settable
+           (`shared.rmw.<side>.cyclone.fragment_size`) rather than literal. -->
+      <FragmentSize>#fragment_size</FragmentSize>
       <MaxMessageSize>1200B</MaxMessageSize>
       <MaxRexmitMessageSize>1200B</MaxRexmitMessageSize>
     </General>

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/ota_configs/cyclonedds_tuned.xml.template

@@ -16,8 +16,15 @@
                  sample: 1200/1200 delivers nothing on 11.0.1 and everything on
                  0.10.5; 1024/1200 delivers on both. The datagram stays inside the
                  same MTU budget the 1200B was chosen for; only the header room is
-                 added. -->
-            <FragmentSize>1024B</FragmentSize>
+                 added.
+
+                 The default is that 1024B. It is a placeholder rather than a literal
+                 because both values are correct on 0.10.5, so which one a run used is
+                 a property of the session and not of the installed package version:
+                 `shared.rmw.<side>.cyclone.fragment_size`. Asking for one that fills
+                 the datagram is allowed — it is what the Kilted-era link ran — and
+                 get_ota_xml.py says so on stderr rather than refusing. -->
+            <FragmentSize>#fragment_size</FragmentSize>
             <MaxMessageSize>1200B</MaxMessageSize>
             <MaxRexmitMessageSize>1200B</MaxRexmitMessageSize>
         </General>

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/ota_configs/get_ota_xml.py

@@ -2,8 +2,9 @@
 """Unified OTA DDS XML generator.
 
 Loads an XML template from /ws/ota_configs/<config>(.template), detects which
-placeholders it uses (#host_ip, #peer, #easy_mode_ip, #spdp_interval),
-substitutes already resolved addresses, and prints the resulting XML to stdout.
+placeholders it uses (#host_ip, #peer, #easy_mode_ip, #spdp_interval,
+#fragment_size), substitutes already resolved addresses, and prints the
+resulting XML to stdout.
 
 Replaces the old per-template scripts (get_fastdds_xml.py,
 get_fastdds_easy_mode_xml.py, get_cyclonedds_xml.py).
@@ -28,9 +29,22 @@ KNOWN_PLACEHOLDERS = {
     #: profile and half the local one.
     "#local_domain",
     "#ota_domain",
+    #: How large an RTPS fragment this link sends. A template resolves it so
+    #: that the number is a property of the session rather than of the
+    #: installed package: 1024B and 1200B are both correct on CycloneDDS
+    #: 0.10.5, only the smaller one is correct on 11.0.1, and a run comparing
+    #: the two ROS distributions has to be able to say which it used.
+    "#fragment_size",
 }
 PLACEHOLDER_PATTERN = re.compile(r"#[A-Za-z_][A-Za-z0-9_]*")
 DEFAULT_SPDP_INTERVAL = "30s"
+#: Strictly below the templates' MaxMessageSize; see cyclonedds_tuned.xml for
+#: what making the two equal cost under ROS 2 Lyrical.
+DEFAULT_FRAGMENT_SIZE = "1024B"
+
+#: CycloneDDS size suffixes, and what each one is worth in bytes.
+SIZE_UNITS = {"B": 1, "KB": 1000, "KIB": 1024, "MB": 1000_000, "MIB": 1024 * 1024}
+SIZE_PATTERN = re.compile(r"(\d+)\s*(B|kB|KB|KiB|MB|MiB)?\Z")
 
 
 def _template_path(name: str) -> str:
@@ -86,6 +100,60 @@ def _resolved_spdp_interval(value: str) -> str:
     return interval
 
 
+def _parse_size(value: str) -> int:
+    """A CycloneDDS size, in bytes, or None when it is not one this script wrote.
+
+    Used both to validate what a session asked for and to read the template's
+    own MaxMessageSize back out of the rendered XML, so the warning below can
+    compare the two.
+    """
+    match = SIZE_PATTERN.fullmatch(value.strip())
+    if not match:
+        return None
+    return int(match.group(1)) * SIZE_UNITS[(match.group(2) or "B").upper()]
+
+
+def _resolved_fragment_size(value: str) -> str:
+    size = value.strip()
+    if not size:
+        raise ValueError("Fragment size must be a non-empty size.")
+    parsed = _parse_size(size)
+    if parsed is None:
+        raise ValueError("Fragment size must be a byte size, e.g. '1024B', '1200B' or '4KiB'.")
+    if parsed <= 0:
+        raise ValueError("Fragment size must be > 0.")
+    return size
+
+
+def _warn_if_fragment_fills_the_datagram(content: str, path: str) -> None:
+    """Say so when the rendered profile is the one Lyrical cannot carry.
+
+    An RTPS message carries headers as well as its fragment, so a fragment of
+    exactly MaxMessageSize cannot be sent at all. CycloneDDS 0.10.5 coped with
+    that; 11.0.1 drops every fragmented sample and drops it silently, with the
+    endpoints matched and small samples still arriving. That combination is a
+    legitimate thing to ask for -- it is what the Kilted-era link ran, and
+    reproducing it is the reason the fragment size is settable -- so this warns
+    rather than refuses. Refusing would make the older profile unreachable; not
+    saying anything would let it be chosen by accident.
+    """
+    fragment = re.search(r"<FragmentSize>([^<]+)</FragmentSize>", content)
+    maximum = re.search(r"<MaxMessageSize>([^<]+)</MaxMessageSize>", content)
+    if not fragment or not maximum:
+        return
+    fragment_bytes = _parse_size(fragment.group(1))
+    maximum_bytes = _parse_size(maximum.group(1))
+    if fragment_bytes is None or maximum_bytes is None or fragment_bytes < maximum_bytes:
+        return
+    print(
+        f"WARNING - {os.path.basename(path)} renders FragmentSize {fragment.group(1)} against "
+        f"MaxMessageSize {maximum.group(1)}. A fragment leaves no room for the RTPS header, so "
+        "on CycloneDDS 11.0.1 (ROS 2 Lyrical) no fragmented sample will arrive, silently. "
+        "Correct on 0.10.5 (Kilted), which is what this profile reproduces.",
+        file=sys.stderr,
+    )
+
+
 def _resolve_peer_ips(value: str) -> list:
     seen = set()
     unique = []
@@ -162,6 +230,7 @@ def main(
     peer: str = None,
     easy_mode_ip: str = None,
     spdp_interval: str = DEFAULT_SPDP_INTERVAL,
+    fragment_size: str = DEFAULT_FRAGMENT_SIZE,
     local_domain: str = None,
     ota_domain: str = None,
 ) -> str:
@@ -195,6 +264,9 @@ def main(
     if "#spdp_interval" in found:
         content = content.replace("#spdp_interval", _resolved_spdp_interval(spdp_interval))
 
+    if "#fragment_size" in found:
+        content = content.replace("#fragment_size", _resolved_fragment_size(fragment_size))
+
     for placeholder, value, option in (
         ("#local_domain", local_domain, "--local-domain"),
         ("#ota_domain", ota_domain, "--ota-domain"),
@@ -211,6 +283,7 @@ def main(
             raise RuntimeError(f"Template '{os.path.basename(path)}' uses #peer but --peer was not provided.")
         content = _expand_peer_block(content, _resolve_peer_ips(peer))
 
+    _warn_if_fragment_fills_the_datagram(content, path)
     return content
 
 
@@ -268,6 +341,12 @@ if __name__ == "__main__":
         default=DEFAULT_SPDP_INTERVAL,
         help=f"CycloneDDS SPDP interval duration (#spdp_interval, default: {DEFAULT_SPDP_INTERVAL}).",
     )
+    parser.add_argument(
+        "--fragment-size",
+        dest="fragment_size",
+        default=DEFAULT_FRAGMENT_SIZE,
+        help=f"CycloneDDS RTPS fragment size (#fragment_size, default: {DEFAULT_FRAGMENT_SIZE}).",
+    )
     args = parser.parse_args()
     output = args.output
     rendered = main(**{k: v for k, v in vars(args).items() if v is not None and k != "output"})

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/ros2src/com_py/com_py/ota_pcap.py

@@ -79,6 +79,15 @@ A capture that quietly drops packets is worse than none: the analysis would
 read the gap as radio loss. So `PACKET_STATISTICS` is read from the kernel and
 the sidecar `.json` reports `kernel_drops` next to `packets`. A non-zero drop
 count means this process fell behind, not that the link did.
+
+Neither file depends on a clean shutdown, and that is deliberate. A session
+usually ends by the container being stopped, which does not reach this process
+as a signal it can act on — the first bench run ended exactly that way and left
+a pcap truncated at a buffer boundary and no sidecar at all. So the pcap is
+flushed on an interval and the sidecar is written at the *start* and rewritten
+on the same interval, with `stopped_because: "running"` until something stops
+it. A killed capture therefore still leaves a readable pcap and a sidecar that
+says what it was and how much it had seen, rather than an unexplained file.
 """
 
 from __future__ import annotations
@@ -135,6 +144,12 @@ DEFAULT_MAX_MB = 2000
 #: is where `kernel_drops` comes from on a burst.
 RCVBUF_BYTES = 4 << 20
 
+#: How often the pcap is flushed and the sidecar rewritten. A session that ends
+#: by having its container stopped never reaches this process, so what is on
+#: disk at any moment is what the run will be read from. One second costs a
+#: ~300-byte write and bounds the loss to the packets of that second.
+CHECKPOINT_S = 1.0
+
 
 def log(message: str) -> None:
     print(f"[ota_pcap] {message}", flush=True)
@@ -326,7 +341,7 @@ class Capture:
         self.kernel_seen = 0
         self.first_ts: float | None = None
         self.last_ts: float | None = None
-        self.stopped_because = "signal"
+        self.stopped_because = "running"
 
     def sidecar(self) -> dict:
         """What the file is, and what it is missing. Written next to the pcap."""
@@ -348,6 +363,14 @@ class Capture:
             "stopped_because": self.stopped_because,
         }
 
+    def write_sidecar(self) -> None:
+        """The sidecar as of now. Cheap enough to call on every checkpoint."""
+        try:
+            self.out.with_suffix(".json").write_text(
+                json.dumps(self.sidecar(), indent=2) + "\n", encoding="utf-8")
+        except OSError as error:
+            log(f"WARN could not write the sidecar: {error}")
+
     def run(self, stop: list) -> None:
         sock = open_socket(self.iface)
         # Root was needed for that one call and for nothing after it.
@@ -360,8 +383,22 @@ class Capture:
         with open(self.out, "wb", buffering=1 << 20) as handle:
             handle.write(pcap_header(self.snaplen))
             self.bytes_written = 24
+            handle.flush()
+            # Written before a single packet arrives, so a capture that is
+            # killed with its container still explains itself.
+            self.write_sidecar()
+            next_checkpoint = time.monotonic() + CHECKPOINT_S
             sock.settimeout(0.5)
             while not stop:
+                # `tick`, not `now`: the timestamp fallback below rebinds `now`
+                # to wall-clock time, and comparing that against a monotonic
+                # deadline would checkpoint on every single packet.
+                tick = time.monotonic()
+                if tick >= next_checkpoint:
+                    next_checkpoint = tick + CHECKPOINT_S
+                    self._collect(sock)
+                    handle.flush()
+                    self.write_sidecar()
                 try:
                     packet, ancdata, _flags, address = sock.recvmsg(65535, ancillary)
                 except socket.timeout:
@@ -395,8 +432,9 @@ class Capture:
                         f"after {self.packets} packets — the recording is untouched")
                     self.stopped_because = "size ceiling"
                     break
-                if self.packets % 20000 == 0:
-                    self._collect(sock)
+            handle.flush()
+        if self.stopped_because == "running":
+            self.stopped_because = "signal"
         self._collect(sock)
         sock.close()
 
@@ -445,9 +483,8 @@ def main(argv: list[str] | None = None) -> int:
         log(f"FAIL {error}")
         return 3
 
+    capture.write_sidecar()
     sidecar = capture.sidecar()
-    args.out.with_suffix(".json").write_text(
-        json.dumps(sidecar, indent=2) + "\n", encoding="utf-8")
     log(f"{sidecar['packets']} packets, {sidecar['bytes'] / 1e6:.1f} MB, "
         f"{sidecar['kernel_drops']} dropped by the kernel")
     if sidecar["kernel_drops"]:

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/session/content/base/session_plugin_base.yaml

@@ -7,6 +7,7 @@ parameters:
   local_config_file: ${peer_dir}/local_dds.xml # destination path for the resolved local DDS XML
   local_easy_mode_ip: # resolved address for #easy_mode_ip (only honored when the template uses it)
   local_spdp_interval: # CycloneDDS SPDP interval override, e.g. 150s. Empty => template default.
+  local_fragment_size: # CycloneDDS RTPS fragment size, e.g. 1200B. Empty => template default.
   use_domain_bridge: false
   local_domain_id:   # pinned per-peer ROS_DOMAIN_ID (from peer_settings.<peer>.domain_id)
   ota_domain_id:
@@ -39,6 +40,7 @@ parameters:
   ota_config_file: ${peer_dir}/ota_dds.xml # destination path for the resolved DDS XML
   ota_easy_mode_ip: # resolved address for #easy_mode_ip (only honored when the template uses it)
   ota_spdp_interval: # CycloneDDS SPDP interval override, e.g. 150s. Empty => template default.
+  ota_fragment_size: # CycloneDDS RTPS fragment size, e.g. 1200B. Empty => template default.
   # Z2D (zenoh_ros2dds) parameters — used only when use_zenoh_ros2dds=true
   zen_mode: # e.g. router, peer or client
   zen_endpoint_role: # e.g. listen or connect
@@ -299,7 +301,7 @@ common:
   before_commands:
     - if [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ]; then export ROS_DOMAIN_ID='${local_domain_id}'; fi
     - if [ '${rmw_local}' != "None" ]; then case ${rmw_local} in cyclone) export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp;; fastdds) export RMW_IMPLEMENTATION=rmw_fastrtps_cpp; export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4};; zenoh) export RMW_IMPLEMENTATION=rmw_zenoh_cpp;; *) export RMW_IMPLEMENTATION='${rmw_local}';; esac; fi
-    - if [ '${local_config_template}' != "None" ] && [ -n '${local_config_template}' ]; then local_args=(--config "${local_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && local_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && local_args+=(--ota-domain "${ota_domain_id}"); [ '${local_easy_mode_ip}' != "None" ] && [ -n '${local_easy_mode_ip}' ] && local_args+=(--easy-mode-ip "${local_easy_mode_ip}"); [ '${local_spdp_interval}' != "None" ] && [ -n '${local_spdp_interval}' ] && local_args+=(--spdp-interval "${local_spdp_interval}"); python3 /ws/ota_configs/get_ota_xml.py "${local_args[@]}" --output "${local_config_file}" || { echo "FATAL - could not render the local DDS profile ${local_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_local} in cyclone) export CYCLONEDDS_URI="file://${local_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${local_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
+    - if [ '${local_config_template}' != "None" ] && [ -n '${local_config_template}' ]; then local_args=(--config "${local_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && local_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && local_args+=(--ota-domain "${ota_domain_id}"); [ '${local_easy_mode_ip}' != "None" ] && [ -n '${local_easy_mode_ip}' ] && local_args+=(--easy-mode-ip "${local_easy_mode_ip}"); [ '${local_spdp_interval}' != "None" ] && [ -n '${local_spdp_interval}' ] && local_args+=(--spdp-interval "${local_spdp_interval}"); [ '${local_fragment_size}' != "None" ] && [ -n '${local_fragment_size}' ] && local_args+=(--fragment-size "${local_fragment_size}"); python3 /ws/ota_configs/get_ota_xml.py "${local_args[@]}" --output "${local_config_file}" || { echo "FATAL - could not render the local DDS profile ${local_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_local} in cyclone) export CYCLONEDDS_URI="file://${local_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${local_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
     - if [ '${before_command}' != "None" ]; then ${before_command}; fi
 
 windows:
@@ -345,7 +347,7 @@ windows:
     if: use_domain_bridge
     splits:
       - commands:
-        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
+        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); [ '${ota_fragment_size}' != "None" ] && [ -n '${ota_fragment_size}' ] && ota_args+=(--fragment-size "${ota_fragment_size}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
         - ros2 run domain_bridge domain_bridge --wait-for-publisher false ${domain_bridge_config_file}
   - name: IN
     if: in
@@ -353,7 +355,7 @@ windows:
       - commands:
         - if [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ]; then export ROS_DOMAIN_ID='${ota_domain_id}'; fi
         - case ${rmw_ota} in cyclone) export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp;; fastdds) export RMW_IMPLEMENTATION=rmw_fastrtps_cpp; export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4};; zenoh) export RMW_IMPLEMENTATION=rmw_zenoh_cpp;; esac
-        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
+        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); [ '${ota_fragment_size}' != "None" ] && [ -n '${ota_fragment_size}' ] && ota_args+=(--fragment-size "${ota_fragment_size}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
         # For zenoh_ros2dds the OTA domain is loopback-only (zenoh is the inter-host
         # transport), so confine discovery to localhost instead of statically peering
         # the remote host — otherwise the OTA-domain DDS double-delivers alongside zenoh.
@@ -380,7 +382,7 @@ windows:
       - commands:
         - if [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ]; then export ROS_DOMAIN_ID='${ota_domain_id}'; fi
         - case ${rmw_ota} in cyclone) export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp;; fastdds) export RMW_IMPLEMENTATION=rmw_fastrtps_cpp; export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4};; zenoh) export RMW_IMPLEMENTATION=rmw_zenoh_cpp;; esac
-        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
+        - if [ '${ota_config_template}' != "None" ] && [ -n '${ota_config_template}' ]; then ota_args=(--config "${ota_config_template}" --host-ip "${ip_local}" --peer "${ip_remote}"); [ '${local_domain_id}' != "None" ] && [ -n '${local_domain_id}' ] && ota_args+=(--local-domain "${local_domain_id}"); [ '${ota_domain_id}' != "None" ] && [ -n '${ota_domain_id}' ] && ota_args+=(--ota-domain "${ota_domain_id}"); [ '${ota_easy_mode_ip}' != "None" ] && [ -n '${ota_easy_mode_ip}' ] && ota_args+=(--easy-mode-ip "${ota_easy_mode_ip}"); [ '${ota_spdp_interval}' != "None" ] && [ -n '${ota_spdp_interval}' ] && ota_args+=(--spdp-interval "${ota_spdp_interval}"); [ '${ota_fragment_size}' != "None" ] && [ -n '${ota_fragment_size}' ] && ota_args+=(--fragment-size "${ota_fragment_size}"); python3 /ws/ota_configs/get_ota_xml.py "${ota_args[@]}" --output "${ota_config_file}" || { echo "FATAL - could not render the OTA DDS profile ${ota_config_template}; refusing to start on defaults." >&2; exit 1; }; case ${rmw_ota} in cyclone) export CYCLONEDDS_URI="file://${ota_config_file}";; fastdds) export FASTDDS_DEFAULT_PROFILES_FILE="${ota_config_file}"; export RMW_FASTRTPS_USE_QOS_FROM_XML=1;; esac; fi
         # For zenoh_ros2dds the OTA domain is loopback-only (zenoh is the inter-host
         # transport), so confine discovery to localhost instead of statically peering
         # the remote host — otherwise the OTA-domain DDS double-delivers alongside zenoh.

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom/resources/ws/session/creation/generate_session_files.py

@@ -194,7 +194,8 @@ class YamlBlockScalar:
 #   - a string: cyclone | fastdds | zenoh_connect_endpoints | zenoh_ros2dds | <raw rmw string>
 #     (zenoh_ros2dds is allowed for ota only; raw rmw strings are for local only)
 #   - a tagged-union mapping with exactly one key (the RMW name):
-#       {cyclone: {config?: <fname.xml>, easy_mode_ip?: <address>, spdp_interval?: <duration>}}
+#       {cyclone: {config?: <fname.xml>, easy_mode_ip?: <address>, spdp_interval?: <duration>,
+#                 fragment_size?: <size, e.g. 1200B>}}
 #       {fastdds: {config?: <fname.xml>, easy_mode_ip?: <address>}}
 #       {zenoh_connect_endpoints: {transport?: tcp|udp, main_peer?: <peer_key>, main_port?: 7447}}
 #       {zenoh_ros2dds: {transport?: udp|tcp, main_peer?: <peer_key>, main_port?: 7447}}
@@ -207,7 +208,11 @@ _OTA_SHORTS = {"cyclone", "fastdds", *_NATIVE_ZENOH_OTA_SHORTS, "zenoh_ros2dds"}
 _LOCAL_SHORTS = {"cyclone", "fastdds", "zenoh"}
 _SHORTCUT_ALLOWED = {"cyclone", "fastdds", "zenoh"}
 
-_DDS_CFG_KEYS = {"config", "easy_mode_ip", "spdp_interval"}
+_DDS_CFG_KEYS = {"config", "easy_mode_ip", "spdp_interval", "fragment_size"}
+#: A CycloneDDS size: digits and an optional unit. Validated here so an
+#: unusable value is a session error rather than a profile the DDS stack
+#: silently ignores on its way to defaults.
+_DDS_SIZE_RE = re.compile(r"(\d+)\s*(B|kB|KB|KiB|MB|MiB)?\Z")
 _ZEN_OTA_CFG_KEYS = {"transport", "main_peer", "main_port"}
 #: Inter-host transports the native zenoh router may be pointed at. Both are
 #: plain zenoh locator schemes; tls/quic would additionally need certificates
@@ -280,6 +285,7 @@ class RmwSideSpec:
     dds_config: Optional[str] = None
     dds_easy_mode_ip: Optional[str] = None
     dds_spdp_interval: Optional[str] = None
+    dds_fragment_size: Optional[str] = None
     # zenoh (native) and zenoh_ros2dds
     zen_main_peer: Optional[str] = None
     zen_transport: Optional[str] = None
@@ -345,6 +351,19 @@ def _parse_rmw_side(value: Any, ctx: str, *, is_local: bool) -> RmwSideSpec:
                 raise RuntimeError(f"{ctx}.{impl}.spdp_interval must be a non-empty duration if provided.")
             _validate_positive_seconds(cfg["spdp_interval"], f"{ctx}.{impl}.spdp_interval")
             spec.dds_spdp_interval = cfg["spdp_interval"].strip()
+        if cfg.get("fragment_size") is not None:
+            if impl != "cyclone":
+                raise RuntimeError(f"{ctx}.{impl}.fragment_size is only supported for CycloneDDS.")
+            if not isinstance(cfg["fragment_size"], str) or not cfg["fragment_size"].strip():
+                raise RuntimeError(f"{ctx}.{impl}.fragment_size must be a non-empty size if provided.")
+            size = cfg["fragment_size"].strip()
+            match = _DDS_SIZE_RE.fullmatch(size)
+            if not match or int(match.group(1)) <= 0:
+                raise RuntimeError(
+                    f"{ctx}.{impl}.fragment_size must be a positive byte size, e.g. '1024B' or '1200B'; "
+                    f"got {cfg['fragment_size']!r}."
+                )
+            spec.dds_fragment_size = size
     elif _is_native_zenoh_ota(impl):
         extra = set(cfg.keys()) - _ZEN_OTA_CFG_KEYS
         if extra:
@@ -2279,6 +2298,8 @@ def func(
                 )
             if side.impl == "cyclone" and side.dds_spdp_interval:
                 items.append(("local_spdp_interval", side.dds_spdp_interval))
+            if side.impl == "cyclone" and side.dds_fragment_size:
+                items.append(("local_fragment_size", side.dds_fragment_size))
         return items
 
     def _build_ota_rmw_items() -> List[Tuple[str, Any]]:
@@ -2306,6 +2327,8 @@ def func(
                 )
             if ota.impl == "cyclone" and ota.dds_spdp_interval:
                 items.append(("ota_spdp_interval", ota.dds_spdp_interval))
+            if ota.impl == "cyclone" and ota.dds_fragment_size:
+                items.append(("ota_fragment_size", ota.dds_fragment_size))
         return items
 
     def _build_zenoh_block(

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev70
+Version: 2.5.dev72
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/src/rosotacom_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "2.4",
-  "distance": 70,
-  "node": "g2a4d43769fad290b84ccf9e3a25455c6e45ce093",
+  "distance": 72,
+  "node": "g35a828b2f75e38e29c67649e1ce73dafee8c561a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/tests/contract/test_generated_topics_have_a_producer.py

@@ -315,7 +315,7 @@ SPEC_OWNS = (
 #: options. Listed by pattern so an unclassified newcomer fails the guard.
 NO_TOPIC = (
     r"dir_path|before_command|peer_dir|session_dir",
-    r"(rmw|ota|local)_(local|ota|config_template|config_file|easy_mode_ip|spdp_interval|domain_id|name)",
+    r"(rmw|ota|local)_(local|ota|config_template|config_file|easy_mode_ip|spdp_interval|fragment_size|domain_id|name)",
     r"domain_bridge_config_file|use_domain_bridge",
     r"ip_(local|remote)|remote_name|qos_config_file|topic_types_file",
     r"in|out|use_zenoh_(rmw|ros2dds)",

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/tests/unit/test_cli.py

@@ -3166,6 +3166,88 @@ def test_run_session_passes_cyclone_spdp_interval_to_plugin(tmp_path: Path) -> N
     assert plugin["parameters"]["ota_spdp_interval"] == "150s"
 
 
+def test_run_session_passes_cyclone_fragment_size_to_plugin(tmp_path: Path) -> None:
+    """The number reaches the peer that renders the profile, not just the YAML."""
+    from session.creation import run_session
+
+    source = tmp_path / "sessions" / "fragment"
+    output = tmp_path / "session-instances" / "2026-01-01" / "fragment_run" / "config"
+    source.mkdir(parents=True)
+    (source / "session-definition.yaml").write_text(
+        "\n".join(
+            [
+                "peers:",
+                "  a: {}",
+                "  b: {}",
+                "shared:",
+                "  rmw:",
+                "    local: cyclone",
+                "    ota:",
+                "      cyclone:",
+                "        fragment_size: 1200B",
+                "topics:",
+                "  a_to_b:",
+                "    - topic: /x",
+                "      type: std_msgs/msg/String",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    peer_dir = run_session._resolve_peer_dir(
+        str(source),
+        str(output),
+        "a",
+        force=True,
+        rewrite_formatting=False,
+        peer_address=["a=127.0.0.1", "b=127.0.0.2"],
+    )
+
+    plugin = yaml.safe_load((Path(peer_dir) / "plugin.yaml").read_text(encoding="utf-8"))
+    assert plugin["parameters"]["ota_fragment_size"] == "1200B"
+
+
+def test_run_session_rejects_a_fragment_size_no_template_can_use(tmp_path: Path) -> None:
+    """An unusable size is a session error, not a profile that renders wrong."""
+    from session.creation import run_session
+
+    source = tmp_path / "sessions" / "bad_fragment"
+    output = tmp_path / "session-instances" / "2026-01-01" / "bad_fragment_run" / "config"
+    source.mkdir(parents=True)
+    (source / "session-definition.yaml").write_text(
+        "\n".join(
+            [
+                "peers:",
+                "  a: {}",
+                "  b: {}",
+                "shared:",
+                "  rmw:",
+                "    local: cyclone",
+                "    ota:",
+                "      cyclone:",
+                "        fragment_size: plenty",
+                "topics:",
+                "  a_to_b:",
+                "    - topic: /x",
+                "      type: std_msgs/msg/String",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    with pytest.raises(RuntimeError, match="positive byte size"):
+        run_session._resolve_peer_dir(
+            str(source),
+            str(output),
+            "a",
+            force=True,
+            rewrite_formatting=False,
+            peer_address=["a=127.0.0.1", "b=127.0.0.2"],
+        )
+
+
 def test_create_session_yaml_injects_catmux_logging_command(tmp_path: Path) -> None:
     from session.creation import create_session_yaml
 

{rosotacom_dev-2.5.dev70 → rosotacom_dev-2.5.dev72}/tests/unit/test_ota_link_configs.py

@@ -91,6 +91,48 @@ def test_only_cyclone_caps_the_datagram_and_fast_dds_must_not() -> None:
         assert "max_msg_size=" not in resolved, config
 
 
+def test_every_bootstrap_forwards_the_fragment_size_it_was_given() -> None:
+    """One forgotten window renders the default and nothing says so.
+
+    The OTA profile is rendered in three windows (COM, IN, OUT) and the local
+    one in a fourth. A session that names a fragment size and gets it in three
+    of the four has two profiles on one host, which is the failure mode
+    cyclonedds_scoped.xml exists to remove — and it would look healthy.
+    """
+    plugin_base = PLUGIN_BASE.read_text(encoding="utf-8")
+
+    assert plugin_base.count('ota_args+=(--fragment-size "${ota_fragment_size}")') == 3
+    assert plugin_base.count('local_args+=(--fragment-size "${local_fragment_size}")') == 1
+    # Declared, so an unset one renders as "None" and is skipped rather than
+    # left as a literal ${...} in the command line.
+    assert "\n  ota_fragment_size:" in plugin_base
+    assert "\n  local_fragment_size:" in plugin_base
+
+
+def test_a_session_may_ask_the_packaged_templates_for_the_older_profile() -> None:
+    """Both shipped Cyclone OTA templates resolve the size, not just one.
+
+    The two-profile arrangement renders cyclonedds_tuned.xml and the scoped one
+    renders cyclonedds_scoped.xml. A Kilted-versus-Lyrical comparison needs the
+    same fragment size whichever arrangement it runs, so neither template may
+    keep the number as a literal.
+    """
+    module = _load(OTA_CONFIGS / "get_ota_xml.py", "rosotacom_get_ota_xml_fragment")
+    for config in ("cyclonedds_tuned.xml", "cyclonedds_scoped.xml"):
+        rendered = str(
+            module.main(
+                config=config,
+                host_ip="10.0.0.1",
+                peer="10.0.0.2",
+                fragment_size="1200B",
+                local_domain="47",
+                ota_domain="48",
+            )
+        )
+        assert "<FragmentSize>1200B</FragmentSize>" in rendered, config
+        assert f"<MaxMessageSize>{OTA_DATAGRAM_BYTES}B</MaxMessageSize>" in rendered, config
+
+
 def test_both_default_ota_templates_pin_the_interface_and_the_peer() -> None:
     for config in ("cyclonedds_tuned.xml", "fastdds_tuned.xml"):
         resolved = _resolved(config)