Struct mz_compute_client::controller::ActiveComputeController

pub struct ActiveComputeController<'a, T> {
    compute: &'a mut ComputeController<T>,
    storage: &'a mut dyn StorageController<Timestamp = T>,
}

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

Fields

compute: &'a mut ComputeController<T>

storage: &'a mut dyn StorageController<Timestamp = T>

Implementations

impl<T> ActiveComputeController<'_, T>

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

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

Return a read-only handle to the indicated collection.

fn instance(
    &mut self,
    id: ComputeInstanceId
) -> Result<ActiveInstance<'_, T>, InstanceMissing>

Return a handle to the indicated compute instance.

impl<T> ActiveComputeController<'_, T>where
    T: Timestamp + Lattice,
    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_dataflows(
    &mut self,
    instance_id: ComputeInstanceId,
    dataflows: Vec<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>
) -> Result<(), PeekError>

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

pub fn cancel_peeks(
    &mut self,
    instance_id: ComputeInstanceId,
    uuids: BTreeSet<Uuid>
) -> Result<(), InstanceMissing>

Cancel existing peek requests.

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<(), CollectionUpdateError>

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.

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

Processes the work queued by ComputeController::ready.