Method put

d-engine-server/src/api/embedded_client.rs:181–219

Store a key-value pair with strong consistency. # Errors Returns an error if the node is not the leader, the channel is closed, the operation times out, or the state machine returns a server error.

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

    /// Returns an error if the node is not the leader, the channel is closed,
    /// the operation times out, or the state machine returns a server error.
    pub async fn put(
        &self,
        key: impl AsRef<[u8]>,
        value: impl AsRef<[u8]>,
    ) -> ClientApiResult<()> {
        let request = ClientWriteRequest {
            client_id: self.client_id,
            command: Some(WriteOperation::Insert {
                key: Bytes::copy_from_slice(key.as_ref()),
                value: Bytes::copy_from_slice(value.as_ref()),
                ttl_secs: None,
            }),
        };

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

        self.cmd_tx
            .send(d_engine_core::ClientCmd::Propose(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,
            ));
        }

        Ok(())
    }

    /// Strongly consistent read (linearizable).
    ///