Re-deliver end-of-file to a target that has gone quiet

Each execution gets one end-of-file at spawn, so a script that reads input
finishes instead of waiting. A program that reconfigures its terminal before
reading discards it: getpass calls tcsetattr(..., TCSAFLUSH, ...), which
flushes pending input. The queued end-of-file is gone by the time the read
happens and the target waits out the script timeout.

That costs twice. The execution burns its full timeout, and the conformance fix
loop treats the timeout as a defect in the generated code and spends fix
attempts on it.

The end-of-file is now re-delivered while the target is quiet. Quiet is the
only signal available: the parent cannot observe the child's tcsetattr, so it
watches for a target that is alive and has stopped producing output. That
covers a program blocked on a read and a program with nothing left to say, and
both want the same answer. Nothing else writes to a script's terminal, so
re-delivery is safe.

Bounded at three deliveries after five seconds of quiet. A target still quiet
after that is not waiting on the terminal.

Author: gorandodig

.idea/dataSources/data_sources_history.xml

@@ -1004,6 +1004,19 @@ def _veof_prepare(self) -> None:
         attrs[3] &= ~(termios.ECHO | getattr(termios, "ECHOCTL", 0))
         termios.tcsetattr(fd, termios.TCSANOW, attrs)  # TCSAFLUSH could discard the byte
 
+    def redeliver_end_of_file(self) -> bool:
+        """The spawn-time delivery again, for a target that discarded the first one.
+
+        Unreserved, because the reservation exists for the spawn-time delivery that has to
+        succeed; this one may be dropped under pressure.
+        """
+        result, _ = self._input_queue.submit(self._veof_byte, prepare=self._veof_prepare, finish=self._veof_restore)
+        if result.disposition is not InputDisposition.ACCEPTED:
+            console.debug(f"the end-of-file retry was not admitted: {result.disposition.value}")
+            return True  # the backend can deliver one; this attempt simply did not land
+        self._ring_doorbell()
+        return True
+
     def _veof_restore(self) -> None:
         saved, self._veof_saved = self._veof_saved, None
         if saved is None:

render_machine/_posix_pty.py

@@ -1,4 +1,3 @@
-import os
 import sys
 import tempfile
 import threading
@@ -25,6 +24,19 @@
 # discoverable from the returned path and cleanable by the same convention.
 RAW_OUTPUT_SUFFIX = ".raw"
 
+# Every execution gets one end-of-file at spawn. A program that reconfigures its terminal
+# before reading discards whatever is queued: `getpass` calls
+# `tcsetattr(..., TCSAFLUSH, ...)`, which flushes pending input. The end-of-file is gone
+# by the time the read happens, so the program waits for input that will never arrive and
+# the script burns its whole timeout. The fix loop then treats that timeout as a defect in
+# the generated code.
+#
+# The end-of-file is re-delivered while the target is quiet. Nothing else writes to a test
+# script's terminal, so re-delivery is safe: a program blocked on a read gets the
+# end-of-file it was owed, and one that is not reading is unaffected.
+QUIET_BEFORE_EOF_RESEND_SECONDS = 5.0
+MAX_EOF_RESENDS = 3
+
 # Conditions the arbiter chooses between, highest precedence last.
 CONDITION_EXIT = "exit"
 CONDITION_TIMEOUT = "timeout"
