rosotacom-dev 2.5.dev71__tar.gz → 2.5.dev73__tar.gz

{rosotacom_dev-2.5.dev71 → rosotacom_dev-2.5.dev73}/PKG-INFO

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

{rosotacom_dev-2.5.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/src/rosotacom/cli.py

@@ -794,6 +794,31 @@ def _new_instance_id() -> str:
     return hashlib.sha1(seed.encode("utf-8")).hexdigest()[:8]
 
 
+#: The timestamp every instance directory carries between its session slug and
+#: its id: `<slug>_YYYY-MM-DD_HH-MM-SS_<id>`. Spelled out digit by digit rather
+#: than left as `*`, because a session's name may be a *prefix* of another
+#: session's name and `f"{slug}_*"` then collects the other session's instances
+#: too. `ccng_remote_assist_*` matches every `ccng_remote_assist_kilted_dds_*`,
+#: and because the matches are ordered by name, `[-1]` answers with the wrong
+#: session's run whenever the longer name sorts after a digit — which `k` does.
+#:
+#: That is not hypothetical. On 2026-08-21 it made `rosotacom status
+#: ccng_remote_assist` report a `ccng_remote_assist_kilted_dds` run that had
+#: been shut down 45 minutes earlier, so three two-host runs concluded their
+#: link never came up while it was in fact carrying traffic for eleven minutes.
+#: Nothing in the reading said it came from another session.
+_INSTANCE_STAMP_GLOB = "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]_[0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
+
+
+def _instance_glob(session_slug: str, instance_id: str | None = None) -> str:
+    """The pattern matching this session's instances, and no other session's.
+
+    With the stamp pinned, the names sort chronologically, so `sorted(...)[-1]`
+    is the newest instance rather than merely the last name.
+    """
+    return f"*/{session_slug}_{_INSTANCE_STAMP_GLOB}_{instance_id or '*'}"
+
+
 def _session_instances_root(runtime: RuntimeConfig) -> Path:
     return (runtime.session_instances_dir or (Path.cwd() / "session-instances")).resolve()
 
@@ -818,7 +843,7 @@ def _resolve_session_instance(
     resolved_instance_id = _safe_path_token(instance_id or _new_instance_id())
 
     if instance_id:
-        matches = sorted(root.glob(f"*/{session_slug}_*_{resolved_instance_id}"))
+        matches = sorted(root.glob(_instance_glob(session_slug, resolved_instance_id)))
         if matches:
             host_dir = matches[-1].resolve()
         else:
@@ -8781,10 +8806,7 @@ def smoke(args: argparse.Namespace) -> int:
 def _find_latest_instance_dir(runtime: RuntimeConfig, session: ResolvedSession, instance_id: str | None) -> Path:
     root = _session_instances_root(runtime)
     session_slug = _session_instance_slug(session, runtime)
-    if instance_id:
-        pattern = f"*/{session_slug}_*_{_safe_path_token(instance_id)}"
-    else:
-        pattern = f"*/{session_slug}_*"
+    pattern = _instance_glob(session_slug, _safe_path_token(instance_id) if instance_id else None)
     matches = sorted(p for p in root.glob(pattern) if p.is_dir())
     if not matches:
         raise RuntimeError(

{rosotacom_dev-2.5.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/src/rosotacom_dev.egg-info/PKG-INFO

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

rosotacom_dev-2.5.dev73/src/rosotacom_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.4",
+  "distance": 73,
+  "node": "g25251cbc0967cd74a2417b707e9062c0b520491e",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-22"
+}

{rosotacom_dev-2.5.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/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.dev71 → rosotacom_dev-2.5.dev73}/tests/unit/test_concurrency.py

@@ -943,3 +943,76 @@ def test_a_pinned_peer_confines_its_containers(tmp_path: Path) -> None:
     # And without one, nothing is added: the flag must not appear on a peer that
     # was never pinned, or every unpinned run changes shape too.
     assert "--cpuset" not in rosotacom._ota_start_parts(target, "a", "id-1", [], mode="detached")
+
+
+# --------------------------------------------------- instance resolution by name
+#
+# A session's instances are found by globbing its slug. The slug of one session
+# can be a prefix of another's — `ccng_remote_assist` and
+# `ccng_remote_assist_kilted_dds` are the pair that exposed it — and a pattern
+# that ends the slug with `*` then matches both. The matches are ordered by
+# name, so the answer is whichever sorts last, and a letter sorts after a digit:
+# the *other* session's run wins over this session's own newest one.
+#
+# What that cost: on 2026-08-21 `rosotacom status ccng_remote_assist` reported a
+# `ccng_remote_assist_kilted_dds` run that had been shut down 45 minutes
+# earlier. Three two-host runs waited ten minutes each and concluded their link
+# never came up, while their own status file said it had been OK the whole time.
+
+
+def _session(tmp_path: Path, name: str) -> rosotacom.ResolvedSession:
+    host_dir = tmp_path / "sessions" / name
+    host_dir.mkdir(parents=True, exist_ok=True)
+    return rosotacom.ResolvedSession(host_dir, f"/session/{name}", "test")
+
+
+def _instance(root: Path, slug: str, stamp: str, instance_id: str) -> Path:
+    day, _, _ = stamp.partition("_")
+    path = root / day / f"{slug}_{stamp}_{instance_id}"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def test_a_longer_session_name_does_not_capture_this_session_s_instances(tmp_path: Path) -> None:
+    runtime = _runtime(tmp_path)
+    root = tmp_path / "instances"
+    mine = _instance(root, "ccng_remote_assist", "2026-08-21_21-42-01", "35285739")
+    # Older, another session, and its name sorts after mine because 'k' > '2'.
+    _instance(root, "ccng_remote_assist_kilted_dds", "2026-08-21_20-57-05", "52a752d6")
+
+    found = rosotacom._find_latest_instance_dir(runtime, _session(tmp_path, "ccng_remote_assist"), None)
+
+    assert found == mine.resolve()
+
+
+def test_the_longer_name_still_finds_its_own_newest(tmp_path: Path) -> None:
+    runtime = _runtime(tmp_path)
+    root = tmp_path / "instances"
+    _instance(root, "ccng_remote_assist", "2026-08-21_21-42-01", "35285739")
+    _instance(root, "ccng_remote_assist_kilted_dds", "2026-08-21_20-48-37", "643792ab")
+    newest = _instance(root, "ccng_remote_assist_kilted_dds", "2026-08-21_20-57-05", "52a752d6")
+
+    found = rosotacom._find_latest_instance_dir(runtime, _session(tmp_path, "ccng_remote_assist_kilted_dds"), None)
+
+    assert found == newest.resolve()
+
+
+def test_instances_are_ordered_by_their_stamp(tmp_path: Path) -> None:
+    runtime = _runtime(tmp_path)
+    root = tmp_path / "instances"
+    _instance(root, "link", "2026-08-20_23-59-59", "aaaaaaaa")
+    newest = _instance(root, "link", "2026-08-21_00-00-01", "00000000")
+
+    found = rosotacom._find_latest_instance_dir(runtime, _session(tmp_path, "link"), None)
+
+    # The id sorts first among these two; the stamp is what has to decide.
+    assert found == newest.resolve()
+
+
+def test_a_named_instance_of_another_session_is_not_answered(tmp_path: Path) -> None:
+    runtime = _runtime(tmp_path)
+    root = tmp_path / "instances"
+    _instance(root, "ccng_remote_assist_kilted_dds", "2026-08-21_20-57-05", "52a752d6")
+
+    with pytest.raises(RuntimeError, match="No session instance found"):
+        rosotacom._find_latest_instance_dir(runtime, _session(tmp_path, "ccng_remote_assist"), "52a752d6")

{rosotacom_dev-2.5.dev71 → rosotacom_dev-2.5.dev73}/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)