Struct Client 

pub struct Client { /* private fields */ }

Main entry point for interacting with the d-engine cluster.

Derefs to GrpcClient, which implements ClientApi for all KV operations. Created through ClientBuilder.

Implementations

impl Client

pub fn builder(endpoints: Vec<String>) -> ClientBuilder

Create a configured client builder

Starts client construction process with specified bootstrap endpoints. Chain configuration methods before calling build().

Arguments

• endpoints - Initial cluster nodes for discovery

Panics

Will panic if no valid endpoints provided

pub async fn refresh( &self, new_endpoints: Option<Vec<String>>, ) -> Result<(), ClientApiError>

Rediscover the cluster and rebuild the connection pool.

Blocks until a leader whose noop entry is committed by majority is found, or ClientConfig::cluster_ready_timeout elapses.

What this does:

• Probes all endpoints in round-robin until one reports a ready leader (current_leader_id is Some and present in the member list)
• Atomically replaces the cached leader/follower connections
• After Ok(()), get_leader_id() returns the new leader and all write/read operations are routed to the correct node

What this does NOT do:

• Does not guarantee that the caller’s in-flight requests succeeded; requests sent before refresh() may have failed and need to be retried
• Does not implement application-level retry — the caller is responsible for re-issuing any operations that failed during the failover window
• Does not update endpoints permanently; pass new_endpoints to change the bootstrap list for this and future refreshes

Typical usage after leader failover:

client.refresh(None).await?;          // blocks until new leader ready
client.put(key, value).await?;        // now safe to retry operations

Methods from Deref<Target = GrpcClient>

pub async fn get_with_policy( &self, key: impl AsRef<[u8]>, consistency_policy: Option<ReadConsistencyPolicy>, ) -> Result<Option<KvEntry>, ClientApiError>

Retrieves a single key’s value with explicit consistency policy

Allows client to override server’s default consistency policy for this specific request. If server’s allow_client_override is false, the override will be ignored.

Parameters

• key - The key to retrieve, accepts any type implementing AsRef<[u8]>
• policy - Explicit consistency policy for this request

pub async fn get_multi_with_policy( &self, keys: impl IntoIterator<Item = impl AsRef<[u8]>>, consistency_policy: Option<ReadConsistencyPolicy>, ) -> Result<Vec<Option<KvEntry>>, ClientApiError>

Fetches multiple keys with explicit consistency policy override

Allows client to override server’s default consistency policy for this batch request. If server’s allow_client_override is false, the override will be ignored.

pub async fn watch_membership( &self, ) -> Result<Streaming<MembershipSnapshot>, ClientApiError>

Subscribe to committed cluster membership changes.

Immediately yields the current MembershipSnapshot on connect, then one snapshot per committed ConfChange (AddNode, Promote, Remove). The stream ends with Err(UNAVAILABLE) when the server shuts down; callers should reconnect and re-subscribe.

Use committed_index as an idempotency key to deduplicate retries.

pub async fn watch( &self, key: impl AsRef<[u8]>, ) -> Result<Streaming<WatchResponse>, ClientApiError>

Watch for changes to a specific key

Returns a stream of watch events when the key’s value changes. The stream will continue until explicitly closed or a connection error occurs.

Arguments

• key - The key to watch

Returns

A streaming response that yields WatchResponse events

Errors

Returns error if unable to establish watch connection

pub async fn watch_prefix( &self, prefix: impl AsRef<[u8]>, ) -> Result<Streaming<WatchResponse>, ClientApiError>

Watch all keys under a path prefix.

prefix must start with ‘/’ and end with ‘/’, e.g. b"/services/". Returns a stream of events for any key whose path begins with the prefix.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for Client

type Target = GrpcClient

The resulting type after dereferencing.

fn deref(&self) -> &<Client as Deref>::Target

Dereferences the value.