Struct LanceClient 

pub struct LanceClient { /* private fields */ }

LANCE protocol client for communicating with LANCE servers

Provides methods for ingesting data, managing topics, and consuming records.

Implementations

impl LanceClient

pub async fn connect(config: ClientConfig) -> Result<Self, ClientError>

Connect to LANCE server, automatically using TLS if configured

The address in the config can be either an IP:port or hostname:port. DNS resolution is performed automatically for hostnames.

pub async fn connect_tls( config: ClientConfig, tls_config: TlsClientConfig, ) -> Result<Self, ClientError>

Connect to LANCE server with TLS encryption

Arguments

• config - Client configuration with server address (IP:port or hostname:port)
• tls_config - TLS configuration including certificates

Example

use lnc_client::{ClientConfig, TlsClientConfig, LanceClient};

let config = ClientConfig::new("lance.example.com:1992");
let tls = TlsClientConfig::new()
    .with_ca_cert("/path/to/ca.pem");

let client = LanceClient::connect_tls(config, tls).await?;

pub async fn connect_to(addr: &str) -> Result<Self, ClientError>

Connect to a LANCE server using an address string

The address can be either an IP:port (e.g., “127.0.0.1:1992”) or a hostname:port (e.g., “lance.example.com:1992”).

pub async fn connect_tls_to( addr: &str, tls_config: TlsClientConfig, ) -> Result<Self, ClientError>

Connect to LANCE server with TLS using address string

The address can be either an IP:port (e.g., “127.0.0.1:1992”) or a hostname:port (e.g., “lance.example.com:1992”).

pub async fn send_ingest( &mut self, payload: Bytes, record_count: u32, ) -> Result<u64, ClientError>

Send an ingest request to the default topic (topic 0)

pub async fn send_ingest_to_topic( &mut self, topic_id: u32, payload: Bytes, record_count: u32, _auth_config: Option<&AuthConfig>, ) -> Result<u64, ClientError>

Send an ingest request to a specific topic

pub async fn send_ingest_sync( &mut self, payload: Bytes, record_count: u32, ) -> Result<u64, ClientError>

Send an ingest request and wait for acknowledgment (default topic)

pub async fn send_ingest_to_topic_sync( &mut self, topic_id: u32, payload: Bytes, record_count: u32, auth_config: Option<&AuthConfig>, ) -> Result<u64, ClientError>

Send an ingest request to a specific topic and wait for acknowledgment

pub async fn recv_ack(&mut self) -> Result<u64, ClientError>

Receive an acknowledgment for a previously sent ingest request

pub async fn send_keepalive(&mut self) -> Result<(), ClientError>

Send a keepalive message to maintain the connection

pub async fn recv_keepalive(&mut self) -> Result<(), ClientError>

Receive a keepalive response from the server

pub async fn ping(&mut self) -> Result<Duration, ClientError>

Ping the server and measure round-trip latency

pub async fn create_topic( &mut self, name: &str, ) -> Result<TopicInfo, ClientError>

Create a new topic with the given name

pub async fn list_topics(&mut self) -> Result<Vec<TopicInfo>, ClientError>

List all topics on the server

pub async fn get_topic( &mut self, topic_id: u32, ) -> Result<TopicInfo, ClientError>

Get information about a specific topic

pub async fn delete_topic(&mut self, topic_id: u32) -> Result<(), ClientError>

Delete a topic by its ID

pub async fn set_retention( &mut self, topic_id: u32, max_age_secs: u64, max_bytes: u64, ) -> Result<(), ClientError>

Set retention policy for an existing topic

Arguments

• topic_id - Topic identifier
• max_age_secs - Maximum age in seconds (0 = no limit)
• max_bytes - Maximum size in bytes (0 = no limit)

pub async fn create_topic_with_retention( &mut self, name: &str, max_age_secs: u64, max_bytes: u64, ) -> Result<TopicInfo, ClientError>

Create a topic with retention policy in a single operation

Arguments

• name - Topic name
• max_age_secs - Maximum age in seconds (0 = no limit)
• max_bytes - Maximum size in bytes (0 = no limit)

pub async fn get_cluster_status(&mut self) -> Result<ClusterStatus, ClientError>

Get cluster status and health information

pub async fn fetch( &mut self, topic_id: u32, start_offset: u64, max_bytes: u32, ) -> Result<FetchResult, ClientError>

Fetch data from a topic starting at the given offset Returns (data, next_offset, record_count)

pub async fn subscribe( &mut self, topic_id: u32, start_offset: u64, max_batch_bytes: u32, consumer_id: u64, ) -> Result<SubscribeResult, ClientError>

Subscribe to a topic for streaming data Returns the consumer ID and starting offset

pub async fn unsubscribe( &mut self, topic_id: u32, consumer_id: u64, ) -> Result<(), ClientError>

Unsubscribe from a topic

pub async fn commit_offset( &mut self, topic_id: u32, consumer_id: u64, offset: u64, ) -> Result<CommitResult, ClientError>

Commit consumer offset for checkpointing

pub fn config(&self) -> &ClientConfig

Get a reference to the client configuration

pub async fn close(self) -> Result<(), ClientError>

Close the client connection

Trait Implementations

impl Debug for LanceClient

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

Formats the value using the given formatter.