Enum mz_dataflow_types::client::ActiveReplicationResponse

pub enum ActiveReplicationResponse<T = Timestamp> {
    ComputeResponse(ComputeResponse<T>),
    ReplicaHeartbeat(ReplicaId, DateTime<Utc>),
}

A response from the ActiveReplication client: either a deduplicated compute response, or a notification that we heard from a given replica and should update its recency status.

Variants

ComputeResponse(ComputeResponse<T>)

A response from the compute layer.

ReplicaHeartbeat(ReplicaId, DateTime<Utc>)

A notification that we heard a response from the given replica at the given time.

Trait Implementations

impl<T: Clone> Clone for ActiveReplicationResponse<T>

fn clone(&self) -> ActiveReplicationResponse<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ActiveReplicationResponse<T>

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

Formats the value using the given formatter.

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

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, 

The ADAPTER layer’s isolation from COMPUTE depends on the fact that this function is essentially non-blocking, i.e. the ADAPTER blindly awaits calls to this function. This lets the ADAPTER continue operating even in the face of unhealthy or absent replicas.

If this function every become blocking (e.g. making networking calls), the ADAPTER must amend its contract with COMPUTE.

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

Receives the next response from the dataflow server.

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

Returns an adapter that treats the client as a stream.