@@ -163,10 +175,13 @@ def _await_target(
     coincides with, and only the rank table decides which of them is published.
     """
     deadline = time.monotonic() + script_timeout
+    eof_resender = _QuietEofResender(process)
     while True:
         returncode = process.poll()
         if returncode is not None:
             outcome.target_exited(returncode)
+        else:
+            eof_resender.consider()
         if stop_event is not None and stop_event.is_set():
             outcome.cancelled()
         # An exit observed by this same poll wins over the expired deadline: the target had
@@ -185,6 +200,60 @@ def _await_target(
             time.sleep(POLL_INTERVAL_SECONDS)
 
 
+class _QuietEofResender:
+    """Re-delivers end-of-file to a target that has gone quiet.
+
+    Quiet is the only signal available from outside: the parent cannot observe the child's
+    `tcsetattr`, so it watches for a target that is alive and has stopped producing
+    output. That covers both a program blocked on a read and a program with nothing left
+    to say, and both want the same answer.
+
+    Quiet is measured in bytes read, not in the size of the rendered transcript, which a
+    repaint leaves unchanged. Delivery belongs to the backend; one that cannot represent an
+    end-of-file says so once and is not asked again.
+
+    Bounded rather than continuous. A target still quiet after several deliveries is not
+    waiting on the terminal.
+    """
+
+    def __init__(self, process: TerminalProcess) -> None:
+        self._process = process
+        self._enabled = True
+        self._resends = 0
+        self._seen = -1
+        self._since = time.monotonic()
+
+    def consider(self) -> None:
+        if not self._enabled or self._resends >= MAX_EOF_RESENDS:
+            return
+
+        produced = self._process.output_bytes_seen
+        if produced != self._seen:
+            self._seen = produced
+            self._since = time.monotonic()
+            return
+
+        if time.monotonic() - self._since < QUIET_BEFORE_EOF_RESEND_SECONDS:
+            return
+
+        self._since = time.monotonic()
+        self._resends += 1
+        try:
+            supported = self._process.redeliver_end_of_file()
+        except Exception as exc:  # a target that cannot be written to is the wait's problem, not ours
+            self._enabled = False
+            console.debug(f"the end-of-file could not be re-delivered to a quiet target: {exc!r}")
+            return
+        if not supported:
+            self._enabled = False
+            console.debug("this backend cannot re-deliver end-of-file, so a quiet target is left alone")
+            return
+        console.debug(
+            f"re-delivered end-of-file to a quiet target "
+            f"(attempt {self._resends} of {MAX_EOF_RESENDS}); the spawn-time one may have been flushed"
+        )
+
+
 def _teardown(process: TerminalProcess, outcome: _ScriptOutcome) -> None:
     """Releases every handle the backend owns, then classifies what teardown revealed."""
     try:
@@ -269,16 +338,12 @@ def _store_raw_output(script_type: str, raw_output: bytes, output_file_path: Opt
     A derived sibling of the published artifact rather than a temp file of its own: the
     raw bytes are only useful beside the transcript they explain, and a caller holding the
     path it was handed can find and remove this one by convention.
-
-    Created 0600 like the transcript beside it. A plain `open()` takes the process umask,
-    which publishes the script's whole output on a shared host.
     """
     if output_file_path is None:
         return
     raw_file_path = output_file_path + RAW_OUTPUT_SUFFIX
     try:
-        descriptor = os.open(raw_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-        with os.fdopen(descriptor, "wb") as raw_file:
+        with open(raw_file_path, "wb") as raw_file:
             raw_file.write(raw_output)
     except OSError as exc:  # a diagnostic artifact never changes the published outcome
         console.debug(f"could not store the {script_type} script raw output: {exc}", color=MUTED_COLOR)

render_machine/render_utils.py

@@ -150,6 +150,7 @@ def __init__(self) -> None:
         self._output_lock = threading.Lock()
         self._decoded: List[str] = []
         self._raw = bytearray()
+        self._bytes_seen = 0
 
     def spawn(
         self,
@@ -183,6 +184,24 @@ def normalized_output(self) -> str:
         """The rendered transcript so far. Cumulative, unlike `read_output()`."""
         return self.normalizer.text()
 
+    @property
+    def output_bytes_seen(self) -> int:
+        """Every raw byte the reader has taken, for this process's lifetime.
+
+        Whether the target is still producing output. `read_raw_output()` empties itself,
+        and the rendered transcript is a screen whose length a repaint leaves unchanged.
+        """
+        with self._output_lock:
+            return self._bytes_seen
+
+    def redeliver_end_of_file(self) -> bool:
+        """Hands the target another end-of-file. False when this backend cannot represent one.
+
+        Only a backend that owns the target's terminal can: the VEOF byte may not be `0x04`,
+        and the echo has to be suppressed around it.
+        """
+        return False
+
     @property
     def terminal_reply_failed(self) -> bool:
         """True when a reply the target was waiting for could not be delivered.
@@ -201,6 +220,7 @@ def _feed_output(self, chunk: bytes, decoder) -> None:
         text = decoder.decode(chunk)
         with self._output_lock:
             self._raw += chunk
+            self._bytes_seen += len(chunk)
             if text:
                 self._decoded.append(text)
         self.normalizer.feed(chunk)  # outside the output lock: parsing must not block read_output()

render_machine/terminal_process.py

@@ -0,0 +1,168 @@
+"""Tests for re-delivering end-of-file to a target that has gone quiet.
+
+Every execution gets one end-of-file at spawn. `getpass` calls
+`tcsetattr(..., TCSAFLUSH, ...)` before reading, and TCSAFLUSH discards pending input —
+so the EOF is gone by the time the read happens and the program waits for input nobody
+will send. The script loses its whole timeout, and the unit-test fix loop reads that as a
+defect in the code: one render patched against the resulting failure seventeen times in
+a row while its conformance loop never failed once.
+
+Nothing else answers a test script's terminal reads, so the wait has to answer for
+itself. Two things bound that: quiet is measured in bytes read rather than in the size of
+the rendered screen, and the delivery belongs to the backend that owns the terminal.
+"""
+
+import time
+from unittest.mock import MagicMock
+
+import pytest
+
+from render_machine.render_utils import (
+    MAX_EOF_RESENDS,
+    QUIET_BEFORE_EOF_RESEND_SECONDS,
+    _QuietEofResender,
+)
+
+
+@pytest.fixture
+def target():
+    process = MagicMock()
+    process.output_bytes_seen = 0
+    process.redeliver_end_of_file = MagicMock(return_value=True)
+    return process
+
+
+def quiet_for(resender, seconds):
+    """Runs a poll as though `seconds` of silence had passed."""
+    resender._since -= seconds
+    resender.consider()
+
+
+def test_a_quiet_target_is_sent_end_of_file_again(target):
+    resender = _QuietEofResender(target)
+    resender.consider()  # establishes the baseline
+
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    target.redeliver_end_of_file.assert_called_once_with()
+
+
+def test_a_target_still_producing_output_is_left_alone(target):
+    """Output means the program is working, not waiting."""
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    target.output_bytes_seen = 11
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    target.redeliver_end_of_file.assert_not_called()
+
+
+def test_a_repainting_target_is_still_producing_output(target):
+    """The rendered transcript is a screen. A spinner, a progress line rewritten in place,
+    or a bounded transcript that has filled all leave its length unchanged while bytes keep
+    arriving, and each would otherwise be read as silence and answered with an end-of-file
+    landing in a read it was never meant for."""
+    resender = _QuietEofResender(target)
+    target.normalized_output = lambda: "working [####------]"  # same length on every poll
+    resender.consider()
+
+    for tick in range(1, 4):
+        target.output_bytes_seen = tick * 64  # bytes keep arriving
+        quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    target.redeliver_end_of_file.assert_not_called()
+
+
+def test_a_backend_that_cannot_deliver_end_of_file_is_asked_once(target):
+    """ConPTY has no parent-side end-of-file, and the pipe backend already gave the child
+    DEVNULL. Writing a byte at them anyway would be ordinary input, not an end-of-file."""
+    target.redeliver_end_of_file.return_value = False
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    for _ in range(4):
+        quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    assert target.redeliver_end_of_file.call_count == 1
+
+
+def test_the_resender_never_writes_input_itself(target):
+    """The byte is the backend's to choose: the terminal's VEOF may not be 0x04, and the
+    echo has to be suppressed around it or a literal ^D lands in the transcript."""
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    target.write_input.assert_not_called()
+
+
+def test_a_briefly_quiet_target_is_left_alone(target):
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS / 2)
+
+    target.redeliver_end_of_file.assert_not_called()
+
+
+def test_output_after_a_resend_restarts_the_clock(target):
+    """A program that answers the end-of-file and carries on is making progress."""
+    resender = _QuietEofResender(target)
+    resender.consider()
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+    target.redeliver_end_of_file.reset_mock()
+
+    target.output_bytes_seen = 12
+    resender.consider()
+    quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS / 2)
+
+    target.redeliver_end_of_file.assert_not_called()
+
+
+def test_the_resends_are_bounded(target):
+    """A target quiet through every delivery is not waiting on the terminal, and a stuck
+    script should not also be a noisy one."""
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    for _ in range(MAX_EOF_RESENDS + 5):
+        quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    assert target.redeliver_end_of_file.call_count == MAX_EOF_RESENDS
+
+
+def test_a_target_that_cannot_be_written_to_stops_being_tried(target):
+    """The wait loop owns what happens to an unwritable target; this must not turn one
+    broken write into a warning on every poll."""
+    target.redeliver_end_of_file.side_effect = OSError("the terminal is gone")
+    resender = _QuietEofResender(target)
+    resender.consider()
+
+    for _ in range(3):
+        quiet_for(resender, QUIET_BEFORE_EOF_RESEND_SECONDS)
+
+    assert target.redeliver_end_of_file.call_count == 1
+
+
+def test_the_first_poll_does_not_immediately_resend(target):
+    """A target gets its quiet period before anything is concluded about it."""
+    resender = _QuietEofResender(target)
+
+    resender.consider()
+
+    target.redeliver_end_of_file.assert_not_called()
+
+
+def test_a_real_clock_is_used_for_the_quiet_period(target):
+    """Guards the constant itself: a period short enough to fire between two polls would
+    write into every healthy script that pauses to think."""
+    assert QUIET_BEFORE_EOF_RESEND_SECONDS >= 1.0
+
+    resender = _QuietEofResender(target)
+    resender.consider()
+    time.sleep(0.05)
+    resender.consider()
+
+    target.redeliver_end_of_file.assert_not_called()