Method _heartbeat_loop

relay/server.py:342–409

Send periodic heartbeats to Unity instance. Implements: - Single Outstanding PING: Wait for PONG before sending next PING - 3 consecutive failures → DISCONNECTED - Extended timeout during RELOADING state

(self, instance_id: str)

            logger.warning(f"Unknown Unity message type: {msg_type}")

    async def _heartbeat_loop(self, instance_id: str) -> None:
        """
        Send periodic heartbeats to Unity instance.

        Implements:
        - Single Outstanding PING: Wait for PONG before sending next PING
        - 3 consecutive failures → DISCONNECTED
        - Extended timeout during RELOADING state
        """
        consecutive_failures = 0

        try:
            while self._running:
                # Wait before sending next PING
                await asyncio.sleep(HEARTBEAT_INTERVAL_MS / 1000)

                instance = self.registry.get(instance_id)
                if not instance or not instance.is_connected:
                    break

                # Determine timeout based on instance state
                if instance.status == InstanceStatus.RELOADING:
                    timeout_ms = RELOAD_TIMEOUT_MS
                else:
                    timeout_ms = HEARTBEAT_TIMEOUT_MS

                # Create event for PONG response (Single Outstanding PING)
                pong_event = asyncio.Event()
                self._pending_pongs[instance_id] = pong_event

                try:
                    # Send PING
                    ping = PingMessage()
                    await write_frame(instance.writer, ping.to_dict())
                    logger.debug(f"PING sent to {instance_id}")

                    # Wait for PONG with timeout
                    try:
                        await asyncio.wait_for(pong_event.wait(), timeout=timeout_ms / 1000)
                        # PONG received - reset failure counter
                        consecutive_failures = 0
                        logger.debug(f"Heartbeat OK for {instance_id}")

                    except TimeoutError:
                        consecutive_failures += 1
                        logger.warning(
                            f"Heartbeat timeout for {instance_id} ({consecutive_failures}/{HEARTBEAT_MAX_RETRIES})"
                        )

                        if consecutive_failures >= HEARTBEAT_MAX_RETRIES:
                            logger.error(f"Heartbeat failed {HEARTBEAT_MAX_RETRIES} times, disconnecting {instance_id}")
                            break

                except Exception as e:
                    logger.warning(f"Failed to send heartbeat to {instance_id}: {e}")
                    consecutive_failures += 1
                    if consecutive_failures >= HEARTBEAT_MAX_RETRIES:
                        break