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 Arbitrary for StorageResponse<Timestamp>

type Strategy = Union<BoxedStrategy<StorageResponse>>

The type of Strategy used to generate values of type Self.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

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

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

Returns a copy 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: 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 RustType<ProtoStorageResponse> for StorageResponse<Timestamp>

fn into_proto(&self) -> ProtoStorageResponse

Convert a Self into a Proto value.

fn from_proto(proto: ProtoStorageResponse) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

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>