Method handle_request

gunicorn/dirty/worker.py:315–367

Handle a single request message. Supports both regular (non-streaming) and streaming responses. For streaming, detects if the result is a generator and sends chunk messages followed by an end message. Args: message: Request dict from protocol

(self, message, writer)

                pass

    async def handle_request(self, message, writer):
        """
        Handle a single request message.

        Supports both regular (non-streaming) and streaming responses.
        For streaming, detects if the result is a generator and sends
        chunk messages followed by an end message.

        Args:
            message: Request dict from protocol
            writer: StreamWriter for sending responses
        """
        request_id = message.get("id", str(uuid.uuid4()))
        msg_type = message.get("type")

        if msg_type != DirtyProtocol.MSG_TYPE_REQUEST:
            response = make_error_response(
                request_id,
                DirtyWorkerError(f"Unknown message type: {msg_type}")
            )
            await DirtyProtocol.write_message_async(writer, response)
            return

        app_path = message.get("app_path")
        action = message.get("action")
        args = message.get("args", [])
        kwargs = message.get("kwargs", {})

        # Update heartbeat before executing
        self.notify()

        try:
            result = await self.execute(app_path, action, args, kwargs)

            # Check if result is a generator (streaming)
            if inspect.isgenerator(result):
                await self._stream_sync_generator(request_id, result, writer)
            elif inspect.isasyncgen(result):
                await self._stream_async_generator(request_id, result, writer)
            else:
                # Regular non-streaming response
                response = make_response(request_id, result)
                await DirtyProtocol.write_message_async(writer, response)
        except Exception as e:
            tb = traceback.format_exc()
            self.log.error("Error executing %s.%s: %s\n%s",
                           app_path, action, e, tb)
            response = make_error_response(
                request_id,
                DirtyAppError(str(e), app_path=app_path, action=action,
                              traceback=tb)
            )
            await DirtyProtocol.write_message_async(writer, response)

    async def _stream_sync_generator(self, request_id, gen, writer):
        """