Struct mz_dataflow_types::client::controller::Controller

pub struct Controller<T = Timestamp> { /* private fields */ }

A client that maintains soft state and validates commands, in addition to forwarding them.

NOTE(benesch): I find the fact that this type is called Controller but is referred to as the dataflow_client in the coordinator to be very confusing. We should find the one correct name, and use it everywhere!

Implementations

impl<T> Controller<T> where
    T: Timestamp + Lattice + Codec64 + Copy + Unpin,
    ComputeCommand<T>: RustType<ProtoComputeCommand>,
    ComputeResponse<T>: RustType<ProtoComputeResponse>, 

pub async fn create_instance(
    &mut self,
    instance: ComputeInstanceId,
    logging: Option<LoggingConfig>
) -> Result<(), Error>

pub async fn add_replica_to_instance(
    &mut self,
    instance_id: ComputeInstanceId,
    replica_id: ReplicaId,
    config: ConcreteComputeInstanceReplicaConfig
) -> Result<(), Error>

Adds replicas of an instance.

Panics

• If the identified instance has not yet been created via Self::create_instance.

pub async fn drop_replica(
    &mut self,
    instance_id: ComputeInstanceId,
    replica_id: ReplicaId,
    config: ConcreteComputeInstanceReplicaConfig
) -> Result<(), Error>

Removes a replica from an instance, including its service in the orchestrator.

pub async fn drop_instance(
    &mut self,
    instance: ComputeInstanceId
) -> Result<(), Error>

Removes an instance from the orchestrator.

Panics

• If the identified instance still has active replicas.

pub fn watch_compute_services(&self) -> BoxStream<'static, ComputeInstanceEvent>

Listen for changes to compute services reported by the orchestrator.

impl<T> Controller<T>

pub fn storage(&self) -> &dyn StorageController<Timestamp = T>

Acquires an immutable handle to a controller for the storage instance.

pub fn storage_mut(&mut self) -> &mut dyn StorageController<Timestamp = T>

Acquires a mutable handle to a controller for the storage instance.

pub fn compute(
    &self,
    instance: ComputeInstanceId
) -> Option<ComputeController<'_, T>>

Acquires an immutable handle to a controller for the indicated compute instance, if it exists.

pub fn compute_mut(
    &mut self,
    instance: ComputeInstanceId
) -> Option<ComputeControllerMut<'_, T>>

Acquires a mutable handle to a controller for the indicated compute instance, if it exists.

impl<T> Controller<T> where
    T: Timestamp + Lattice + Codec64, 

pub async fn ready(&mut self) -> Result<(), Error>

Wait until the controller is ready to process a response.

This method may await indefinitely.

This method is intended to be cancel-safe: dropping the returned future at any await point and restarting from the beginning is fine.

pub async fn process(&mut self) -> Result<Option<ControllerResponse<T>>, Error>

Process any queued messages.

This method is not known to be cancel-safe, and should not be called in the receiver of a tokio::select branch. Calling it in the handler of such a branch is fine.

This method is not intended to await indefinitely for reconnections and such; the coordinator relies on this property in order to not hang.

impl<T> Controller<T> where
    T: Timestamp + Lattice + TotalOrder + TryInto<i64> + TryFrom<i64> + Codec64 + Unpin,
    <T as TryInto<i64>>::Error: Debug,
    <T as TryFrom<i64>>::Error: Debug,
    StorageCommand<T>: RustType<ProtoStorageCommand>,
    StorageResponse<T>: RustType<ProtoStorageResponse>, 

pub async fn new(config: ControllerConfig) -> Self

Creates a new controller.