Method get_with_consistency

d-engine-server/src/api/embedded_client.rs:289–325

Advanced: Read with explicit consistency policy. For fine-grained control over read consistency vs performance trade-off. # Consistency Policies - `LinearizableRead`: Read from Leader (strong consistency, may be slower) - `EventualConsistency`: Read from local node (fast, may be stale) - `LeaseRead`: Optimized Leader read using lease mechanism # Example ```ignore use d_engine_proto::client::Rea

(
        &self,
        key: impl AsRef<[u8]>,
        consistency: ReadConsistencyPolicy,
    )

    /// ).await?;
    /// ```
    pub async fn get_with_consistency(
        &self,
        key: impl AsRef<[u8]>,
        consistency: ReadConsistencyPolicy,
    ) -> ClientApiResult<Option<Bytes>> {
        let request = ClientReadRequest {
            client_id: self.client_id,
            keys: vec![Bytes::copy_from_slice(key.as_ref())],
            consistency_policy: Some(consistency),
        };

        let (resp_tx, resp_rx) = MaybeCloneOneshot::new();

        self.cmd_tx
            .send(d_engine_core::ClientCmd::Read(request, resp_tx))
            .await
            .map_err(|_| channel_closed_error())?;

        let result = tokio::time::timeout(self.timeout, resp_rx)
            .await
            .map_err(|_| timeout_error(self.timeout))?
            .map_err(|_| channel_closed_error())?;

        let response =
            result.map_err(|status| server_error(format!("RPC error: {}", status.message())))?;

        if response.error != ErrorCode::Success {
            return Err(Self::map_error_response(
                response.error,
                response.leader_hint,
                response.retry_after_ms,
            ));
        }

        let read_results = extract_read_payload(response.result)?;
        Ok(read_results.entries.first().map(|e| e.value.clone()))
    }

    /// Get multiple keys with linearizable consistency.
    ///