rosotacom-dev 2.5.dev65__tar.gz → 2.5.dev67__tar.gz

{rosotacom_dev-2.5.dev65 → rosotacom_dev-2.5.dev67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosotacom-dev
-Version: 2.5.dev65
+Version: 2.5.dev67
 Summary: Host CLI for ROS OTA communication sessions.
 Author: develNor
 License-Expression: BSD-3-Clause
@@ -684,6 +684,13 @@ the [link trace recorder](docs/link-trace.md). It writes
 `link_trace.jsonl` under the same status directory with `/proc/net/dev` counter
 deltas, echo-heartbeat RTT/loss provenance, and an optional modem-metrics hook.
 
+Those counters localise loss to a *direction* and no further. When the question
+is which fragment was lost, whether a retransmit followed, or how one sample's
+sub-messages were spaced, enable the [header-only OTA capture](docs/ota-pcap.md)
+next to them — `shared.ota_pcap.enabled`, off by default, roughly 1 % of payload
+volume, and every packet labelled uplink or downlink. It needs no capability,
+no image change and no extra container.
+
 Convert a recorded link trace into a profiles-file entry when you want to replay
 the same drive conditions in a repeatable benchmark:
 

{rosotacom_dev-2.5.dev65 → rosotacom_dev-2.5.dev67}/README.md

@@ -639,6 +639,13 @@ the [link trace recorder](docs/link-trace.md). It writes
 `link_trace.jsonl` under the same status directory with `/proc/net/dev` counter
 deltas, echo-heartbeat RTT/loss provenance, and an optional modem-metrics hook.
 
+Those counters localise loss to a *direction* and no further. When the question
+is which fragment was lost, whether a retransmit followed, or how one sample's
+sub-messages were spaced, enable the [header-only OTA capture](docs/ota-pcap.md)
+next to them — `shared.ota_pcap.enabled`, off by default, roughly 1 % of payload
+volume, and every packet labelled uplink or downlink. It needs no capability,
+no image change and no extra container.
+
 Convert a recorded link trace into a profiles-file entry when you want to replay
 the same drive conditions in a repeatable benchmark:
 

{rosotacom_dev-2.5.dev65 → rosotacom_dev-2.5.dev67}/docs/findings/README.md

@@ -32,6 +32,7 @@ living verification hook.
 - [A bridge that learns types from the graph cannot use a transport that does not carry the graph](graph-derived-types-block-a-non-graph-transport.md) - over `zenoh_ros2dds` the payload topic never arrived in either run: the bridge routes a topic once a local reader exists and the reader waited for the bridge, leaving only `Pending=1` in a log.
 - [A Fast DDS datagram cap stops every message larger than it](fastdds-datagram-cap-drops-large-samples.md) - copying CycloneDDS's 1200 B fragment size into the Fast DDS OTA profile makes every sample above the cap never arrive, at 1200 B and at 8192 B, sync and async — while the 84 B heartbeat keeps flowing at 10 Hz.
 - [A fragment sized exactly like the datagram cap stops every fragmented sample](cyclone-fragment-equal-to-max-drops-fragmented-samples.md) - CycloneDDS 11.0.1 delivers nothing above one fragment when `FragmentSize` equals `MaxMessageSize`, where 0.10.5 delivers everything on the identical profile; a 40 B string still crosses, and discovery, endpoint announcement and proxy-writer matching all succeed while no sample arrives.
+- [Two CycloneDDS configurations on one domain stop interoperating](one-domain-two-cyclone-configs-stop-interoperating.md) - on 11.0.1 a publisher and a subscriber on the same host and domain deliver nothing when one carries the local profile and the other the OTA profile, where 0.10.5 delivers in all four combinations; discovery, endpoint announcement and matching all succeed while no sample moves.
 - [A lost keyframe silences exactly the next gop_size−2 deltas](keyframe-loss-kills-the-next-deltas.md) - libavcodec emits nothing for them, the last delta decodes with artifacts, the next keyframe restores clean decode; a lost delta never blocks decode — so the display hole is gop_size × frame period, deterministically.
 - [Any transport element in a Fast DDS profile doubles every sample on the wire](a-transport-element-doubles-every-fastdds-sample.md) - 366 datagrams for 180 samples against 183 without it; `<builtinTransports>DEFAULT` is a no-op selection and doubles too, so the trigger is the element's presence — removing it takes the shipped OTA profile from 2.10x the payload to 1.04x at identical delivery.
 - [Lifespan is enforced by one DDS reader and not the other](lifespan-is-enforced-by-one-reader-and-not-the-other.md) - under the same 20% oversubscription both stacks queue alike (472 and 433 delivered at ~1.1-1.2 s); with `lifespan: 0.7` CycloneDDS is unchanged and delivers 9.1% inside the bound, while Fast DDS drops to 4 delivered and never exceeds 570 ms — the policy decides shown-vs-suppressed, not how long the wait is.

rosotacom_dev-2.5.dev67/docs/findings/one-domain-two-cyclone-configs-stop-interoperating.md

@@ -0,0 +1,94 @@
+# Two CycloneDDS Configurations on One Domain Stop Interoperating
+
+## Claim
+
+On CycloneDDS 11.0.1 two participants on the **same host and the same domain**
+exchange no data when they are given different configurations. On 0.10.5 they
+do. Discovery is unaffected in the failing combination — the topic appears in
+`ros2 topic list`, both sides announce their endpoints, the reader builds its
+proxy writers — and no sample is delivered.
+
+This is what a session relies on without saying so. A peer renders two whole
+configurations, a local one and an OTA one, and exports `CYCLONEDDS_URI` twice,
+so the second replaces the first: processes started after it view the *local*
+domain through the *OTA* profile while the relay and the application containers
+view it through the local one. Under 0.10.5 that mixture worked. Under 11.0.1
+the bridge subscribes on the local domain, receives nothing, forwards nothing
+into the OTA domain, and the far peer receives nothing — with every stage
+reporting itself healthy.
+
+## Setup
+
+- Host pair / topology: for the effect itself, one host is enough — two
+  containers from the same communication image, `--network host`, one ROS
+  domain, one publisher and one subscriber. The session it was found in runs
+  across two hosts joined by a point-to-point VPN.
+- Session: none for the isolated measurement; a `std_msgs/msg/String` at 2 Hz
+  and `ros2 topic echo … --once`. The two configurations are the ones a session
+  renders: `cyclonedds_local_participants.xml` and `cyclonedds_tuned.xml`.
+- rosotacom SHA: measured on the packaged 2.5.dev61 images; re-runs record
+  theirs.
+- Profile: none — no impairment; the effect needs none.
+- Seed policy: deterministic (no netem, no random load), `n=1` per cell; the
+  effect is present/absent, not a distribution.
+- Stacks: `ros-kilted-cyclonedds` 0.10.5-2noble against
+  `ros-lyrical-cyclonedds` 11.0.1-4resolute.
+
+## Evidence
+
+| publisher / subscriber | 0.10.5 | 11.0.1 |
+|---|---|---|
+| local / local | 12 B | 12 B |
+| local / **ota** | 12 B | **0** |
+| **ota** / local | 12 B | **0** |
+| ota / ota | 12 B | 12 B |
+
+Inside a failing session, one topic the relay publishes on the local domain:
+
+```
+/com/out/<peer>/can/twist/max10hz/ota_stamped, domain 47
+  subscriber with local_dds.xml : 512 B received
+  subscriber with ota_dds.xml   :   0 B
+domain 47 seen through local_dds.xml : 103 topics
+domain 47 seen through ota_dds.xml   :  29 topics
+```
+
+Ruled out on the way to it, each measured with the real images on the same
+hosts: cross-host delivery, same-host delivery under one profile,
+`com_msgs/msg/OtaStamped`, the container's IPC namespace, `domain_bridge`
+itself (minimal config, the session's full 27-topic config, with and without the
+OTA profile, with and without `ROS_DOMAIN_ID` set), participant count (0, 6 and
+12 extra participants), and adding the local profile's
+`ParticipantIndex`/`MaxAutoParticipantIndex` to the OTA profile.
+
+Verification: automated:
+`pytest tests/unit/test_ota_xml.py::test_shipped_scoped_template_carries_both_domains_and_only_ota_restrictions`
+holds the shape of the configuration that avoids the mixture — OTA restrictions
+scoped to the OTA domain, the local domain left with default discovery. Manual,
+for the effect itself: two containers on one host and one domain, one publisher
+and one subscriber, each given one of the two rendered profiles, all four
+combinations.
+
+## Status
+
+confirmed, 2026-08-20.
+
+Addressed by `cyclonedds_scoped.xml.template`, which carries both domains in one
+file with each section scoped by `Domain Id`, so one configuration can be shared
+by every process on the host. It is an additional template: the two-file
+arrangement is unchanged, and a session that does not name the new one behaves
+exactly as before.
+
+## Publication notes
+
+The reportable part is not "a DDS version changed". It is that a configuration
+which was *never* uniform became load-bearing without anybody choosing it: the
+mixture had been there all along and was harmless, so nothing recorded it as a
+property of the deployment. A measurement stack should state, beside the
+middleware version, whether every process on a domain was configured
+identically — because on one side of that version boundary the answer does not
+matter and on the other it decides whether any data moves.
+
+Second, it is another instance of the same trap as the datagram cap: a link that
+passes discovery, endpoint matching and a heartbeat check while carrying
+nothing. Neither check tests what the payload uses.

rosotacom_dev-2.5.dev67/docs/ota-pcap.md

@@ -0,0 +1,134 @@
+# Header-Only OTA Capture
+
+A passive, header-only packet capture of the OTA link, written beside the
+[link trace](link-trace.md) by the same node:
+
+```text
+session-instances/.../logs/<peer>/status/ota.pcap
+session-instances/.../logs/<peer>/status/ota.json
+```
+
+Enable it in a session definition:
+
+```yaml
+shared:
+  use_status_overview: true
+  ota_pcap:
+    enabled: true
+```
+
+Everything else is optional:
+
+```yaml
+  ota_pcap:
+    enabled: true
+    snaplen: 96        # bytes kept per packet; headers, no payload
+    max_mb: 2000       # ceiling for one capture file
+    peer_filter: true  # keep only packets to or from the remote peer
+```
+
+Off by default, and off is exactly the session that existed before: a
+definition without the block renders the same peer files it always did, which
+a test asserts by rendering both and diffing them.
+
+## What it answers that the link trace cannot
+
+`link_trace.jsonl` counts `/proc/net/dev` bytes per direction once a second.
+That localises loss to a **direction** and no further. It cannot say which
+fragment of which sample was lost, whether a retransmit followed, or how one
+sample's sub-messages were spaced on the wire.
+
+The capture answers those, at roughly 1 % of payload volume. Use the two
+together: the trace is the cheap continuous record, the capture is what you
+turn on for a measurement run.
+
+## What the file is
+
+`LINKTYPE_LINUX_SLL` (113), microsecond `pcap`, snaplen 96 by default. Every
+reader takes it — Wireshark, `tshark`, `scapy`, `capinfos`.
+
+The link type is the important choice. The capture uses a `SOCK_DGRAM` packet
+socket, so one code path works on both link types the fleet has: a VPN `tun`
+device is layer 3 and has no link-layer header at all, while a control-centre
+LAN port is Ethernet. The kernel hands `SOCK_DGRAM` the network-layer packet
+either way, plus the `sockaddr_ll` that `LINKTYPE_LINUX_SLL` is defined over.
+
+That pseudo-header carries the field the analysis is for:
+
+```bash
+# uplink (this host sent it) against downlink, per packet
+tshark -r ota.pcap -T fields -e sll.pkttype | sort | uniq -c
+#   4 = PACKET_OUTGOING, 0 = PACKET_HOST
+```
+
+A `LINKTYPE_RAW` capture would have thrown that away.
+
+Timestamps come from the kernel (`SO_TIMESTAMPNS`), not from the moment python
+reached the packet.
+
+## The sidecar, and the number that matters
+
+`ota.json` is written when the capture stops:
+
+```json
+{
+  "interface": "tun0",
+  "snaplen": 96,
+  "linktype": "LINKTYPE_LINUX_SLL",
+  "filter": "udp and host 10.254.0.37",
+  "promiscuous": false,
+  "packets": 2434,
+  "bytes": 272498,
+  "kernel_drops": 0,
+  "kernel_seen": 4638,
+  "first_timestamp": 1787297717.008177,
+  "last_timestamp": 1787297733.10892,
+  "stopped_because": "signal"
+}
+```
+
+**`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
+result on a link of a few Mbit/s; a non-zero value means this process, not the
+radio.
+
+## Which interface, and the refusal that matters
+
+The interface is not configured. It is resolved from the peer's own OTA
+address by `com_py.link_bytes.resolve_link_interface` — the same resolution the
+status snapshot's `link` block uses, including its refusal to report a loopback
+interface for a non-loopback address. That refusal is issue #267: sampling `lo`
+on a machine that also runs an `-a` recorder reads about 28 Gbit/s next to a
+6 Mbit/s link, and it survived a field session and an offline analysis before
+anyone doubted the number. A capture on the wrong device would be the same
+mistake in a bigger file.
+
+If no interface resolves, the capture is skipped with a warning and the session
+runs on. `shared.ota_pcap.enabled` therefore requires
+`shared.use_status_overview: true`, which is where that resolution lives.
+
+## Privilege, containers, and what the option costs
+
+Nothing is added. The communication container already runs as root with
+`CAP_NET_RAW` in docker's default set, so the capture needs no `--cap-add`, no
+image change, no rebuild and no extra container in `docker ps`.
+
+`CAP_NET_ADMIN` is *not* taken and is not needed: it buys promiscuous mode,
+which this capture deliberately does not use. Everything of interest is
+addressed to or from this host, and promiscuous mode on a control-centre LAN
+port would collect other people's traffic.
+
+The capture runs as a separate process rather than inside the status node's
+thread, so a capture that misbehaves cannot reach the snapshot an operator is
+watching. It is stopped with `SIGINT` and waited for, because that is what
+writes the sidecar JSON.
+
+## Cost
+
+Header-only at 96 bytes: about 6 MB per minute at 500 packets/s, so a two-hour
+run is well under a gigabyte. `max_mb` bounds a mistake — a capture pointed at
+a busy LAN port — rather than shaping a run; when it is reached the capture
+stops and says so in `stopped_because`.
+
+Nothing is transmitted, so the capture costs no link capacity.

rosotacom_dev-2.5.dev67/src/rosotacom/resources/ws/ota_configs/cyclonedds_scoped.xml.template

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+One CycloneDDS configuration for both of a peer's domains, each section scoped
+to the domain it belongs to.
+
+Set it as `shared.rmw.ota.cyclone.config` and leave the local one unset: this
+file already carries the local domain's section, so nothing has to overwrite
+anything.
+
+Why it exists. The two-file arrangement renders a local profile and an OTA
+profile and exports CYCLONEDDS_URI twice, so the second replaces the first and
+every process started after it views the *local* domain through the *OTA*
+profile. On CycloneDDS 0.10.5 that was survivable: participants configured
+differently on one host and one domain still exchanged data. On 11.0.1 they do
+not — they discover each other, announce their endpoints, match, and deliver
+nothing. Measured on one host, one domain, a publisher and a subscriber:
+
+  publisher / subscriber     0.10.5     11.0.1
+  local     / local          12 B       12 B
+  local     / ota            12 B       0
+  ota       / local          12 B       0
+  ota       / ota            12 B       12 B
+
+A session whose relay publishes under one profile and whose bridge subscribes
+under the other therefore hands nothing from the local domain into the OTA
+domain, and the link carries nothing while every stage looks healthy
+(docs/findings/one-domain-two-cyclone-configs-stop-interoperating.md).
+
+Scoping fixes the cause rather than the symptom: the OTA settings apply to the
+OTA domain, the local domain keeps default discovery with room for many
+participants, and one file can be shared by every process on the host.
+
+The two-file arrangement stays exactly as it was — this is an additional
+template, not a replacement, and a session that does not name it is unchanged.
+-->
+<CycloneDDS xmlns="https://cdds.io/config">
+  <!--
+  The OTA domain: interface-pinned, unicast-only, with the datagram caps the
+  provisioned link is sized for. Identical to cyclonedds_tuned.xml except that
+  it says which domain it is for.
+  -->
+  <Domain Id="#ota_domain">
+    <General>
+      <AllowMulticast>false</AllowMulticast>
+      <Interfaces>
+        <NetworkInterface address="#host_ip"/>
+      </Interfaces>
+      <MulticastRecvNetworkInterfaceAddresses>none</MulticastRecvNetworkInterfaceAddresses>
+      <!-- Strictly below MaxMessageSize; see cyclonedds_tuned.xml for what
+           making them equal cost. -->
+      <FragmentSize>1024B</FragmentSize>
+      <MaxMessageSize>1200B</MaxMessageSize>
+      <MaxRexmitMessageSize>1200B</MaxRexmitMessageSize>
+    </General>
+
+    <Discovery>
+      <Peers>
+        <!--peer-block--><Peer Address="#peer"/><!--/peer-block-->
+      </Peers>
+      <EnableTopicDiscoveryEndpoints>false</EnableTopicDiscoveryEndpoints>
+      <LeaseDuration>60s</LeaseDuration>
+      <SPDPInterval>#spdp_interval</SPDPInterval>
+    </Discovery>
+
+    <Internal>
+      <SquashParticipants>true</SquashParticipants>
+    </Internal>
+
+    <Tracing>
+      <Verbosity>config</Verbosity>
+      <OutputFile>/tmp/cyclonedds.log</OutputFile>
+    </Tracing>
+  </Domain>
+
+  <!--
+  The local domain: default discovery, more participants. It pins no interface,
+  disables no multicast and sets no peer list, because intra-host discovery has
+  to keep working — the same reasoning as cyclonedds_local_participants.xml,
+  including why 119 and not higher.
+  -->
+  <Domain Id="#local_domain">
+    <Discovery>
+      <ParticipantIndex>auto</ParticipantIndex>
+      <MaxAutoParticipantIndex>119</MaxAutoParticipantIndex>
+    </Discovery>
+  </Domain>
+</CycloneDDS>

{rosotacom_dev-2.5.dev65 → rosotacom_dev-2.5.dev67}/src/rosotacom/resources/ws/ota_configs/get_ota_xml.py

@@ -15,8 +15,20 @@ import re
 import sys
 import tempfile
 
-
-KNOWN_PLACEHOLDERS = {"#host_ip", "#peer", "#easy_mode_ip", "#spdp_interval"}
+KNOWN_PLACEHOLDERS = {
+    "#host_ip",
+    "#peer",
+    "#easy_mode_ip",
+    "#spdp_interval",
+    #: A template that scopes its settings to one ROS domain resolves these.
+    #: Cyclone applies a <Domain> section to the domain its Id names, so a
+    #: single configuration can hold the OTA settings for the OTA domain and
+    #: leave the local domain alone — which is what lets every process on a
+    #: host share one configuration instead of half of them carrying the OTA
+    #: profile and half the local one.
+    "#local_domain",
+    "#ota_domain",
+}
 PLACEHOLDER_PATTERN = re.compile(r"#[A-Za-z_][A-Za-z0-9_]*")
 DEFAULT_SPDP_INTERVAL = "30s"
 
@@ -48,6 +60,19 @@ def _resolved_address(value: str, label: str) -> str:
     return address
 
 
+def _resolved_domain(value: str, label: str) -> str:
+    """A ROS domain id, validated rather than pasted into the XML.
+
+    An unusable Id is worse than a missing one: Cyclone keeps a <Domain>
+    section it cannot match to any domain, so the settings vanish without a
+    word and the link comes up on defaults.
+    """
+    domain = str(value).strip()
+    if not domain.isdigit() or not 0 <= int(domain) <= 232:
+        raise ValueError(f"{label} must be a ROS domain id between 0 and 232, got {value!r}.")
+    return str(int(domain))
+
+
 def _resolved_spdp_interval(value: str) -> str:
     interval = value.strip().lower()
     if not interval:
@@ -99,9 +124,7 @@ def _expand_peer_block(content: str, peer_ips: list) -> str:
 
     has_markers = PEER_BLOCK_OPEN in content
     if has_markers and (PEER_BLOCK_CLOSE not in content):
-        raise RuntimeError(
-            f"Template has '{PEER_BLOCK_OPEN}' without matching '{PEER_BLOCK_CLOSE}'."
-        )
+        raise RuntimeError(f"Template has '{PEER_BLOCK_OPEN}' without matching '{PEER_BLOCK_CLOSE}'.")
 
     if len(peer_ips) == 1 and not has_markers:
         return content.replace("#peer", peer_ips[0])
@@ -116,9 +139,7 @@ def _expand_peer_block(content: str, peer_ips: list) -> str:
 
     matches = list(PEER_BLOCK_PATTERN.finditer(content))
     if len(matches) != 1:
-        raise RuntimeError(
-            f"Template must contain exactly one peer-block region; found {len(matches)}."
-        )
+        raise RuntimeError(f"Template must contain exactly one peer-block region; found {len(matches)}.")
     m = matches[0]
     block = m.group(1)
     if "#peer" not in block:
@@ -128,11 +149,11 @@ def _expand_peer_block(content: str, peer_ips: list) -> str:
 
     # Preserve the indentation of the marker line so duplicated blocks align.
     line_start = content.rfind("\n", 0, m.start()) + 1
-    indent = content[line_start:m.start()]
+    indent = content[line_start : m.start()]
     sep = ("\n" + indent) if not indent.strip() else ""
 
     rendered = sep.join(block.replace("#peer", ip) for ip in peer_ips)
-    return content[:m.start()] + rendered + content[m.end():]
+    return content[: m.start()] + rendered + content[m.end() :]
 
 
 def main(
@@ -141,12 +162,14 @@ def main(
     peer: str = None,
     easy_mode_ip: str = None,
     spdp_interval: str = DEFAULT_SPDP_INTERVAL,
+    local_domain: str = None,
+    ota_domain: str = None,
 ) -> str:
     path = _template_path(config)
     if not os.path.exists(path):
         raise FileNotFoundError(f"Template not found: {path}")
 
-    with open(path, "r", encoding="utf-8") as f:
+    with open(path, encoding="utf-8") as f:
         content = f.read()
 
     found = set(PLACEHOLDER_PATTERN.findall(content))
@@ -159,9 +182,7 @@ def main(
 
     if "#host_ip" in found:
         if not host_ip:
-            raise RuntimeError(
-                f"Template '{os.path.basename(path)}' uses #host_ip but --host-ip was not provided."
-            )
+            raise RuntimeError(f"Template '{os.path.basename(path)}' uses #host_ip but --host-ip was not provided.")
         content = content.replace("#host_ip", _resolved_address(host_ip, "Host IP"))
 
     if "#easy_mode_ip" in found:
@@ -169,45 +190,60 @@ def main(
             raise RuntimeError(
                 f"Template '{os.path.basename(path)}' uses #easy_mode_ip but --easy-mode-ip was not provided."
             )
-        content = content.replace(
-            "#easy_mode_ip", _resolved_address(easy_mode_ip, "Easy Mode IP")
-        )
+        content = content.replace("#easy_mode_ip", _resolved_address(easy_mode_ip, "Easy Mode IP"))
 
     if "#spdp_interval" in found:
         content = content.replace("#spdp_interval", _resolved_spdp_interval(spdp_interval))
 
+    for placeholder, value, option in (
+        ("#local_domain", local_domain, "--local-domain"),
+        ("#ota_domain", ota_domain, "--ota-domain"),
+    ):
+        if placeholder in found:
+            if value is None or not str(value).strip():
+                raise RuntimeError(
+                    f"Template '{os.path.basename(path)}' uses {placeholder} but {option} was not provided."
+                )
+            content = content.replace(placeholder, _resolved_domain(value, placeholder))
+
     if "#peer" in found:
         if not peer:
-            raise RuntimeError(
-                f"Template '{os.path.basename(path)}' uses #peer but --peer was not provided."
-            )
+            raise RuntimeError(f"Template '{os.path.basename(path)}' uses #peer but --peer was not provided.")
         content = _expand_peer_block(content, _resolve_peer_ips(peer))
 
     return content
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Resolve placeholders in an OTA DDS XML template."
-    )
+    parser = argparse.ArgumentParser(description="Resolve placeholders in an OTA DDS XML template.")
     parser.add_argument(
-        "-c", "--config", required=True,
+        "-c",
+        "--config",
+        required=True,
         help="Template name (e.g. fastdds_v1.xml, cyclonedds.xml, fastdds_easy_mode.xml).",
     )
     parser.add_argument(
-        "-i", "--host-ip", dest="host_ip",
+        "-i",
+        "--host-ip",
+        dest="host_ip",
         help="Resolved local host address (#host_ip).",
     )
     parser.add_argument(
-        "-p", "--peer", dest="peer",
+        "-p",
+        "--peer",
+        dest="peer",
         help="Resolved peer address, or comma-separated addresses (#peer).",
     )
     parser.add_argument(
-        "-e", "--easy-mode-ip", dest="easy_mode_ip",
+        "-e",
+        "--easy-mode-ip",
+        dest="easy_mode_ip",
         help="Resolved Fast DDS Easy Mode address (#easy_mode_ip).",
     )
     parser.add_argument(
-        "-o", "--output", dest="output",
+        "-o",
+        "--output",
+        dest="output",
         help=(
             "Write the rendered XML to this path, atomically. Prefer this over a shell "
             "redirect: `> file` truncates the target before this script runs, so a "
@@ -216,6 +252,16 @@ if __name__ == "__main__":
             "comes up carrying nothing."
         ),
     )
+    parser.add_argument(
+        "--local-domain",
+        dest="local_domain",
+        help="Local ROS domain id, for a template that scopes a section to it (#local_domain).",
+    )
+    parser.add_argument(
+        "--ota-domain",
+        dest="ota_domain",
+        help="OTA ROS domain id, for a template that scopes a section to it (#ota_domain).",
+    )
     parser.add_argument(
         "--spdp-interval",
         dest="spdp_interval",
@@ -224,8 +270,7 @@ if __name__ == "__main__":
     )
     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"})
+    rendered = main(**{k: v for k, v in vars(args).items() if v is not None and k != "output"})
     if not output:
         print(rendered)
         raise SystemExit(0)