Method _read_next_chunk

gunicorn/dirty/client.py:417–489

Read the next message from the stream.

(self)

            DirtyProtocol.write_message(self.client._sock, request)

    def _read_next_chunk(self):
        """Read the next message from the stream."""
        with self.client._lock:
            # Check total stream deadline
            now = time.monotonic()
            if now >= self._deadline:
                self._exhausted = True
                raise DirtyTimeoutError(
                    "Stream exceeded total timeout",
                    timeout=self.client.timeout
                )

            remaining = self._deadline - now

            # Set socket timeout based on remaining time
            # Fast path: use larger timeout when plenty of time remains
            if remaining > self._TIMEOUT_THRESHOLD:
                read_timeout = self._TIMEOUT_THRESHOLD
            else:
                read_timeout = min(remaining, self._idle_timeout)

            try:
                self.client._sock.settimeout(read_timeout)
                response = DirtyProtocol.read_message(self.client._sock)
            except socket.timeout:
                # Check which timeout was hit
                now = time.monotonic()
                if now >= self._deadline:
                    self._exhausted = True
                    raise DirtyTimeoutError(
                        "Stream exceeded total timeout",
                        timeout=self.client.timeout
                    )
                idle_duration = now - self._last_chunk_time
                self._exhausted = True
                raise DirtyTimeoutError(
                    f"Timeout waiting for next chunk (idle {idle_duration:.1f}s)",
                    timeout=self._idle_timeout
                )
            except Exception as e:
                self._exhausted = True
                self.client._close_socket()
                raise DirtyConnectionError(f"Communication error: {e}") from e

            # Update last chunk time for idle tracking
            self._last_chunk_time = time.monotonic()

            msg_type = response.get("type")

            # Chunk message - return the data
            if msg_type == DirtyProtocol.MSG_TYPE_CHUNK:
                return response.get("data")

            # End message - stop iteration
            if msg_type == DirtyProtocol.MSG_TYPE_END:
                self._exhausted = True
                raise StopIteration