Struct GrpcConfig 

pub struct GrpcConfig {
    pub enabled: bool,
    pub max_message_size: usize,
    pub enable_compression: bool,
    pub request_timeout: Option<u64>,
    pub max_concurrent_streams: u32,
    pub enable_keepalive: bool,
    pub keepalive_interval: u64,
    pub keepalive_timeout: u64,
}

Configuration for gRPC support

Controls how the server handles gRPC requests, including compression, timeouts, and protocol settings.

Stream Limits

This configuration enforces message-level size limits but delegates concurrent stream limiting to the HTTP/2 transport layer:

• Message Size Limits: The max_message_size field is enforced per individual message (request or response) in both unary and streaming RPCs. When a single message exceeds this limit, the request is rejected with PAYLOAD_TOO_LARGE (HTTP 413).

• Concurrent Stream Limits: The max_concurrent_streams is an advisory configuration passed to the HTTP/2 layer for connection-level stream negotiation. The HTTP/2 transport automatically enforces this limit and returns GOAWAY frames when exceeded. Applications should not rely on custom enforcement of this limit.

• Stream Length Limits: There is currently no built-in limit on the total number of messages in a stream. Handlers should implement their own message counting if needed. Future versions may add a max_stream_response_bytes field to limit total response size per stream.

Example

let mut config = GrpcConfig::default();
config.max_message_size = 10 * 1024 * 1024; // 10MB per message
config.max_concurrent_streams = 50; // Advised to HTTP/2 layer

Fields

enabled: bool

Enable gRPC support

max_message_size: usize

Maximum message size in bytes (for both sending and receiving)

This limit applies to individual messages in both unary and streaming RPCs. When a single message exceeds this size, the request is rejected with HTTP 413 (Payload Too Large).

Default: 4MB (4194304 bytes)

Note

This limit does NOT apply to the total response size in streaming RPCs. For multi-message streams, the total response can exceed this limit as long as each individual message stays within the limit.

enable_compression: bool

Enable gzip compression for gRPC messages

request_timeout: Option<u64>

Timeout for gRPC requests in seconds (None = no timeout)

max_concurrent_streams: u32

Maximum number of concurrent streams per connection (HTTP/2 advisory)

This value is communicated to HTTP/2 clients as the server’s flow control limit. The HTTP/2 transport layer enforces this limit automatically via SETTINGS frames and GOAWAY responses. Applications should NOT implement custom enforcement.

Default: 100 streams per connection

Stream Limiting Strategy

• Per Connection: This limit applies per HTTP/2 connection, not globally
• Transport Enforcement: HTTP/2 handles all stream limiting; applications need not implement custom checks
• Streaming Requests: In server streaming or bidi streaming, each logical RPC consumes one stream slot. Message ordering within a stream follows HTTP/2 frame ordering.

Future Enhancement

A future max_stream_response_bytes field may be added to limit the total response size in streaming RPCs (separate from per-message limits).

enable_keepalive: bool

Enable HTTP/2 keepalive

keepalive_interval: u64

HTTP/2 keepalive interval in seconds

keepalive_timeout: u64

HTTP/2 keepalive timeout in seconds

Trait Implementations

impl Clone for GrpcConfig

fn clone(&self) -> GrpcConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GrpcConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GrpcConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GrpcConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GrpcConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.