Trait mz_service::client::GenericClient

pub trait GenericClient<C, R>: Debug + Send {
    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;
    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;

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

A generic client to a server that receives commands and asynchronously produces responses.

Required Methods

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.

The command can error for various reasons.

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,

Receives the next response from the dataflow server.

This method blocks until the next response is available.

A return value of Ok(Some(_)) transmits a response.

A return value of Ok(None) indicates graceful termination of the connection. The owner of the client should not call recv again.

A return value of Err(_) indicates an unrecoverable error. After observing an error, the owner of the client must drop the client.

Implementations of this method must be cancellation safe. That means that work must not be lost if the future returned by this method is dropped.

Provided Methods

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.

The stream produces the responses that would be produced by repeated calls to recv.

Trait Implementations

impl<C, R> GenericClient<C, R> for Box<dyn GenericClient<C, R>>where
    C: Send,

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 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,

Receives the next response from the dataflow server.

Implementations on Foreign Types

impl<C, R> GenericClient<C, R> for Box<dyn GenericClient<C, R>>where
    C: Send,

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,

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,

Implementors

impl<C, R, A> GenericClient<C, R> for LocalClient<C, R, A>where
    C: Debug + Send,
    R: Debug + Send,
    A: Debug + Activatable + Send,

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,

impl<P, C, R> GenericClient<C, R> for Partitioned<P, C, R>where
    P: GenericClient<C, R>,
    (C, R): Partitionable<C, R>,
    C: Debug + Send,
    R: Debug + Send,