SWPROT-9959: Make ZLF file rotation opt-in on ZlfFileWriter

Disable rotation by default so zniffer only write ZLF data; enable it explicitly for Hardware devices PTI capture.

Author: anrivoal

CHANGES.md

@@ -52,7 +52,7 @@ Release v0.5.1
 
 - ``hw_clusters`` accepts ``clusters.json`` with ``schema_version`` 1 (metadata keys such as ``$schema``, plus a ``clusters`` object with per-cluster ``devices`` arrays). The legacy top-level ``name -> [wpk, ...]`` map remains supported. Serial and board fields are validated on load (see ``clusters_json.load_clusters_json``).
 - Z-Wave sample-app CLI communication uses TCP on port 4901 instead of Telnet (``_CliTcpSocket``, ``run_cmd``). CLI parsers accept an optional ``[I] `` log prefix. ``DevZwaveCli`` adds ``press()`` and ``em1_lock_rtt()``; WPK admin Telnet reconnects on pipe or connection reset.
-- Traces and RTT logs are stored under a per-device subdirectory (``N_FriendlyName``). Zniffer and Railtest skip automatic capture folders. ``ZlfFileWriter`` supports size-based rotation with optional gzip and helpers to list rotated files.
+- Traces and RTT logs are stored under a per-device subdirectory (``N_FriendlyName``). Zniffer and Railtest skip automatic capture folders. ``ZlfFileWriter`` supports optional size-based rotation (enabled for PTI capture via ``max_size_bytes``); standalone tools use the writer without rotation by default.
 - Root ``config.json``, ``conftest.py``, ``pytest.ini``, and ``setup_dev_environment.py`` support local runs. Dev Container, Conan remotes, artifact fetch scripts, ``pick_hw_cluster.py``, and VS Code tasks are included for development setup.
 - Pytest options ``--pti`` and ``--rtt`` enable PTI and RTT capture per test (disabled by default in ``SessionContext``).
 - SOC devices support ``wpk_serial_speed="auto"``: baud rate is read from WPK admin TCP port 4902 (``serial vcom``). NCP device types reject ``"auto"``.

z_wave_ts_silabs/devices.py

@@ -16,7 +16,7 @@
 from .processes import CommanderCli
 from .definitions import AppName, ZwaveAppProductType, ZwaveRegion, ZpalRadioRegion
 from .pcap import PcapFileWriter
-from .zlf import ZlfFileWriter
+from .zlf import PTI_ZLF_MAX_SIZE_BYTES, ZlfFileWriter
 
 
 @dataclass
@@ -330,7 +330,10 @@ def _pti_logger_thread(self, logger_name: str):
         # Redirect DCH output from port 4905; store zniffer (zlf) and pcap in device folder.
         device_dir = self._ctxt.current_test_logdir / logger_name
         device_dir.mkdir(parents=True, exist_ok=True)
-        zlf_file = ZlfFileWriter(device_dir / "trace.zlf")
+        zlf_file = ZlfFileWriter(
+            device_dir / "trace.zlf",
+            max_size_bytes=PTI_ZLF_MAX_SIZE_BYTES,
+        )
         pcap_file = PcapFileWriter(device_dir / "trace.pcap")
         dch_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         dch_socket.connect((self.ip, self.dch_port))

z_wave_ts_silabs/zlf.py

@@ -23,8 +23,8 @@
 _ZLF_DATACHUNK_HEADER_SIZE: int = 5
 _ZLF_API_TYPE_ZNIFFER: int = 0xF5 #  0xF5 is for PTI
 
-# Default max ZLF file size before rotation (50 MiB). Set to None to disable rotation.
-DEFAULT_ZLF_MAX_SIZE_BYTES: int | None = 50 * 1024 * 1024
+# Suggested max size when enabling rotation on long-running captures (50 MiB).
+PTI_ZLF_MAX_SIZE_BYTES: int = 50 * 1024 * 1024
 
 # Minimum size to consider a file as valid ZLF (at least the header)
 _MIN_VALID_ZLF_SIZE = _ZLF_HEADER_SIZE
@@ -193,10 +193,16 @@ def __init__(
         self,
         file_path: Path,
         *,
-        max_size_bytes: int | None = DEFAULT_ZLF_MAX_SIZE_BYTES,
+        max_size_bytes: int | None = None,
         keep_count: int = 0,
         compress_rotated: bool = True,
     ) -> None:
+        """
+        Write Zniffer-compatible ZLF files.
+
+        Rotation is opt-in: pass max_size_bytes (e.g. PTI_ZLF_MAX_SIZE_BYTES) for
+        long-running captures. Short-lived tools and converters can omit it.
+        """
         self.file_path = file_path
         self._max_size_bytes = max_size_bytes
         self._keep_count = keep_count
@@ -228,7 +234,7 @@ def _rotate_if_needed(self) -> None:
         self._create()
 
     def write_datachunk(self, dch_packet: bytes) -> None:
-        """Dumps frame to ZLF file. Rotates when file size exceeds max_size_bytes (default 50 MiB).
+        """Dumps frame to ZLF file. Rotates when max_size_bytes was set and the file exceeds it.
         :param dch_packet: DCH packet directly from WSTK/WPK/TB
         """
         self._rotate_if_needed()

z_wave_ts_silabs/zwave_cli.py

@@ -72,7 +72,7 @@ def read_until(self, match: bytes, timeout: float = 1.0) -> bytes:
         return buffer
 
 
-def run_cmd(sock: _CliTcpSocket, command: str, read_timeout: float = 0.3) -> str:
+def run_cmd(sock: _CliTcpSocket, command: str, read_timeout: float = 1.0) -> str:
     """Execute a command on an open CLI socket and return the response.
 
     Drains any pending data, sends the command, then reads until the prompt ("> ").
@@ -175,7 +175,7 @@ def _run_cmd(self, command: str) -> str:
                if self._cli_socket is None:
                     return ""
                try:
-                    response = run_cmd(self._cli_socket, command, read_timeout=0.3)
+                    response = run_cmd(self._cli_socket, command, read_timeout=1.0)
                     if command not in response or "> " not in response:
                          self.logger.warning(f"Command response not properly synchronized: {response}")
                          extra = self._cli_socket.drain_buffer().decode("ascii", errors="ignore")