Struct GrpcTransport 

pub struct GrpcTransport { /* private fields */ }

Available on crate features transport-grpc and transport only.

gRPC transport for DFE inter-service communication.

Implements both TransportSender and TransportReceiver, so it also satisfies the unified Transport trait via blanket impl.

Implementations

impl GrpcTransport

pub async fn new(config: &GrpcConfig) -> TransportResult<Self>

Create a new gRPC transport.

Configuration

• Set config.listen to start a gRPC server (receive mode).
• Set config.endpoint to connect to a remote server (send mode).
• Set both for bidirectional communication.

Errors

Returns error if the listen address is invalid or the server fails to start.

pub async fn with_pressure( config: &GrpcConfig, pressure: Option<Arc<UnifiedPressure>>, ) -> TransportResult<Self>

Available on crate feature governor only.

Create a gRPC transport bound to a pressure governor (G3, governor feature).

Identical to new except the receive server consults pressure BEFORE enqueuing each inbound Push / batch record: while UnifiedPressure::should_hold holds, the RPC is rejected with Status::unavailable (the gRPC analogue of HTTP 503, matching the existing channel-full backpressure mapping). Passing None is exactly equivalent to new.

Errors

Same as new.

Trait Implementations

impl Drop for GrpcTransport

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl TransportBase for GrpcTransport

async fn close(&self) -> TransportResult<()>

Shutdown the transport gracefully.

fn is_healthy(&self) -> bool

Check if the transport is healthy and connected.

fn name(&self) -> &'static str

Get transport name for logging/metrics.

impl TransportReceiver for GrpcTransport

type Token = GrpcToken

The token type for this transport.

async fn recv(&self, max: usize) -> TransportResult<WorkBatch<Self::Token>>

Receive up to max records as one WorkBatch.

async fn commit(&self, _tokens: &[Self::Token]) -> TransportResult<()>

Commit/acknowledge processed messages.

fn recv_limited( &self, limits: RecvLimits, ) -> impl Future<Output = TransportResult<WorkBatch<Self::Token>>> + Send

Byte-aware receive: bound a single poll by BOTH a record cap and a payload-byte cap (see RecvLimits).

impl TransportSender for GrpcTransport

async fn send_batch(&self, records: &[Record]) -> SendResult

Send a whole batch of records in ONE RouteBatch RPC (Task 0.6).

The native batch override of TransportSender::send_batch: serde-less rustlib<->rustlib transfer. The records map to a proto Batch via batch::records_to_proto – payloads travel as OPAQUE bytes and the JSON / MsgPack codec is NEVER invoked in transit. The whole batch goes in a single call (batch-at-a-time, NOT record-by-record streaming), so unlike the trait’s per-record default there is no partial-send window: the block is accepted or not as a unit.

Commit tokens and inline-DLQ entries are NOT sent – they are the SENDER’s local concern. Pass the records (e.g. &workbatch.records); the caller fires its commit tokens locally after this returns Ok.

Atomic (all-or-nothing) acceptance

The server handler reserves receiver-channel capacity for the WHOLE batch (one try_reserve_many) BEFORE enqueuing any record, so the block is accepted or rejected as a unit – there is genuinely no partial-send window. A Backpressured result means ZERO records were admitted, so the caller safely retries the whole block (at-least-once) with no risk of the receiver having kept a prefix on the prior attempt (no duplicate prefix).

Errors / result

Returns a SendResult. Backpressured maps the same transient gRPC codes as send so the caller retries the whole block rather than dropping it (at-least-once).

async fn send(&self, key: &str, payload: Bytes) -> SendResult

Send raw bytes to a key/destination.