Let a client which came back read its events again

Being switched off was a statement about the connection which was bound at the
time - that the client behind it stopped answering - but it used to last for
the life of the layout. A single unanswered message, a page which was reloaded
or a socket which was quietly replaced, left every handler which came after it
reading nothing but ``EventProxyUnavailable`` while a perfectly willing browser
sat on the other end of the new connection.

Binding a sender which is not the one already in place, which is what a
reconnect does, now clears the switch and the timeout budget along with it.
Binding the very same sender again does not, and neither does anything at all
once the layout has closed.

Author: Archmonger

src/reactpy/_event_proxy.py

@@ -161,6 +161,7 @@ def __init__(self) -> None:
         self._send_tasks: set[Any] = set()
         self._timeouts = 0
         self._disabled = False
+        self._closed = False
         # Requests are counted against the round trip which carried them - one send of
         # a batch, or one answer which came back - rather than against each other.
         self._round_trip = 0
@@ -189,11 +190,35 @@ def set_sender(self, send: SendCoroutine) -> None:
         This must be called from the event loop which runs the associated layout since
         live access needs to know both *how* and *from which thread* to talk to the
         browser.
+
+        Binding a *different* sender also brings live access back if an earlier one was
+        switched off. Being switched off is a statement about the connection which was
+        bound at the time - that the client behind it stopped answering - and it says
+        nothing about the client which has just connected. That one has yet to be given
+        the chance to answer for itself.
         """
+        if self._send is not send:
+            self._reactivate()
         self._send = send
         self._loop = asyncio.get_running_loop()
         self._loop_thread_id = threading.get_ident()
 
+    def _reactivate(self) -> None:
+        """Give a newly bound sender the chance to answer for itself
+
+        Without this, being switched off is permanent for the life of the layout, and a
+        single unanswered message - a page which was reloaded, a socket which was
+        replaced - leaves every later handler reading nothing but
+        :class:`EventProxyUnavailable` while a perfectly willing browser sits on the
+        other end of the connection.
+        """
+        if self._closed or not (self._disabled or self._timeouts):
+            return
+        self._disabled = False
+        self._timeouts = 0
+        self._struck.clear()
+        logger.debug("Live event access re-enabled for a newly bound sender")
+
     def disable(self, reason: str) -> None:
         """Stop attempting live access, for example because the client went away"""
         if not self._disabled:
@@ -202,8 +227,13 @@ def disable(self, reason: str) -> None:
         self._abandon_pending(reason)
 
     def close(self) -> None:
-        """Abandon all in-flight requests (called when the layout shuts down)"""
+        """Abandon all in-flight requests (called when the layout shuts down)
+
+        This one is final. Binding a sender afterwards does not bring live access back,
+        because there is no layout left for the answers to belong to.
+        """
         self._disabled = True
+        self._closed = True
         self._abandon_pending("the layout was closed")
 
     def _abandon_pending(self, reason: str) -> None:

src/reactpy/core/layout.py

@@ -212,6 +212,10 @@ def set_event_proxy_sender(
         This must be called from the event loop running the layout, and is what makes
         it possible for event handlers to read properties from, and call methods on,
         the browser objects which triggered them.
+
+        Binding a sender which is not the one already in place - which is what a
+        reconnect does - also brings live access back if an earlier client was switched
+        off for going quiet. A client which has just connected has not failed yet.
         """
         self._event_proxy_sender = send
         backend = getattr(self, "_event_proxy_backend", None)

tests/test_core/test_event_proxy.py

@@ -1003,6 +1003,51 @@ async def test_one_silent_batch_costs_one_timeout(monkeypatch):
     assert backend.disabled, "three dead round trips is a dead connection"
 
 
+async def test_a_client_which_connected_again_can_be_read_again(monkeypatch):
+    """A reconnect is a new client, not the one which stopped answering
+
+    Being switched off used to last for the life of the layout, so one unanswered
+    message - a page which was reloaded, a socket which was quietly replaced - left
+    every handler which came after it reading nothing but ``EventProxyUnavailable``,
+    while a perfectly willing browser sat on the other end of the connection.
+    """
+    monkeypatch.setattr(REACTPY_EVENT_PROXY_TIMEOUT, "current", 0.05)
+    monkeypatch.setattr(REACTPY_EVENT_PROXY_MAX_TIMEOUTS, "current", 1)
+
+    async def silence(message: dict[str, Any]) -> None:
+        return None
+
+    backend = EventProxyBackend()
+    backend.set_sender(silence)
+    event_object = make_event(backend, "evt")
+
+    with pytest.raises(EventProxyTimeout):
+        await event_object.read("target")
+
+    assert backend.disabled
+    backend.set_sender(silence)
+    assert backend.disabled, "the very same silent sender is not a second chance"
+
+    alive = CannedClient(backend, ok=True, value="typed")
+    backend.set_sender(alive.send)
+    assert backend.available, "a client which has just connected has not failed yet"
+    assert await event_object.read("target.value") == ("typed",)
+
+
+async def test_a_closed_layout_does_not_come_back_when_a_sender_appears():
+    """Closing is the layout going away, which no sender can undo"""
+    backend = EventProxyBackend()
+    backend.disable("the client went away")
+    backend.close()
+
+    async def send(message: dict[str, Any]) -> None:
+        return None
+
+    backend.set_sender(send)
+    assert backend.disabled
+    assert not backend.available
+
+
 async def test_failures_the_client_cannot_explain_are_still_reported():
     backend, client = make_canned_client(ok=False)
     event_object = make_event(backend, "evt")