Struct mz_cluster::server::ClusterClient

pub struct ClusterClient<Client, Worker, C, R>
where
    Worker: AsRunnableWorker<C, R>,
{
    inner: Option<Client>,
    timely_container: TimelyContainerRef<C, R, Worker::Activatable>,
    persist_clients: Arc<PersistClientCache>,
    txns_ctx: TxnsContext,
    tokio_handle: Handle,
    tracing_handle: Arc<TracingHandle>,
    worker: Worker,
}

A client managing access to the local portion of a Timely cluster

Fields

inner: Option<Client>

The actual client to talk to the cluster

timely_container: TimelyContainerRef<C, R, Worker::Activatable>

The running timely instance

persist_clients: Arc<PersistClientCache>

Handle to the persist infrastructure.

txns_ctx: TxnsContext

Context necessary for rendering txn-wal operators.

tokio_handle: Handle

The handle to the Tokio runtime.

tracing_handle: Arc<TracingHandle>

A process-global handle to tracing configuration.

worker: Worker

Implementations

impl<Worker, C, R> ClusterClient<Partitioned<LocalClient<C, R, Worker::Activatable>, C, R>, Worker, C, R>

where C: Send + 'static, R: Send + 'static, (C, R): Partitionable<C, R>, Worker: AsRunnableWorker<C, R> + Clone + Send + Sync + 'static,

fn new( timely_container: TimelyContainerRef<C, R, Worker::Activatable>, persist_clients: Arc<PersistClientCache>, txns_ctx: TxnsContext, tokio_handle: Handle, tracing_handle: Arc<TracingHandle>, worker_config: Worker, ) -> Self

async fn build_timely( user_worker_config: Worker, config: TimelyConfig, epoch: ClusterStartupEpoch, persist_clients: Arc<PersistClientCache>, txns_ctx: TxnsContext, tracing_handle: Arc<TracingHandle>, tokio_executor: Handle, ) -> Result<TimelyContainer<C, R, Worker::Activatable>, Error>

async fn build( &mut self, config: TimelyConfig, epoch: ClusterStartupEpoch, ) -> Result<(), Error>

Trait Implementations

impl<Client: Debug, Worker: AsRunnableWorker<C, R>, C, R> Debug for ClusterClient<Client, Worker, C, R>

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

Formats the value using the given formatter.

impl<Worker, C, R> GenericClient<C, R> for ClusterClient<Partitioned<LocalClient<C, R, Worker::Activatable>, C, R>, Worker, C, R>

where C: Send + Debug + TryIntoTimelyConfig + 'static, R: Send + Debug + 'static, (C, R): Partitionable<C, R>, Worker: AsRunnableWorker<C, R> + Send + Sync + Clone + 'static, Worker::Activatable: Send + Sync + 'static + Debug,

fn recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<Option<R>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Cancel safety

This method is cancel safe. If recv is used as the event in a tokio::select! statement and some other branch completes first, it is guaranteed that no messages were received by this client.

fn send<'life0, 'async_trait>( &'life0 mut self, cmd: C, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sends a command to the dataflow server.

fn as_stream<'a>( &'a mut self, ) -> Pin<Box<dyn Stream<Item = Result<R, Error>> + Send + 'a>>

where R: Send + 'a,

Returns an adapter that treats the client as a stream.