Parse PROXY protocol header if enabled. Returns True if parsing is complete (or not applicable), False if more data is needed.

Parse PROXY protocol v1 (text format). Returns buffer with v1 header consumed.

Parse PROXY protocol v1 (text format). Format: PROXY <PROTO> <SRC_ADDR> <DST_ADDR> <SRC_PORT> <DST_PORT>\r\n

Parse PROXY protocol v2 (binary format). Returns buffer with v2 header consumed.

Parse PROXY protocol v2 (binary format).

Parse request using pure Python parser.

Parse request line, return True if complete.

Parse wrk output to extract metrics.

Pause reading from transport due to backpressure.

Number of open fds for a process (Linux /proc).

Number of threads for a process (Linux /proc).

Query the dirty arbiter for worker information. Connects to the dirty arbiter socket and sends a status request. Returns:

Read a chunk of data from the underlying stream.

Read exactly n bytes from internal buffer. Waits for data via the callback-fed buffer instead of StreamReader.

Read and process incoming WebSocket frames.

Read the next message from the stream.

Read the next message from the stream.

Receive exactly n bytes from a socket. Args: sock: Socket to read from n: Number of bytes to read R

Register fork handlers once at module level.

Return True when the response MUST NOT have a body (RFC 9110). Applies to HEAD requests and to status codes that semantically carry no body:

Resume reading from transport.

Main async loop - start server, manage workers.

Main async loop - start server and handle connections.

Run the ASGI lifespan protocol.

ASGI send callable.

Send WebSocket handshake accept response.

Sends the closing frame to the client, if required.

Main async serving loop.

Main async server loop.

Run one HTTP/2 request, answering 500 rather than dropping it.

Set up body state for async reading.

Create callback parser based on http_parser setting. Parser selection: - auto: Use H1CProtocol if available (>= 0.4.1) and no incompa

Perform graceful shutdown.

\ Start the control socket server. The server runs in a background thread and accepts commands via Unix socket.

Send the initial request to the arbiter.

Send the initial request to the arbiter.

\ Stop the control socket server.

Stream chunks from an asynchronous generator. Args: request_id: Request ID for the messages gen: Async gener

Stream chunks from a synchronous generator. Args: request_id: Request ID for the messages gen: Sync generato

Switch to HTTP/2 if this request asks to upgrade. Returns True when the connection has been taken over. Any HTTP/2 bytes the client p

Wait for body data to arrive via callback.

Wait for connection to close after body is finished. This is needed for ASGI apps (like Django) that call receive() to listen for cli

Wait for flow control window to become positive. Returns: int: Available window size, or -1 if waiting failed

Wait for gunicorn to be ready and serving requests.

Benchmark ASGI parser.

Benchmark multiple concurrent streams.

Check memory stability over many iterations.

Benchmark DirtyStreamIterator directly (for comparison with async). Note: This runs the sync iterator within an async context for comparison

Benchmark WSGI parser.

Chat WebSocket - simple broadcast example.

Check if required tools are available.

Check for available load testing tools.

Close this stream normally.

Close the body stream.

Create a worker for testing.

Decode HyBi style WebSocket packets. Returns: {'fin' : 0_or_1, 'opcode' : number, 'mask'

Delete an entire table. Args: table: Table name

Echo WebSocket - sends back whatever it receives.

Encode a worker management message. Args: request_id: Request identifier op: Management operation (MANAGE_OP

Encode a stash operation message. Args: request_id: Unique request identifier (uint64) op: Stash operation c

Encode a status query message. Args: request_id: Request identifier Returns: bytes: Complete messag

Ensure a table exists (create if not exists). This is idempotent - calling it multiple times is safe. Args: tab

Find a free port to bind to.

Mark parsing complete for EOF handling. Call when no more data will be received. Handles edge cases like chunked encoding without fin

Force the connection to close after this request.

Force the connection to close after this request.

Format show all output for display.

Format config output for display.

Format dirty workers output for display.