Enum mz_storage_client::client::StorageCommand

pub enum StorageCommand<T = Timestamp> {
    CreateTimely {
        config: TimelyConfig,
        epoch: ClusterStartupEpoch,
    },
    InitializationComplete,
    UpdateConfiguration(StorageParameters),
    CreateSources(Vec<CreateSourceCommand<T>>),
    AllowCompaction(Vec<(GlobalId, Antichain<T>)>),
    CreateSinks(Vec<CreateSinkCommand<T>>),
}

Commands related to the ingress and egress of collections.

Variants

CreateTimely

Fields

config: TimelyConfig

epoch: ClusterStartupEpoch

Specifies to the storage server(s) the shape of the timely cluster we want created, before other commands are sent.

InitializationComplete

Indicates that the controller has sent all commands reflecting its initial state.

UpdateConfiguration(StorageParameters)

Update storage instance configuration.

CreateSources(Vec<CreateSourceCommand<T>>)

Create the enumerated sources, each associated with its identifier.

AllowCompaction(Vec<(GlobalId, Antichain<T>)>)

Enable compaction in storage-managed collections.

Each entry in the vector names a collection and provides a frontier after which accumulations must be correct.

CreateSinks(Vec<CreateSinkCommand<T>>)

Trait Implementations

impl Arbitrary for StorageCommand<Timestamp>

type Strategy = Union<BoxedStrategy<StorageCommand<Timestamp>>>

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 StorageCommand<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StorageCommand<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for StorageCommand<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 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 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,

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.

impl<T: PartialEq> PartialEq<StorageCommand<T>> for StorageCommand<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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<ProtoStorageCommand> for StorageCommand<Timestamp>

fn into_proto(&self) -> ProtoStorageCommand

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl<T> Serialize for StorageCommand<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 StorageCommand<T>