rosotacom-dev 2.5.dev81__tar.gz → 2.5.dev83__tar.gz

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/PKG-INFO

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

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/src/rosotacom/cli.py

@@ -2437,9 +2437,19 @@ def _ota_stop_parts(
 #: How a benchmark's load maps onto `publish-test-topics` flags. The keys are
 #: `_sized_publisher_param_args`'s own, so a load dict travels from the
 #: benchmark to the peer's publisher without being rewritten on the way.
+#:
+#: `size_pattern` and not `pattern`, and that distinction is the whole reason a
+#: mixed-size load never reached a peer. `parse_size_pattern_load` turns one CLI
+#: string into five keys -- `sizes`, `pattern`, `size_pattern`, and one
+#: `size_<label>` per distinct size -- and only three of them used to cross the
+#: hop. A two-size pattern therefore arrived as `pattern=a*6,b*1` with `size_a`
+#: and no `size_b`, and the publisher died on `Pattern references size 'b' but
+#: it was not provided` inside a detached `docker exec`, which the orchestrator
+#: reported as the topic not advertising. Sending the *source* string instead
+#: cannot lose a size, whatever the pattern turns out to contain.
 _OTA_LOAD_FLAGS: tuple[tuple[str, str], ...] = (
     ("size", "--load-size"),
-    ("pattern", "--load-size-pattern"),
+    ("size_pattern", "--load-size-pattern"),
     ("rate", "--load-rate-hz"),
     ("streams", "--load-streams"),
     ("interval_jitter_ms", "--load-interval-jitter-ms"),
@@ -2469,6 +2479,16 @@ def _ota_publish_parts(
         merged = dict(load or {})
         if "size" not in merged and merged.get("size_a") is not None:
             merged["size"] = merged["size_a"]
+        if merged.get("pattern") and not merged.get("size_pattern"):
+            # Only `parse_size_pattern_load` produces `pattern`, and it always
+            # produces `size_pattern` beside it. A load carrying one without the
+            # other was assembled by hand, and sending the expanded form would
+            # drop every size but the first -- loudly here rather than as a peer
+            # whose publisher will not start.
+            raise RuntimeError(
+                f"load carries pattern {merged['pattern']!r} without the size pattern it came from; "
+                "build it with parse_size_pattern_load so every size reaches the peer."
+            )
         for key, flag in _OTA_LOAD_FLAGS:
             if merged.get(key) is not None:
                 parts.extend([flag, str(merged[key])])
@@ -3562,6 +3582,35 @@ def _ota_remote_package_dir(peer: OtaSmokePeer, plan: OtaSmokePlan, *, dry_run:
     return located
 
 
+def _ota_missing_project_message(plan: OtaSmokePlan, peer: OtaSmokePeer) -> str:
+    """Why one peer has no project file, in the terms that make it fixable.
+
+    `test -f` failing is the single most common way a checkout-mode run stops,
+    and the bare "exit code 1" it used to raise says nothing about the contract
+    it broke. The path is not resolved per peer: `--project` is split once, on
+    the orchestrator, into (checkout root, path inside it), and that *relative*
+    path is then asserted inside every peer's own `--peer-checkout`. So the
+    peers do not merely need a rosotacom project each — they need the same
+    repository, with the project at the same place in it.
+
+    The failure therefore has two ordinary causes and they want opposite fixes:
+    the peer is behind (sync it), or the project lives in a repository this peer
+    does not have (move the project, or point the peer at the repository that
+    holds it). Naming both is the difference between a minute and an afternoon.
+    """
+    workdir = _ota_peer_workdir(plan, peer)
+    return (
+        f"{peer.name}: {workdir}/{plan.project} does not exist.\n"
+        f"  --install-mode checkout resolves the project once, on this machine, into a checkout root and "
+        f"the path {plan.project!r} inside it, and then asserts that same relative path inside every peer's "
+        f"--peer-checkout. Every peer therefore needs the same repository, with the project at the same "
+        f"place in it -- not a project of its own.\n"
+        f"  If {peer.name} has that repository, it is behind: sync it and run again.\n"
+        f"  If it does not, the project is in the wrong repository for this run. Move it into the one the "
+        f"peers actually have, or give this peer --peer-checkout for a checkout that holds it."
+    )
+
+
 def _ota_verify_checkouts(plan: OtaSmokePlan, *, dry_run: bool) -> None:
     """Checkout mode's replacement for staging: assert, do not install.
 
@@ -3583,13 +3632,16 @@ def _ota_verify_checkouts(plan: OtaSmokePlan, *, dry_run: bool) -> None:
             dry_run=dry_run,
             batch=True,
         )
-        _ota_run(
+        found = _ota_run(
             peer,
             f"test -f {checkout}/{project}",
             label=f"{peer.name}: project config {plan.project} inside the checkout",
             dry_run=dry_run,
+            check=False,
             batch=True,
         )
+        if found.returncode != 0:
+            raise RuntimeError(_ota_missing_project_message(plan, peer))
         _ota_run(
             peer,
             f"{OTA_CHECKOUT_PATH_PREFIX}command -v rosotacom >/dev/null 2>&1",
@@ -7548,6 +7600,33 @@ def _smoke_publish_specs(cfg: dict[str, Any], source_peer_key: str | None = None
     return specs
 
 
+#: Where a detached smoke publisher's own output goes inside its container.
+#: `docker exec -d` returns before the process says anything and keeps nothing,
+#: so without this the only evidence of a publisher that refused to start is the
+#: topic never appearing -- which reads as a broken graph rather than as a bad
+#: parameter. One file per topic, overwritten per attempt.
+_SMOKE_PUBLISHER_LOG_DIR = "/tmp"
+
+
+def _smoke_publisher_log_path(topic: str) -> str:
+    slug = re.sub(r"[^A-Za-z0-9]+", "_", topic).strip("_") or "topic"
+    return f"{_SMOKE_PUBLISHER_LOG_DIR}/rosotacom-smoke-publisher-{slug}.log"
+
+
+def _smoke_publisher_failure_detail(container: str, log_path: str) -> str:
+    """What the publisher said before it stopped, if it said anything."""
+    result = subprocess.run(
+        ["docker", "exec", container, "tail", "-n", "20", log_path],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    detail = ((result.stdout or "") + (result.stderr or "")).strip()
+    if not detail:
+        return f" Nothing was written to {log_path} in the container, so it never got as far as starting."
+    return f"\nWhat it wrote to {log_path}:\n{detail}"
+
+
 def _start_smoke_topic_publishers(
     containers: dict[str, str],
     ros_setups: dict[str, str],
@@ -7574,8 +7653,9 @@ def _start_smoke_topic_publishers(
             f"Starting smoke publisher {spec.source_peer_key}->{spec.receiver_peer_key} "
             f"{spec.publish_topic} ({spec.publish_type}) in {container}{offered}"
         )
+        log_path = _smoke_publisher_log_path(spec.publish_topic)
         subprocess.run(
-            ["docker", "exec", "-d", container, "bash", "-c", cmd],
+            ["docker", "exec", "-d", container, "bash", "-c", f"{{ {cmd} ; }} > {shlex.quote(log_path)} 2>&1"],
             capture_output=True,
             text=True,
             check=False,
@@ -7594,6 +7674,7 @@ def _start_smoke_topic_publishers(
             raise RuntimeError(
                 f"Smoke publisher {spec.source_peer_key}->{spec.receiver_peer_key} "
                 f"{spec.publish_topic} ({spec.publish_type}) did not advertise in {container}."
+                + _smoke_publisher_failure_detail(container, log_path)
             )
     return started
 
@@ -7949,7 +8030,21 @@ def _publish_load_override(args: argparse.Namespace) -> dict[str, Any] | None:
         load["size"] = int(args.load_size)
         load["size_a"] = int(args.load_size)
     if getattr(args, "load_size_pattern", None):
-        load["pattern"] = args.load_size_pattern
+        # Re-derived here rather than carried in pieces: the orchestrator sends
+        # the pattern it was given, and this side expands it into `sizes`,
+        # `pattern` and every `size_<label>` the publisher needs. `size_a` from
+        # `--load-size` above is overwritten on purpose -- a pattern names its
+        # own sizes, and the scalar is only a fallback for callers without one.
+        from .benchmark import parse_size_pattern_load
+
+        try:
+            load.update(parse_size_pattern_load(str(args.load_size_pattern)))
+        except ValueError as error:
+            raise RuntimeError(
+                f"--load-size-pattern {args.load_size_pattern!r} is not a size pattern ({error}). "
+                "An orchestrator older than this peer sends the expanded token form here instead of the "
+                "pattern; the two sides have to agree, so bring them to the same rosotacom."
+            ) from error
     if getattr(args, "load_rate_hz", None) is not None:
         load["rate"] = float(args.load_rate_hz)
     if getattr(args, "load_streams", None) is not None:

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/src/rosotacom_dev.egg-info/PKG-INFO

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

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/src/rosotacom_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "2.4",
-  "distance": 81,
-  "node": "g1d38e8a9bd4fb5e3c9a20c0a1603c365996cc296",
+  "distance": 83,
+  "node": "g5a3561c197b13a9e9d2b6076cde0bc94bfa9afa4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-01"

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/tests/unit/test_cli.py

@@ -3506,6 +3506,32 @@ def test_ota_checkout_mode_runs_each_peer_from_its_own_checkout(tmp_path: Path)
     assert "--rosotacom-config session/rosotacom.yaml" in command
 
 
+def test_ota_checkout_mode_names_the_shared_repository_when_a_peer_lacks_the_project(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # The path is split once here and asserted on every peer, so a peer whose
+    # checkout is a *different* repository fails this probe -- and used to fail
+    # it as a bare "exit code 1", which reads as a broken machine rather than as
+    # the contract it is. Two runs were spent on that in one afternoon: a bench
+    # driven from the harness checkout, with a peer that only has the fleet
+    # repository, cannot resolve one relative path on both sides.
+    plan = _ota_checkout_plan(_write_checkout_project(tmp_path))
+
+    def fake_run(peer, script, *, label, **kwargs):
+        code = 1 if script.startswith("test -f") and peer.name == "b" else 0
+        return subprocess.CompletedProcess([], code, "", "")
+
+    monkeypatch.setattr(rosotacom, "_ota_run", fake_run)
+
+    with pytest.raises(RuntimeError) as error:
+        rosotacom._ota_verify_checkouts(plan, dry_run=False)
+
+    message = str(error.value)
+    assert "/home/other/fleet_mgmt/session/rosotacom.yaml does not exist" in message
+    assert "the same repository" in message
+    assert "it is behind: sync it" in message
+
+
 def test_ota_checkout_mode_puts_pipx_on_path_because_ssh_is_not_a_login_shell(tmp_path: Path) -> None:
     # `ssh host 'cmd'` skips the login profile, so a pipx install in
     # ~/.local/bin is invisible and the peer answers "command not found" —

{rosotacom_dev-2.5.dev81 → rosotacom_dev-2.5.dev83}/tests/unit/test_ota_benchmark_peer_exec.py

@@ -11,12 +11,16 @@ from __future__ import annotations
 
 import argparse
 
+import pytest
+
+from rosotacom.benchmark import parse_size_pattern_load
 from rosotacom.cli import (
     _ota_instances_rel,
     _ota_publish_parts,
     _profile_directions_for,
     _publish_load_override,
 )
+from rosotacom.cli_benchmark import _sized_publisher_param_args
 
 
 class _Target:
@@ -72,11 +76,67 @@ def test_the_benchmark_load_reaches_the_peer_command():
     assert "--load-streams" in parts and parts[parts.index("--load-streams") + 1] == "2"
 
 
-def test_a_size_pattern_travels_as_itself():
-    parts = _ota_publish_parts(_Target(), "a", [], load={"pattern": "a*4,b*1", "size_a": 5000})
-    assert parts[parts.index("--load-size-pattern") + 1] == "a*4,b*1"
+def test_a_size_pattern_travels_as_the_string_it_was_given():
+    """The source pattern, not the expanded token form it was compiled into.
+
+    `parse_size_pattern_load` turns one string into `sizes`, `pattern`,
+    `size_pattern` and a `size_<label>` per distinct size, and only three of
+    those used to cross the hop. A two-size pattern arrived as `a*6,b*1` with a
+    `size_a` and no `size_b`, so the peer's publisher died on `Pattern
+    references size 'b' but it was not provided` -- inside a detached
+    `docker exec`, which the orchestrator could only report as the topic never
+    advertising. Sending the source string cannot lose a size.
+    """
+    load = parse_size_pattern_load("6x200B+1x28000B")
+    parts = _ota_publish_parts(_Target(), "a", [], load=load)
+
+    assert parts[parts.index("--load-size-pattern") + 1] == "6x200B+1x28000B"
+    assert "a*6,b*1" not in parts
     # `size_a` is the pattern's own base size and must reach the peer as --load-size.
-    assert parts[parts.index("--load-size") + 1] == "5000"
+    assert parts[parts.index("--load-size") + 1] == "200"
+
+
+def test_a_hand_built_pattern_load_is_refused_rather_than_silently_truncated():
+    with pytest.raises(RuntimeError, match="without the size pattern it came from"):
+        _ota_publish_parts(_Target(), "a", [], load={"pattern": "a*4,b*1", "size_a": 5000})
+
+
+def test_every_size_of_a_pattern_survives_the_round_trip_to_the_publisher():
+    """Orchestrator load -> peer flags -> peer load -> publisher parameters.
+
+    The end the defect lived at: each step looked right on its own, and only
+    the whole chain shows that the second size never arrives.
+    """
+    parts = _ota_publish_parts(_Target(), "a", [], load=parse_size_pattern_load("6x200B+1x28000B"))
+    args = argparse.Namespace(
+        load_size=int(parts[parts.index("--load-size") + 1]),
+        load_size_pattern=parts[parts.index("--load-size-pattern") + 1],
+        load_rate_hz=None,
+        load_streams=None,
+        load_interval_jitter_ms=None,
+        load_interval_jitter_seed=None,
+    )
+    peer_load = _publish_load_override(args)
+    assert peer_load is not None
+
+    params = _sized_publisher_param_args("/bench_capacity", dict(peer_load))
+
+    assert "size_a:=200" in params
+    assert "size_b:=28000" in params
+    assert "pattern:=a*6,b*1" in params
+
+
+def test_a_peer_newer_than_its_orchestrator_says_so_instead_of_failing_obscurely():
+    args = argparse.Namespace(
+        load_size=5000,
+        load_size_pattern="a*4,b*1",
+        load_rate_hz=None,
+        load_streams=None,
+        load_interval_jitter_ms=None,
+        load_interval_jitter_seed=None,
+    )
+    with pytest.raises(RuntimeError, match="same rosotacom"):
+        _publish_load_override(args)
 
 
 def test_no_load_leaves_the_session_to_say_what_it_expects():