Trait mz_dataflow_types::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
        'life0: 'async_trait,
        Self: 'async_trait;
    fn recv<'life0, 'async_trait>(
        &'life0 mut self
    ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

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

A client to a running dataflow server.

Required methods

fn send<'life0, 'async_trait>(
    &'life0 mut self,
    cmd: C
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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
    'life0: 'async_trait,
    Self: 'async_trait, 

Receives the next response from the dataflow server.

This method blocks until the next response is available, or, if the dataflow server has been shut down, returns None.

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.

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
    'life0: 'async_trait,
    Self: 'async_trait, 

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

impl<T: Send> GenericClient<ComputeCommand<T>, ComputeResponse<T>> for Box<dyn ComputeClient<T>>

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

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

impl<T: Send> GenericClient<StorageCommand<T>, StorageResponse<T>> for Box<dyn StorageClient<T>>

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

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

Implementors

impl<C, R> GenericClient<C, R> for ProcessLocal<C, R> where
    C: Debug + Send,
    R: Debug + Send, 

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

impl<C, R, G> GenericClient<C, R> for RemoteClient<C, R, G> where
    (C, R): Partitionable<C, R>,
    C: Serialize + Debug + Unpin + Send,
    R: DeserializeOwned + Debug + Unpin + Send,
    G: GenericClient<C, R> + Reconnect + FromAddr, 

impl<Client, C, R, PC, PR> GenericClient<C, R> for GrpcClient<Client, PC, PR> where
    C: RustType<PC> + Send + Sync + 'static,
    R: RustType<PR> + Send + Sync,
    Client: BidiProtoClient<ProtoCommand = PC, ProtoResponse = PR> + Send + Debug,
    PC: Send + Sync + Debug,
    PR: Send + Sync + Debug, 

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

impl<T> GenericClient<ComputeCommand<T>, ActiveReplicationResponse<T>> for ActiveReplication<T> where
    T: Timestamp + Lattice + Debug, 

impl<T, C> GenericClient<ComputeCommand<T>, ComputeResponse<T>> for ComputeCommandReconcile<T, C> where
    C: ComputeClient<T>,
    T: Timestamp + Copy,