Encode a Python value to TLV binary format. Args: value: Python value to encode (None, bool, int, float,

Decode a TLV-encoded value from binary data. Args: data: Binary data to decode offset: Starting offset in th

Process data, fire callbacks synchronously. Args: data: bytes or bytearray of incoming data Raises: ParseErr

Synchronous cleanup on exit.

Get value with default.

Build ASGI HTTP scope from parsed request.

Create a request message. Args: request_id: Unique request identifier command: Command name (e.g., "show workers") a

Factory for creating WebSocket connections.

Send initial HTTP/2 settings to client. Should be called after the SSL handshake completes and before processing any data.

Iterate over (key, value) pairs.

Check if a table or key exists. Args: table: Table name key: Optional key to check within the table

Process received DATA frame with streaming support. Args: data: Bytes received end_stream: True if END_STREAM flag is

Process received data and return completed requests. Args: data: Optional bytes to process. If None, reads from socket.

Build a chunk message dict for streaming responses. Args: request_id: Request identifier this chunk belongs to data: Chunk d

ASGI send callable for lifespan.

Decode a message from bytes. Args: data: Raw bytes (length prefix + JSON payload) Returns: Decoded

Get the appropriate parser class for the test parameter.

Get information about a table. Args: table: Table name Returns: Dict with table info (size, etc.)

Get all keys, optionally filtered by pattern.

Load all configured dirty apps.

Build an end-of-stream message dict. Args: request_id: Request identifier this ends Returns: dict: End message dict

Factory for creating async HTTP clients.

Send initial HTTP/2 settings to client. Should be called after the SSL handshake completes and before processing any data.

Clean up resources on shutdown.

Create an h2 client connection for generating test frames.

Process received HEADERS frame. Args: headers: List of (name, value) tuples end_stream: True if END_STREAM flag is se

Receive data and return completed requests. Args: timeout: Optional timeout in seconds for read operation Returns:

Feed incoming data from the parent protocol's data_received(). Args: data: bytes received on the connection

delete pidfile

Decode the 16-byte message header. Args: data: 16 bytes of header data Returns: tuple: (msg_type, r

Create uWSGI packet for testing. Args: vars_dict: Dict of WSGI environ variables modifier1: Packet type (0 = WSGI request)

Called when the connection is lost or closed. Instead of immediately cancelling the task, we signal a disconnect event and send an ht

Execute request on a specific worker (called by consumer). Handles both regular responses and streaming (chunk-based) responses.

Create an h2 client connection for generating test frames.

Store a value in a table. The table is automatically created if it doesn't exist. Args: table: Table name

Mark data as sent. Args: data: Bytes to send end_stream: True if this completes the response Raises:

Encode a message dict to binary format. Supports the old dict-based API for backwards compatibility. Args: mess

Create a success response message. Args: request_id: Request identifier being responded to data: Response data Returns:

Create a mock HTTP request.

Create an ASGIProtocol instance for testing.

Send any pending data from h2 to the socket.

Start server in background thread with asyncio event loop.

Stream SSE events from URL.

Handle signals by setting alive = False.

Build a uWSGI packet from a dictionary of variables. Args: vars_dict: Dictionary of uWSGI variables modifier1: uWSGI modifier1 (d

Build request from callback parser state. Args: parser: H1CProtocol or PythonProtocol instance is_ssl: Whether connec

Get or create a context-local async client. This is the recommended way to get a client in async HTTP workers. Args: timeout: T

return date in Apache Common Log Format

Read one message from a socket. Args: sock: Socket to read from Returns: Decoded message dictionary

Register which apps a worker has loaded. Updates both app_worker_map and worker_app_map to track the bidirectional relations

Create an h2 client connection.

Execute an action on a dirty app. The action runs in a thread pool executor to avoid blocking the asyncio event loop. Execut

\ Reap workers to avoid zombie processes

Mark headers as sent. Args: headers: List of (name, value) tuples to send end_stream: True if this completes the resp

Send a response on a stream. Args: stream_id: The stream ID to respond on status: HTTP status code (int)

Initiate shutdown. Args: mode: "graceful" (SIGTERM) or "quick" (SIGINT) Returns: Dictionary with st

WebSocket client factory for testing.

Helper to create a stream with headers and body.

Close connection.

Stop server and cleanup socket.

Send any pending data from h2 to the socket.

Create a test worker with mocked components.