Load multiple dirty apps from a list of import paths. Args: import_paths: List of import path strings Returns: dict: Ma

Build a request message dict. Args: request_id: Unique request identifier (int or str) app_path: Import path of the dirty ap

Build a success response message dict. Args: request_id: Request identifier this responds to result: Result value Retur

\ Maintain the number of workers by spawning or killing as required.

Read next body chunk asynchronously for streaming. Returns: bytes: Next chunk of body data, or None if body is complete.

Process received trailing headers. Args: trailers: List of (name, value) tuples

Bytes fed after the completed message (b'' if none or not complete). Matches the accessor H1CProtocol gained in 0.6.8, so a caller does not

Send data on a stream. Args: stream_id: The stream ID data: Body data bytes end_stream: Whether this ends

Determine if the connection should be closed after this request.

\ Spawn the dirty arbiter process. The dirty arbiter manages a separate pool of workers for long-running, blocking operations

Wait for events and dispatch callbacks.

Wait for data to be available on the socket. Uses selectors to wait for the socket to become readable within the given timeout. This

Wait until no gunicorn processes are running.

Apply per-header policy shared between Python and fast parsers. Mutates ``self._expected_100_continue`` and ``self.scheme`` as needed.

Build a client-to-server masked WebSocket frame.

Cancel keepalive timer when new request arrives.

Close the async connection.

Create a mock HTTP/2 request with priority.

Create a mock HTTP request.

Create a mock HTTP request.

Create a mock HTTP request.

Create an ASGIProtocol instance for testing.

Create WebSocketProtocol with mock transport.

Create WebSocketProtocol with mock transport.

Create an ASGIProtocol instance for testing.

Create a WebSocketProtocol instance.

Create a WebSocketProtocol with optional subprotocols.

Create a WebSocketProtocol instance.

Create an ASGIProtocol instance for testing.

Create an ASGIProtocol instance for testing.

Create an ASGIProtocol instance for testing.

Lazily import gunicorn_h1c if available.

Handle an HTTP/2 connection. ``upgrade`` is set when the connection arrives over Upgrade: h2c and carries ``(settings, http1_req, bod

Check if IP address is in the allow list. Args: ip_str: The IP address string to check allow_list: The original allow list (strin

Return the (secure_scheme_headers, forwarder_headers) the peer is allowed to set. When the peer's address is not in ``forwarded_allow_ips`` (

Reset buffer for reuse instead of creating new BytesIO.

Send a WebSocket frame. Server frames are not masked (RFC 6455).

Initiate async shutdown.

Commit to HTTP/1.x and replay anything already read. Called straight from connection_made(), and again when h2c sniffing gives up on

Stop server before fork (called by fork handler).

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

Wake up any pending receive() call.

Periodically check worker health and manage pool.

WSGI application that demonstrates dirty worker integration.

Validate configuration for ASGI worker.

Close the async connection.

Create a test worker for benchmarks.

Create a worker for testing.

Create a worker for testing.

Create a worker for testing.

Create a worker for testing.

Called when data is received on the connection.

Spawn additional dirty workers. Sends a MANAGE message to the dirty arbiter to spawn workers. Args: count: Numb

Remove dirty workers. Sends a MANAGE message to the dirty arbiter to remove workers. Args: count: Number of dir

Drain the request body.

Get PIDs of gunicorn processes.

Extract a header value from h2 headers list. h2 library may return headers as bytes or strings depending on version.

Extract HTTP/2 pseudo-headers from request headers. Returns: dict: Mapping of pseudo-header names to values (e.

Get regular (non-pseudo) headers from request. Returns: list: List of (name, value) tuples for regular headers

Initialize database connection and cache.

\ Initialize master signal handling. Most of the signals are queued. Child signals only wake up the master.

\ Send a signal to the dirty arbiter. :attr sig: `signal.SIG*` value

\ Kill all workers with the signal `sig` :attr sig: `signal.SIG*` value

Close expired keepalive connections.

\ Kill unused/idle workers

Return cached network objects for proxy_allow_ips (internal use).

Read a complete message from socket (sync). Args: sock: Socket to read from Returns: dict: Message

Read SSE events from a streaming response. Stops when receiving a 'complete' or 'error' event, or max_events reached.

Read all lines from the body. Args: hint: Approximate byte count hint Returns: list: List of lines

Reap dead worker processes.

Reset for next request (keepalive).

Run the dirty arbiter (blocking call).

Run the main asyncio event loop.

Run queued callbacks. Called when the pipe is readable. Drains all available wake-up bytes and runs corresponding callbacks. The max_