Struct mz_compute_client::controller::ActiveInstance

struct ActiveInstance<'a, T> {
    compute: &'a mut Instance<T>,
    storage_controller: &'a mut dyn StorageController<Timestamp = T>,
}

A wrapper around Instance with a live storage controller.

Fields

compute: &'a mut Instance<T>

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

Implementations

impl<'a, T> ActiveInstance<'a, T>where
    T: Timestamp + Lattice,
    ComputeGrpcClient: ComputeClient<T>,

fn add_replica(
    &mut self,
    id: ReplicaId,
    addrs: Vec<String>,
    logging: ComputeReplicaLogging,
    communication_config: CommunicationConfig
) -> Result<(), ComputeError>

Add a new instance replica, by ID.

fn remove_replica(&mut self, id: ReplicaId)

Remove an existing instance replica, by ID.

async fn create_dataflows(
    &mut self,
    dataflows: Vec<DataflowDescription<Plan<T>, (), T>>
) -> Result<(), ComputeError>

Create the described dataflows and initializes state for their output.

async fn drop_collections(
    &mut self,
    ids: Vec<GlobalId>
) -> Result<(), ComputeError>

Drops the read capability for the given collections and allows their resources to be reclaimed.

async fn peek(
    &mut self,
    id: GlobalId,
    literal_constraints: Option<Vec<Row>>,
    uuid: Uuid,
    timestamp: T,
    finishing: RowSetFinishing,
    map_filter_project: SafeMfpPlan,
    target_replica: Option<ReplicaId>
) -> Result<(), ComputeError>

Initiate a peek request for the contents of id at timestamp.

async fn cancel_peeks(
    &mut self,
    uuids: BTreeSet<Uuid>
) -> Result<(), ComputeError>

Cancels existing peek requests.

async fn set_read_policy(
    &mut self,
    policies: Vec<(GlobalId, ReadPolicy<T>)>
) -> Result<(), ComputeError>

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

fn update_max_result_size(&mut self, max_result_size: u32)

Update the max size in bytes of any result.

fn validate_ids(
    &self,
    ids: impl Iterator<Item = GlobalId>
) -> Result<(), ComputeError>

Validate that a collection exists for all identifiers, and error if any do not.

async fn update_write_frontiers(
    &mut self,
    updates: &[(GlobalId, FrontierBounds<T>)]
) -> Result<(), ComputeError>

Accept write frontier updates from the compute layer.

async fn update_read_capabilities(
    &mut self,
    updates: &mut BTreeMap<GlobalId, ChangeBatch<T>>
) -> Result<(), ComputeError>

Applies updates, propagates consequences through other read capabilities, and sends an appropriate compaction command.

async fn remove_peeks(
    &mut self,
    peek_ids: &BTreeSet<Uuid>
) -> Result<(), ComputeError>

Removes a registered peek, unblocking compaction that might have waited on it.

async fn allow_compaction(
    &mut self,
    frontiers: Vec<(GlobalId, Antichain<T>)>
) -> Result<(), ComputeError>

Downgrade the read capabilities of specific identifiers to specific frontiers.

Downgrading any read capability to the empty frontier will drop the item and eventually reclaim its resources.

Trait Implementations

impl<'a, T: Debug> Debug for ActiveInstance<'a, T>

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

Formats the value using the given formatter.