Struct mz_service::grpc::GrpcClient

pub struct GrpcClient<G>
where
    G: ProtoServiceTypes,
{
    tx: UnboundedSender<G::PC>,
    rx: Streaming<G::PR>,
}

A client to a remote dataflow server using gRPC and protobuf based communication.

The client opens a connection using the proto client stubs that are generated by tonic from a service definition. When the client is connected, it will call automatically the only RPC defined in the service description, encapsulated by the BidiProtoClient trait. This trait bound is not on the Client type parameter here, but it IS on the impl blocks. Bidirectional protobuf RPC sets up two streams that persist after the RPC has returned: A Request (Command) stream (for us, backed by a unbounded mpsc queue) going from this instance to the server and a response stream coming back (represented directly as a Streaming<Response> instance). The recv and send functions interact with the two mpsc channels or the streaming instance respectively.

Fields

tx: UnboundedSender<G::PC>

The sender for commands.

rx: Streaming<G::PR>

The receiver for responses.

Implementations

impl<G> GrpcClient<G>

where G: ProtoServiceTypes,

pub async fn connect( addr: String, version: Version, metrics: G::STATS, params: &GrpcClientParameters, ) -> Result<Self, Error>

Connects to the server at the given address, announcing the specified client version.

pub async fn connect_partitioned<C, R>( dests: Vec<(String, G::STATS)>, version: Version, params: &GrpcClientParameters, ) -> Result<Partitioned<Self, C, R>, Error>

where (C, R): Partitionable<C, R>,

Like GrpcClient::connect, but for multiple partitioned servers.

Trait Implementations

impl<G> Debug for GrpcClient<G>

where G: ProtoServiceTypes + Debug, G::PC: Debug, G::PR: Debug,

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

Formats the value using the given formatter.

impl<G, C, R> GenericClient<C, R> for GrpcClient<G>

where C: RustType<G::PC> + Send + Sync + 'static, R: RustType<G::PR> + Send + Sync + 'static, G: ProtoServiceTypes,

fn recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancel safety

This method is cancel safe. If recv is used as the event in a tokio::select! statement and some other branch completes first, it is guaranteed that no messages were received by this client.

fn send<'life0, 'async_trait>( &'life0 mut self, cmd: C, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends a command to the dataflow server.

fn as_stream<'a>( &'a mut self, ) -> Pin<Box<dyn Stream<Item = Result<R, Error>> + Send + 'a>>

where R: Send + 'a,

Returns an adapter that treats the client as a stream.