Struct mz_compute_client::controller::ActiveComputeController

pub struct ActiveComputeController<'a, T> { /* private fields */ }

A wrapper around a ComputeController with a live connection to a storage controller.

Implementations

impl<T: ComputeControllerTimestamp> ActiveComputeController<'_, T>

pub fn instance_exists(&self, id: ComputeInstanceId) -> bool

TODO(#25239): Add documentation.

pub fn collection( &self, instance_id: ComputeInstanceId, collection_id: GlobalId ) -> Result<&CollectionState<T>, CollectionLookupError>

Return a read-only handle to the indicated collection.

impl<T> ActiveComputeController<'_, T>

where T: ComputeControllerTimestamp, ComputeGrpcClient: ComputeClient<T>,

pub fn add_replica_to_instance( &mut self, instance_id: ComputeInstanceId, replica_id: ReplicaId, location: ClusterReplicaLocation, config: ComputeReplicaConfig ) -> Result<(), ReplicaCreationError>

Adds replicas of an instance.

pub fn drop_replica( &mut self, instance_id: ComputeInstanceId, replica_id: ReplicaId ) -> Result<(), ReplicaDropError>

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

pub fn create_dataflow( &mut self, instance_id: ComputeInstanceId, dataflow: DataflowDescription<Plan<T>, (), T> ) -> Result<(), DataflowCreationError>

Create and maintain the described dataflows, and initialize state for their output.

This method creates dataflows whose inputs are still readable at the dataflow as_of frontier, and initializes the outputs as readable from that frontier onward. It installs read dependencies from the outputs to the inputs, so that the input read capabilities will be held back to the output read capabilities, ensuring that we are always able to return to a state that can serve the output read capabilities.

pub fn drop_collections( &mut self, instance_id: ComputeInstanceId, collection_ids: Vec<GlobalId> ) -> Result<(), CollectionUpdateError>

Drop the read capability for the given collections and allow their resources to be reclaimed.

pub fn peek( &mut self, instance_id: ComputeInstanceId, collection_id: GlobalId, literal_constraints: Option<Vec<Row>>, uuid: Uuid, timestamp: T, finishing: RowSetFinishing, map_filter_project: SafeMfpPlan, target_replica: Option<ReplicaId>, peek_target: PeekTarget ) -> Result<(), PeekError>

Initiate a peek request for the contents of the given collection at timestamp.

pub fn cancel_peek( &mut self, instance_id: ComputeInstanceId, uuid: Uuid ) -> Result<(), InstanceMissing>

Cancel an existing peek request.

Canceling a peek is best effort. The caller may see any of the following after canceling a peek request:

• A PeekResponse::Rows indicating that the cancellation request did not take effect in time and the query succeeded.
• A PeekResponse::Canceled affirming that the peek was canceled.
• No PeekResponse at all.

pub fn set_read_policy( &mut self, instance_id: ComputeInstanceId, policies: Vec<(GlobalId, ReadPolicy<T>)> ) -> Result<(), ReadPolicyError>

Assign a read policy to specific identifiers.

The policies are assigned in the order presented, and repeated identifiers should conclude with the last policy. Changing a policy will immediately downgrade the read capability if appropriate, but it will not “recover” the read capability if the prior capability is already ahead of it.

Identifiers not present in policies retain their existing read policies.

It is an error to attempt to set a read policy for a collection that is not readable in the context of compute. At this time, only indexes are readable compute collections.

pub async fn process(&mut self) -> Option<ComputeControllerResponse<T>>

Processes the work queued by ComputeController::ready.