Struct GrpcStreamConfig 

pub struct GrpcStreamConfig {

    pub endpoint: String,
    pub service_name: String,
    pub method_name: String,
    pub request: Value,
    pub descriptor_set_path: PathBuf,
    pub auth: AuthSpec<GrpcAuth>,
    pub tls: Option<bool>,
    pub records_path: Option<String>,
    pub batch_size: usize,
    pub rpc_kind: RpcKind,
    pub max_messages: Option<usize>,
    pub terminate_on_error: bool,
    pub reconnect_initial_backoff: Duration,
    pub reconnect_max_backoff: Duration,
    pub reconnect_max_attempts: Option<u32>,
    pub reconnect_replay_from_start: bool,
    pub max_decoding_message_size: Option<usize>,
    pub max_encoding_message_size: Option<usize>,
}

Configuration for the gRPC source.

Fields

endpoint: String

gRPC endpoint URL (e.g. "http://localhost:50051").

service_name: String

Fully qualified service name (e.g. "mypackage.MyService").

method_name: String

Method name (e.g. "ListUsers").

request: Value

Request message as JSON. Fields are mapped to protobuf fields using the FileDescriptorSet.

descriptor_set_path: PathBuf

Path to the compiled FileDescriptorSet file.

auth: AuthSpec<GrpcAuth>

Authentication: either inline ({ type, config }) or a { ref: <name> } pointer to a shared provider in the CLI’s top-level auth: catalog.

tls: Option<bool>

Whether to use TLS (detected from https:// in endpoint by default).

records_path: Option<String>

JSONPath to extract records from the response. If not set, the entire response is returned as a single record.

batch_size: usize

Records per emitted StreamPage. Defaults to DEFAULT_BATCH_SIZE.

For unary RPCs the source has no native paging primitive to honour this hint: the default Source::stream_pages impl buffers the full response and then chunks it in memory, bounding sink-side memory only.

For server-streaming RPCs (rpc_kind = "server_streaming") the source overrides stream_pages and flushes a page each time batch_size messages accumulate, bounding both source-side and sink-side memory. batch_size = 0 drains the entire stream into a single page.

rpc_kind: RpcKind

Kind of RPC to invoke. Defaults to RpcKind::Unary.

max_messages: Option<usize>

For RpcKind::ServerStreaming: maximum number of messages to consume before terminating the stream. None means consume until the server closes the stream (or the run is cancelled).

terminate_on_error: bool

For RpcKind::ServerStreaming: if true, transient stream errors (server-side disconnects, transport errors, etc.) terminate the run with FaucetError::Source. When false (the default), the source reconnects with exponential backoff up to reconnect_max_attempts.

Ignored for RpcKind::Unary.

reconnect_initial_backoff: Duration

For RpcKind::ServerStreaming reconnect: initial backoff delay before the first retry. Doubles after each failure up to reconnect_max_backoff. Defaults to 1s.

reconnect_max_backoff: Duration

For RpcKind::ServerStreaming reconnect: maximum backoff cap. Defaults to 30s.

reconnect_max_attempts: Option<u32>

For RpcKind::ServerStreaming reconnect: maximum reconnect attempts before surfacing the error. None (the default) means unlimited retries.

reconnect_replay_from_start: bool

For RpcKind::ServerStreaming reconnect: whether the server replays the response stream from the beginning when the identical request is re-issued after a disconnect. Defaults to true.

Because the request is resolved once per run, a reconnect sends the same request — a stateless server therefore re-streams from message 0. When true the source skips the messages it already emitted before the disconnect, so consumers see each message once. Set to false only for servers that resume mid-stream on the same request (rare): there, skipping would drop genuinely-new messages, so every received message is emitted (at-least-once; duplicates possible).

max_decoding_message_size: Option<usize>

Maximum size, in bytes, of a single inbound (decoded) gRPC message. None (the default) keeps tonic’s built-in 4 MiB limit. Raise this for sources that legitimately return large messages; a too-low limit surfaces as a decode error and aborts the call. Applies to both unary and server-streaming RPCs.

max_encoding_message_size: Option<usize>

Maximum size, in bytes, of a single outbound (encoded) gRPC request message. None (the default) keeps tonic’s built-in limit. Rarely needs tuning for a data source, since requests are typically small.

Implementations

impl GrpcStreamConfig

pub fn new( endpoint: impl Into<String>, service_name: impl Into<String>, method_name: impl Into<String>, descriptor_set_path: impl Into<PathBuf>, ) -> Self

Create a new config with the required fields.

pub fn request(self, request: Value) -> Self

Set the request message as JSON.

pub fn auth(self, auth: GrpcAuth) -> Self

Set the authentication method (inline).

pub fn tls(self, tls: bool) -> Self

Set the TLS mode explicitly.

pub fn records_path(self, path: impl Into<String>) -> Self

Set the JSONPath for record extraction from the response.

pub fn with_batch_size(self, batch_size: usize) -> Self

Set the per-page record count for Source::stream_pages.

Pass 0 to opt out of batching — the entire result set is emitted in a single StreamPage. For unary RPCs this is observably identical to any positive batch_size, since the full response is buffered before any page is yielded. For server-streaming RPCs, 0 drains the entire stream before yielding.

pub fn rpc_kind(self, rpc_kind: RpcKind) -> Self

Set the RPC kind (unary or server-streaming).

pub fn max_messages(self, max_messages: usize) -> Self

Cap the number of messages to consume from a server-streaming RPC. Ignored for unary RPCs.

pub fn terminate_on_error(self, terminate_on_error: bool) -> Self

Whether transient server-streaming errors should terminate the run (true) or trigger a reconnect with exponential backoff (false, the default).

pub fn reconnect_initial_backoff(self, backoff: Duration) -> Self

Set the initial reconnect backoff for server-streaming RPCs.

pub fn reconnect_max_backoff(self, backoff: Duration) -> Self

Set the maximum reconnect backoff for server-streaming RPCs.

pub fn reconnect_max_attempts(self, attempts: u32) -> Self

Cap the number of reconnect attempts for server-streaming RPCs.

pub fn reconnect_replay_from_start(self, replay: bool) -> Self

Set whether the server replays the stream from the start on reconnect (default true). See reconnect_replay_from_start.

pub fn max_decoding_message_size(self, bytes: usize) -> Self

Set the maximum inbound (decoded) gRPC message size in bytes.

pub fn max_encoding_message_size(self, bytes: usize) -> Self

Set the maximum outbound (encoded) gRPC message size in bytes.

Trait Implementations

impl Clone for GrpcStreamConfig

fn clone(&self) -> GrpcStreamConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GrpcStreamConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GrpcStreamConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for GrpcStreamConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for GrpcStreamConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.