Struct Client 

pub struct Client { /* private fields */ }

A grpc-webnext client: a gRPC channel, not a handle to a socket.

Cheap to clone — clones share one tunnel, which is the point, since calls multiplex over it. When that tunnel dies the channel redials on the next call, the way tonic::transport::Channel does: the call that discovers the failure reports it, and the one after reconnects. Watch Client::state_changes if the application wants to say something about it.

Implementations

impl Client

pub fn from_connection( conn: H2Connection, authority: impl Into<String>, ) -> Client

Build a client over an existing h2ts connection. Single-shot: there is no way to redial, so a dropped tunnel stays dropped. Prefer connect, which reconnects.

pub fn with_connector( connector: Connector, authority: impl Into<String>, ) -> Client

Build a reconnecting client from something that can open a tunnel on demand. Each call to connector must yield a fresh connection, with its driver already spawned.

pub fn over_transport( transport: Transport, authority: impl Into<String>, options: ConnectOptions, ) -> (Client, impl Future<Output = ()>)

Build a client over any byte transport, returning the driver future the caller must poll. Spawn it: wasm_bindgen_futures::spawn_local in a browser, tokio::task::spawn_local on a LocalSet natively.

Single-shot, since the transport is consumed — see from_connection.

pub fn state(&self) -> ConnectivityState

The channel’s connectivity state.

pub fn state_changes(&self) -> impl Stream<Item = ConnectivityState> + 'static

Watch connectivity transitions — gRPC’s WaitForStateChange, as a stream. Repeats are collapsed, so every item is a real change.

pub fn is_closed(&self) -> bool

True if there is no usable tunnel right now. A reconnecting client will open one on the next call; a single-shot one will not.

pub async fn unary( &self, path: &str, request: Vec<u8>, options: CallOptions, ) -> Result<UnaryResponse, Status>

Unary: one message out, one message back.

pub async fn client_streaming<S>( &self, path: &str, requests: S, options: CallOptions, ) -> Result<UnaryResponse, Status>

where S: Stream<Item = Vec<u8>> + 'static,

Client streaming: a stream of messages out, one message back.

The request body is uploaded as the stream yields, under HTTP/2 flow control — a slow server pushes back rather than the messages piling up here.

pub async fn server_streaming( &self, path: &str, request: Vec<u8>, options: CallOptions, ) -> Result<Streaming, Status>

Server streaming: one message out, a stream of messages back.

pub async fn bidi_streaming<S>( &self, path: &str, requests: S, options: CallOptions, ) -> Result<Streaming, Status>

where S: Stream<Item = Vec<u8>> + 'static,

Bidirectional streaming: a stream out, a stream back, concurrently.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl TypedClient for Client

async fn unary_typed<Req, Res>( &self, path: &str, request: Req, options: CallOptions, ) -> Result<TypedResponse<Res>, Status>

where Req: Message, Res: Message + Default,

Unary with prost encode/decode.

async fn client_streaming_typed<Req, Res, S>( &self, path: &str, requests: S, options: CallOptions, ) -> Result<TypedResponse<Res>, Status>

where Req: Message + 'static, Res: Message + Default, S: Stream<Item = Req> + 'static,

Client streaming with prost encode/decode.