Struct mz_compute_client::controller::replica::ReplicaTask

struct ReplicaTask<T> {
    replica_id: ReplicaId,
    config: ReplicaConfig,
    build_info: &'static BuildInfo,
    command_rx: UnboundedReceiver<ComputeCommand<T>>,
    response_tx: InstrumentedUnboundedSender<(ReplicaId, u64, ComputeResponse<T>), DeleteOnDropCounter<'static, AtomicU64, Vec<String>>>,
    epoch: ClusterStartupEpoch,
    metrics: ReplicaMetrics,
    dyncfg: Arc<ConfigSet>,
}

Configuration for replica_task.

Fields

replica_id: ReplicaId

The ID of the replica.

config: ReplicaConfig

Replica configuration.

build_info: &'static BuildInfo

The build information for this process.

command_rx: UnboundedReceiver<ComputeCommand<T>>

A channel upon which commands intended for the replica are delivered.

response_tx: InstrumentedUnboundedSender<(ReplicaId, u64, ComputeResponse<T>), DeleteOnDropCounter<'static, AtomicU64, Vec<String>>>

A channel upon which responses from the replica are delivered.

epoch: ClusterStartupEpoch

A number (technically, pair of numbers) identifying this incarnation of the replica. The semantics of this don’t matter, except that it must strictly increase.

metrics: ReplicaMetrics

Replica metrics.

dyncfg: Arc<ConfigSet>

Dynamic system configuration.

Implementations

impl<T> ReplicaTask<T>

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

async fn run(self)

Asynchronously forwards commands to and responses from a single replica.

async fn connect(&self) -> SequentialHydration<T>

Connects to the replica.

The connection is retried forever (with backoff) and this method returns only after a connection was successfully established.

async fn run_message_loop( self, client: SequentialHydration<T>, ) -> Result<(), Error>

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

Runs the message loop.

Returns (with an Err) if it encounters an error condition (e.g. the replica disconnects). If no error condition is encountered, the task runs until the controller disconnects from the command channel, or the task is dropped.

fn specialize_command(&self, command: &mut ComputeCommand<T>)

Specialize a command for the given replica configuration.

Most ComputeCommands are independent of the target replica, but some contain replica-specific fields that must be adjusted before sending.

fn observe_command(&mut self, command: &ComputeCommand<T>)

Update task state according to an observed command.

fn observe_response(&mut self, response: &ComputeResponse<T>)

Update task state according to an observed response.