Method fetch_chunk

apps/proxy/live_proxy/input/manager.py:1696–1784

Fetch data from socket with timeout handling

(self)

        self._buffer_check_timers = []

    def fetch_chunk(self):
        """Fetch data from socket with timeout handling"""
        if not self.connected or not self.socket:
            return False

        try:
            # Set timeout for chunk reads
            chunk_timeout = ConfigHelper.chunk_timeout()  # Use centralized timeout configuration

            try:
                # Handle different socket types with timeout
                if hasattr(self.socket, 'recv'):
                    # Standard socket - set timeout
                    original_timeout = self.socket.gettimeout()
                    self.socket.settimeout(chunk_timeout)
                    chunk = self.socket.recv(Config.CHUNK_SIZE)
                    self.socket.settimeout(original_timeout)  # Restore original timeout
                else:
                    # Non-socket file object (io.FileIO from os.fdopen) - use raw
                    # fd + os.read to stay cooperative under gevent.
                    import select as _select
                    import os as _os

                    try:
                        fd = self.socket.fileno()
                    except (ValueError, OSError):
                        self.connected = False
                        return False

                    try:
                        ready, _, _ = _select.select([fd], [], [], chunk_timeout)
                    except (ValueError, OSError):
                        self.connected = False
                        return False

                    if not ready:
                        logger.debug(f"Chunk read timeout ({chunk_timeout}s) for channel {self.channel_id}")
                        return False

                    try:
                        chunk = _os.read(fd, Config.CHUNK_SIZE)
                    except OSError as e:
                        import errno as _errno
                        if e.errno == _errno.EAGAIN and (self.stop_requested or not self.running):
                            self.connected = False
                            return False
                        logger.warning(f"Read error for channel {self.channel_id}: {e}")
                        self.connected = False
                        return False

            except socket.timeout:
                # Socket timeout occurred
                logger.debug(f"Socket timeout ({chunk_timeout}s) for channel {self.channel_id}")
                return False

            if not chunk:
                # Connection closed by server
                logger.warning(f"Server closed connection for channel {self.channel_id}")