Enum StorageResponse

pub enum StorageResponse<T = Timestamp> {
    FrontierUpper(GlobalId, Antichain<T>),
    DroppedId(GlobalId),
    StagedBatches(BTreeMap<Uuid, Vec<Result<ProtoBatch, String>>>),
    StatisticsUpdates(Vec<SourceStatisticsUpdate>, Vec<SinkStatisticsUpdate>),
    StatusUpdate(StatusUpdate),
}

Responses that the storage nature of a worker/dataflow can provide back to the coordinator.

Variants

FrontierUpper(GlobalId, Antichain<T>)

A new upper frontier for the specified identifier.

DroppedId(GlobalId)

Punctuation indicates that no more responses will be transmitted for the specified id

StagedBatches(BTreeMap<Uuid, Vec<Result<ProtoBatch, String>>>)

Batches that have been staged in Persist and maybe will be linked into a shard.

StatisticsUpdates(Vec<SourceStatisticsUpdate>, Vec<SinkStatisticsUpdate>)

A list of statistics updates, currently only for sources.

StatusUpdate(StatusUpdate)

A status update for a source or a sink. Periodically sent from storage workers to convey the latest status information about an object.

Trait Implementations

impl<T: Clone> Clone for StorageResponse<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StorageResponse<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for StorageResponse<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<StorageResponse<T>>, 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: StorageCommand<T>, ) -> 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.

impl<T> Metrics<StorageCommand<T>, StorageResponse<T>> for ReplicaMetrics

fn bytes_sent(&mut self, len: usize)

Callback reporting numbers of bytes sent.

fn bytes_received(&mut self, len: usize)

Callback reporting numbers of bytes received.

fn message_sent(&mut self, msg: &StorageCommand<T>)

Callback reporting messages sent.

fn message_received(&mut self, msg: &StorageResponse<T>)

Callback reporting messages received.

impl<T: PartialEq> PartialEq for StorageResponse<T>

fn eq(&self, other: &StorageResponse<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Partitionable<StorageCommand<T>, StorageResponse<T>> for (StorageCommand<T>, StorageResponse<T>)

where T: Timestamp + Lattice,

type PartitionedState = PartitionedStorageState<T>

The type which functions as the state machine for the partitioning.

fn new(parts: usize) -> PartitionedStorageState<T>

Construct a PartitionedState for the command–response pair.

impl<T> PartitionedState<StorageCommand<T>, StorageResponse<T>> for PartitionedStorageState<T>

where T: Timestamp + Lattice,

fn split_command( &mut self, command: StorageCommand<T>, ) -> Vec<Option<StorageCommand<T>>>

Splits a command into multiple partitions.

fn absorb_response( &mut self, shard_id: usize, response: StorageResponse<T>, ) -> Option<Result<StorageResponse<T>, Error>>

Absorbs a response from a single partition.

impl<T> Serialize for StorageResponse<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for StorageResponse<T>