Enum mz_storage_client::client::StorageCommand

pub enum StorageCommand<T = Timestamp> {
    CreateTimely {
        config: TimelyConfig,
        epoch: ClusterStartupEpoch,
    },
    InitializationComplete,
    AllowWrites,
    UpdateConfiguration(StorageParameters),
    RunIngestions(Vec<RunIngestionCommand>),
    AllowCompaction(Vec<(GlobalId, Antichain<T>)>),
    RunSinks(Vec<RunSinkCommand<T>>),
}

Commands related to the ingress and egress of collections.

Variants

CreateTimely

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

Fields

config: TimelyConfig

epoch: ClusterStartupEpoch

InitializationComplete

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

AllowWrites

AllowWrites informs the replica that it can transition out of the read-only stage and into the read-write computation stage. It is now allowed to affect changes to external systems (writes).

See ComputeCommand::AllowWrites for details. This command works analogously to the compute version.

UpdateConfiguration(StorageParameters)

Update storage instance configuration.

RunIngestions(Vec<RunIngestionCommand>)

Run 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.

RunSinks(Vec<RunSinkCommand<T>>)

Implementations

impl<T> StorageCommand<T>

pub fn installs_objects(&self) -> bool

Returns whether this command instructs the installation of storage objects.

Trait Implementations

impl Arbitrary for StorageCommand<Timestamp>

type Strategy = Union<BoxedStrategy<StorageCommand>>

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

fn eq(&self, other: &StorageCommand<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<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.

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 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 TryIntoTimelyConfig for StorageCommand

fn try_into_timely_config( self, ) -> Result<(TimelyConfig, ClusterStartupEpoch), Self>

Attempt to unpack self into a (TimelyConfig, ClusterStartupEpoch). Otherwise, fail and return self back.

impl<T> StructuralPartialEq for StorageCommand<T>