Struct DefaultLitePullConsumer 

pub struct DefaultLitePullConsumer { /* private fields */ }

Default implementation of a lite pull consumer.

This is the main entry point for creating and using a lite pull consumer. It acts as a facade over the internal implementation (DefaultLitePullConsumerImpl) and provides:

• Configuration management via DefaultLitePullConsumerBuilder
• Namespace handling (automatic topic name wrapping/unwrapping)
• Optional message trace integration
• A clean public API that delegates to the internal implementation

Architecture

┌────────────────────────────────────┐
│   DefaultLitePullConsumer          │  ← Public Facade
│  (config, trace, namespace)        │
└──────────────┬─────────────────────┘
               │ delegates
               ↓
┌────────────────────────────────────┐
│ DefaultLitePullConsumerImpl        │  ← Core Logic
│  (lifecycle, pull, commit, etc.)   │
└────────────────────────────────────┘

Examples

Basic usage with auto-commit

use rocketmq_client::DefaultLitePullConsumer;

let consumer = DefaultLitePullConsumer::builder(client_runtime.clone())
    .consumer_group("my_consumer_group")
    .name_server_addr("127.0.0.1:9876")
    .auto_commit(true)
    .build()?;

consumer.start().await?;
consumer.subscribe("my_topic").await?;

loop {
    let messages = consumer.poll_with_timeout(1000).await;
    for msg in messages {
        println!("Received: {:?}", msg);
    }
    // Offsets are auto-committed
}

Manual offset control

let consumer = DefaultLitePullConsumer::builder(client_runtime.clone())
    .consumer_group("my_consumer_group")
    .name_server_addr("127.0.0.1:9876")
    .auto_commit(false)  // Disable auto-commit
    .build()?;

consumer.start().await?;
consumer.subscribe("my_topic").await?;

loop {
    let messages = consumer.poll_with_timeout(1000).await;
    for msg in messages {
        // Process message
    }
     
    // Manually commit after processing
    consumer.commit_all().await?;
}

Manual queue assignment (no rebalance)

use rocketmq_model::common::message::message_queue::MessageQueue;

let mq1 = MessageQueue::from_parts("my_topic", "broker-a", 0);
let mq2 = MessageQueue::from_parts("my_topic", "broker-a", 1);

consumer.start().await?;
consumer.assign(vec![mq1, mq2]).await?;

let messages = consumer.poll().await;

Implementations

impl DefaultLitePullConsumer

pub fn new( client_runtime: Arc<ClientRuntime>, client_config: ClientConfig, consumer_config: LitePullConsumerConfig, rpc_hook: Option<Arc<dyn RPCHook>>, trace_dispatcher: Option<Arc<dyn TraceDispatcher + Send + Sync>>, enable_msg_trace: bool, custom_trace_topic: Option<CheetahString>, ) -> Self

Creates a new consumer with the specified configuration.

Most users should use builder() instead.

pub fn builder( client_runtime: Arc<ClientRuntime>, ) -> DefaultLitePullConsumerBuilder

Returns a builder for creating a consumer with custom configuration.

Examples

let consumer = DefaultLitePullConsumer::builder(client_runtime.clone())
    .consumer_group("my_group")
    .name_server_addr("127.0.0.1:9876")
    .pull_batch_size(32)
    .build()?;

pub async fn start(&self) -> ClientResult<()>

Starts the consumer.

pub async fn shutdown(&self)

Shuts down the consumer.

pub async fn is_running(&self) -> bool

Returns whether the consumer is currently running.

pub async fn consumer_running_info(&self) -> ClientResult<ConsumerRunningInfo>

Returns a Java-compatible running snapshot for broker admin diagnostics.

pub async fn subscribe(&self, topic: &str) -> ClientResult<()>

Subscribes to a topic using the default subscription expression.

pub async fn subscribe_with_expression( &self, topic: &str, sub_expression: &str, ) -> ClientResult<()>

Subscribes to a topic using a tag or SQL expression.

pub async fn subscribe_with_listener<MQL>( &self, topic: &str, sub_expression: &str, listener: MQL, ) -> ClientResult<()>

where MQL: MessageQueueListener + 'static,

Subscribes with a queue-change listener.

pub async fn subscribe_with_selector( &self, topic: &str, selector: Option<MessageSelector>, ) -> ClientResult<()>

Subscribes using a server-side selector.

pub async fn unsubscribe(&self, topic: &str)

Removes the subscription for a topic.

pub async fn assignment(&self) -> ClientResult<HashSet<MessageQueue>>

Returns the currently assigned queues.

pub async fn assign( &self, message_queues: Vec<MessageQueue>, ) -> ClientResult<()>

Assigns queues manually, bypassing broker rebalance.

pub async fn set_sub_expression_for_assign( &self, topic: &str, sub_expression: &str, ) -> ClientResult<()>

Sets the subscription expression used for manually assigned queues.

pub async fn build_subscriptions_for_heartbeat( &self, sub_expression_map: &mut HashMap<String, MessageSelector>, ) -> ClientResult<()>

Builds subscription metadata for heartbeat payloads.

pub async fn subscriptions_for_heartbeat(&self) -> HashSet<SubscriptionData>

Returns heartbeat subscriptions.

pub async fn get_subscriptions_for_heartbeat(&self) -> HashSet<SubscriptionData>

Java-compatible getter alias for heartbeat subscriptions.

pub async fn poll_zero_copy(&self) -> Vec<Arc<MessageExt>>

Polls messages without cloning message payloads.

pub async fn poll_with_timeout_zero_copy( &self, timeout: u64, ) -> Vec<Arc<MessageExt>>

Polls messages without cloning message payloads with a custom timeout.

pub async fn poll(&self) -> Vec<MessageExt>

Polls messages and returns owned copies.

pub async fn poll_with_timeout(&self, timeout: u64) -> Vec<MessageExt>

Polls messages with a custom timeout and returns owned copies.

pub async fn message_model(&self) -> MessageModel

Returns the configured message model.

pub async fn get_message_model(&self) -> MessageModel

Java-compatible getter alias for the configured message model.

pub async fn set_message_model(&self, message_model: MessageModel)

Sets the configured message model.

pub async fn consume_from_where(&self) -> ConsumeFromWhere

Returns where consumption starts when no offset exists.

pub async fn get_consume_from_where(&self) -> ConsumeFromWhere

Java-compatible getter alias for where consumption starts when no offset exists.

pub async fn set_consume_from_where( &self, consume_from_where: ConsumeFromWhere, ) -> ClientResult<()>

Sets where consumption starts when no offset exists.

pub async fn consume_timestamp(&self) -> Option<CheetahString>

Returns the consume timestamp.

pub async fn get_consume_timestamp(&self) -> Option<CheetahString>

Java-compatible getter alias for the consume timestamp.

pub async fn set_consume_timestamp( &self, consume_timestamp: Option<CheetahString>, )

Sets the consume timestamp.

pub async fn allocate_message_queue_strategy( &self, ) -> Arc<dyn AllocateMessageQueueStrategy + Send + Sync>

Returns the queue allocation strategy.

pub async fn get_allocate_message_queue_strategy( &self, ) -> Arc<dyn AllocateMessageQueueStrategy + Send + Sync>

Java-compatible getter alias for the queue allocation strategy.

pub async fn set_allocate_message_queue_strategy( &self, allocate_message_queue_strategy: Arc<dyn AllocateMessageQueueStrategy + Send + Sync>, )

Sets the queue allocation strategy.

pub async fn message_queue_listener(&self) -> Option<ArcMessageQueueListener>

Returns the message queue listener.

pub async fn get_message_queue_listener( &self, ) -> Option<ArcMessageQueueListener>

Java-compatible getter alias for the message queue listener.

pub async fn set_message_queue_listener( &self, message_queue_listener: Option<ArcMessageQueueListener>, )

Sets the message queue listener.

pub async fn offset_store(&self) -> Option<Arc<OffsetStore>>

Returns the configured offset store.

pub async fn get_offset_store(&self) -> Option<Arc<OffsetStore>>

Java-compatible getter alias for the configured offset store.

pub async fn set_offset_store( &self, offset_store: Option<Arc<OffsetStore>>, ) -> ClientResult<()>

Sets the configured offset store.

pub async fn topic_metadata_check_interval_millis(&self) -> u64

Returns the topic metadata check interval in milliseconds.

pub async fn get_topic_metadata_check_interval_millis(&self) -> u64

Java-compatible getter alias for the topic metadata check interval.

pub async fn set_topic_metadata_check_interval_millis( &self, interval_millis: u64, )

Sets the topic metadata check interval in milliseconds.

pub async fn poll_timeout_millis(&self) -> u64

Returns the default poll timeout in milliseconds.

pub async fn get_poll_timeout_millis(&self) -> u64

Java-compatible getter alias for the default poll timeout.

pub async fn set_poll_timeout_millis(&self, timeout_millis: u64)

Sets the default poll timeout in milliseconds.

pub async fn broker_suspend_max_time_millis(&self) -> u64

Returns the broker suspend max time in milliseconds.

pub async fn get_broker_suspend_max_time_millis(&self) -> u64

Java-compatible getter alias for the broker suspend max time.

pub async fn set_broker_suspend_max_time_millis(&self, timeout_millis: u64)

Sets the broker suspend max time in milliseconds.

pub async fn consumer_timeout_millis_when_suspend(&self) -> u64

Returns the consumer timeout while suspended.

pub async fn get_consumer_timeout_millis_when_suspend(&self) -> u64

Java-compatible getter alias for the consumer timeout while suspended.

pub async fn set_consumer_timeout_millis_when_suspend( &self, timeout_millis: u64, )

Sets the consumer timeout while suspended.

pub async fn consumer_pull_timeout_millis(&self) -> u64

Returns the pull RPC timeout in milliseconds.

pub async fn get_consumer_pull_timeout_millis(&self) -> u64

Java-compatible getter alias for the pull RPC timeout.

pub async fn set_consumer_pull_timeout_millis(&self, timeout_millis: u64)

Sets the pull RPC timeout in milliseconds.

pub async fn pull_batch_size(&self) -> i32

Returns the pull batch size.

pub async fn get_pull_batch_size(&self) -> i32

Java-compatible getter alias for the pull batch size.

pub async fn set_pull_batch_size(&self, pull_batch_size: i32)

Sets the pull batch size.

pub async fn pull_thread_nums(&self) -> usize

Returns the configured pull thread count.

pub async fn get_pull_thread_nums(&self) -> usize

Java-compatible getter alias for the configured pull thread count.

pub async fn set_pull_thread_nums(&self, pull_thread_nums: usize)

Sets the configured pull thread count.

pub async fn try_set_pull_thread_nums( &self, pull_thread_nums: usize, ) -> ClientResult<()>

Sets the maximum number of concurrent broker pull RPCs before startup.

Errors

Returns an error when pull_thread_nums is zero or the consumer has already started.

pub async fn pull_threshold_for_all(&self) -> i64

Returns the all-queue pull threshold.

pub async fn get_pull_threshold_for_all(&self) -> i64

Java-compatible getter alias for the all-queue pull threshold.

pub async fn set_pull_threshold_for_all(&self, pull_threshold_for_all: i64)

Sets the all-queue pull threshold.

pub async fn pull_threshold_for_queue(&self) -> i64

Returns the per-queue pull threshold.

pub async fn get_pull_threshold_for_queue(&self) -> i64

Java-compatible getter alias for the per-queue pull threshold.

pub async fn set_pull_threshold_for_queue(&self, pull_threshold_for_queue: i64)

Sets the per-queue pull threshold.

pub async fn pull_threshold_size_for_queue(&self) -> i32

Returns the per-queue pull size threshold.

pub async fn get_pull_threshold_size_for_queue(&self) -> i32

Java-compatible getter alias for the per-queue pull size threshold.

pub async fn set_pull_threshold_size_for_queue( &self, pull_threshold_size_for_queue: i32, )

Sets the per-queue pull size threshold.

pub async fn consume_max_span(&self) -> i64

Returns the max consume span.

pub async fn get_consume_max_span(&self) -> i64

Java-compatible getter alias for the max consume span.

pub async fn set_consume_max_span(&self, consume_max_span: i64)

Sets the max consume span.

pub async fn is_connect_broker_by_user(&self) -> bool

Returns whether pulls use the configured broker id.

pub async fn set_connect_broker_by_user(&self, connect_broker_by_user: bool)

Sets whether pulls use the configured broker id.

pub async fn default_broker_id(&self) -> u64

Returns the configured default broker id.

pub async fn get_default_broker_id(&self) -> u64

Java-compatible getter alias for the configured default broker id.

pub async fn set_default_broker_id(&self, broker_id: u64)

Sets the configured default broker id.

pub async fn fetch_message_queues( &self, topic: &str, ) -> ClientResult<Vec<MessageQueue>>

Fetches message queues for a topic.

pub async fn committed(&self, message_queue: &MessageQueue) -> ClientResult<i64>

Returns the committed offset for a queue.

pub async fn commit_all(&self) -> ClientResult<()>

Commits all offsets to the configured offset store.

pub async fn commit_with_map( &self, offset_map: HashMap<MessageQueue, i64>, persist: bool, )

Commits explicit offsets.

pub async fn commit(&self)

Commits all offsets.

pub async fn commit_with_set( &self, message_queues: HashSet<MessageQueue>, persist: bool, )

Commits offsets for selected queues.

pub async fn commit_sync(&self)

Java-compatible alias for committing all offsets.

pub async fn commit_sync_with_map( &self, offset_map: HashMap<MessageQueue, i64>, persist: bool, )

Java-compatible alias for committing explicit offsets.

pub async fn is_auto_commit(&self) -> bool

Returns whether auto commit is enabled.

pub async fn set_auto_commit(&self, auto_commit: bool)

Sets whether auto commit is enabled.

pub async fn is_unit_mode(&self) -> bool

Returns whether unit mode is enabled.

pub async fn set_unit_mode(&self, unit_mode: bool)

Sets whether unit mode is enabled.

pub async fn auto_commit_interval_millis(&self) -> u64

Returns the auto commit interval in milliseconds.

pub async fn get_auto_commit_interval_millis(&self) -> u64

Java-compatible getter alias for the auto commit interval.

pub async fn set_auto_commit_interval_millis(&self, interval_millis: u64)

Sets the auto commit interval in milliseconds.

pub async fn offset_for_timestamp( &self, message_queue: &MessageQueue, timestamp: u64, ) -> ClientResult<i64>

Queries the offset for a timestamp.

pub async fn earliest_msg_store_time( &self, message_queue: &MessageQueue, ) -> ClientResult<i64>

Queries the earliest store time for a queue.

pub async fn max_offset( &self, message_queue: &MessageQueue, ) -> ClientResult<i64>

Queries the broker max offset for a queue.

pub async fn min_offset( &self, message_queue: &MessageQueue, ) -> ClientResult<i64>

Queries the broker min offset for a queue.

pub async fn create_topic( &self, key: &str, new_topic: &str, queue_num: i32, attributes: HashMap<String, String>, ) -> ClientResult<()>

Creates a topic through the Java-compatible MQAdmin facade.

pub async fn create_topic_with_flag( &self, key: &str, new_topic: &str, queue_num: i32, topic_sys_flag: i32, attributes: HashMap<String, String>, ) -> ClientResult<()>

Creates a topic with an explicit topic system flag.

pub async fn query_message( &self, topic: &str, key: &str, max_num: i32, begin: u64, end: u64, ) -> ClientResult<QueryResult>

Queries messages by key in a time range.

pub async fn view_message( &self, topic: &str, msg_id: &str, ) -> ClientResult<MessageExt>

Views a message by offset message id or Java-compatible unique message id.

pub async fn pause(&self, message_queues: Vec<MessageQueue>)

Pauses fetching from selected queues.

pub async fn resume(&self, message_queues: Vec<MessageQueue>)

Resumes fetching from selected queues.

pub async fn is_paused(&self, message_queue: &MessageQueue) -> bool

Returns whether a queue is paused.

pub async fn seek( &self, message_queue: &MessageQueue, offset: i64, ) -> ClientResult<()>

Seeks a queue to an offset.

pub async fn seek_to_begin( &self, message_queue: &MessageQueue, ) -> ClientResult<()>

Seeks a queue to the beginning.

pub async fn seek_to_end( &self, message_queue: &MessageQueue, ) -> ClientResult<()>

Seeks a queue to the end.

pub async fn update_name_server_address(&self, name_server_address: &str)

Updates the name server address.

pub async fn register_topic_message_queue_change_listener<TL>( &self, topic: &str, listener: TL, ) -> ClientResult<()>

where TL: TopicMessageQueueChangeListener + 'static,

Registers a topic queue-change listener.

pub fn consumer_group(&self) -> CheetahString

Returns the consumer group name from the current immutable configuration snapshot.

pub fn get_consumer_group(&self) -> CheetahString

Java-compatible getter alias for the consumer group name.

pub fn set_consumer_group( &self, consumer_group: impl Into<CheetahString>, ) -> ClientResult<()>

Sets the consumer group name before the consumer starts.

Like Java DefaultLitePullConsumer.setConsumerGroup, this updates the facade configuration. If the internal implementation has already been initialized, the value is synchronized into the impl and rebalance configuration while it is still in the create state.

pub fn namespace(&self) -> Option<CheetahString>

Returns the namespace (if configured).

pub fn customized_trace_topic(&self) -> Option<CheetahString>

Returns the custom trace topic, if configured.

pub fn get_customized_trace_topic(&self) -> Option<CheetahString>

Java-compatible getter alias for the custom trace topic.

pub fn set_customized_trace_topic( &mut self, customized_trace_topic: impl Into<CheetahString>, )

Sets the custom trace topic used when message tracing is enabled.

pub fn clear_customized_trace_topic(&mut self)

Clears the custom trace topic so the default system trace topic is used.

pub fn is_enable_msg_trace(&self) -> bool

Returns whether message trace is enabled.

pub fn set_enable_msg_trace(&mut self, enable_msg_trace: bool)

Enables or disables message trace for subsequent startup.

pub fn is_use_tls(&self) -> bool

Returns whether outbound remoting connections should use TLS.

pub async fn set_use_tls(&self, use_tls: bool)

Enables or disables TLS on the published client configuration and trace dispatcher.

pub async fn trace_dispatcher( &self, ) -> Option<Arc<dyn TraceDispatcher + Send + Sync>>

Returns the trace dispatcher, if tracing has been configured or initialized.

pub async fn get_trace_dispatcher( &self, ) -> Option<Arc<dyn TraceDispatcher + Send + Sync>>

Java-compatible getter alias for the trace dispatcher.

pub fn client_config(&self) -> Arc<ClientConfig>

Returns the current immutable client configuration snapshot.

pub fn consumer_config(&self) -> Arc<LitePullConsumerConfig>

Returns the current immutable consumer configuration snapshot.

Trait Implementations

impl AssignmentControl for DefaultLitePullConsumer

async fn assignment(&self) -> ClientResult<HashSet<MessageQueue>>

Returns the set of MessageQueues currently assigned to this consumer.

async fn assign(&self, message_queues: Vec<MessageQueue>) -> ClientResult<()>

Manually assigns the given MessageQueues to this consumer, bypassing broker rebalance.

async fn set_sub_expression_for_assign( &self, topic: &str, sub_expression: &str, ) -> ClientResult<()>

Sets the subscription filter expression applied when fetching from manually assigned queues.

async fn pause(&self, message_queues: Vec<MessageQueue>)

Suspends message fetching for the specified MessageQueues.

async fn resume(&self, message_queues: Vec<MessageQueue>)

Resumes message fetching for the specified MessageQueues.

async fn is_paused(&self, message_queue: &MessageQueue) -> bool

Checks whether a specific MessageQueue is currently paused.

async fn seek( &self, message_queue: &MessageQueue, offset: i64, ) -> ClientResult<()>

Seeks the fetch position of the specified MessageQueue to the given offset.

async fn seek_to_begin(&self, message_queue: &MessageQueue) -> ClientResult<()>

Seeks the fetch position of the specified MessageQueue to its earliest available offset.

async fn seek_to_end(&self, message_queue: &MessageQueue) -> ClientResult<()>

Seeks the fetch position of the specified MessageQueue to its latest available offset.

impl ClientSessionProvider for DefaultLitePullConsumer

fn client_session(&self) -> Option<&ClientSession>

impl Clone for DefaultLitePullConsumer

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConsumerLifecycle for DefaultLitePullConsumer

async fn start(&self) -> ClientResult<()>

Starts the consumer and establishes connections to the broker and name server.

async fn shutdown(&self)

Shuts down the consumer and releases all associated resources.

async fn is_running(&self) -> bool

Returns whether the consumer is currently in the running state.

impl ConsumerOffsetControl for DefaultLitePullConsumer

async fn offset_store(&self) -> Option<Arc<OffsetStore>>

Returns the configured offset store, if one has been set or initialized.

async fn set_offset_store( &self, offset_store: Option<Arc<OffsetStore>>, ) -> ClientResult<()>

Sets the offset store used by the consumer.

async fn fetch_message_queues( &self, topic: &str, ) -> ClientResult<Vec<MessageQueue>>

Queries the broker for all MessageQueues belonging to the specified topic.

async fn committed(&self, message_queue: &MessageQueue) -> ClientResult<i64>

Returns the last committed offset for the specified MessageQueue.

async fn commit_all(&self) -> ClientResult<()>

Commits all consumed offsets for all assigned queues to the local offset store.

async fn commit_with_map( &self, offset_map: HashMap<MessageQueue, i64>, persist: bool, )

Commits the provided offsets asynchronously, optionally persisting them to the broker.

async fn commit(&self)

Commits all consumed offsets to the consumer offset store.

async fn commit_with_set( &self, message_queues: HashSet<MessageQueue>, persist: bool, )

Commits the offsets for the specified subset of assigned queues.

async fn commit_sync(&self)

Commits all consumed offsets to the consumer offset store.

async fn commit_sync_with_map( &self, offset_map: HashMap<MessageQueue, i64>, persist: bool, )

Commits the provided offsets and optionally persists them to the broker.

async fn is_auto_commit(&self) -> bool

Returns whether automatic offset commit is enabled.

async fn set_auto_commit(&self, auto_commit: bool)

Enables or disables automatic offset commit.

async fn auto_commit_interval_millis(&self) -> u64

Returns the interval between automatic offset commits in milliseconds.

async fn set_auto_commit_interval_millis(&self, interval_millis: u64)

Sets the interval between automatic offset commits in milliseconds.

async fn offset_for_timestamp( &self, message_queue: &MessageQueue, timestamp: u64, ) -> ClientResult<i64>

Queries the broker for the offset corresponding to the given timestamp in a queue.

async fn earliest_msg_store_time( &self, message_queue: &MessageQueue, ) -> ClientResult<i64>

Queries the broker for the earliest message store time of the specified queue.

async fn max_offset(&self, message_queue: &MessageQueue) -> ClientResult<i64>

Queries the broker for the current maximum offset of the specified queue.

async fn min_offset(&self, message_queue: &MessageQueue) -> ClientResult<i64>

Queries the broker for the current minimum offset of the specified queue.

impl MQConsumer for DefaultLitePullConsumer

async fn create_topic( &mut self, key: &str, new_topic: &str, queue_num: i32, attributes: HashMap<String, String>, ) -> ClientResult<()>

Creates a topic through the consumer’s admin facade.

async fn create_topic_with_flag( &mut self, key: &str, new_topic: &str, queue_num: i32, topic_sys_flag: i32, attributes: HashMap<String, String>, ) -> ClientResult<()>

Creates a topic with an explicit topic system flag.

async fn query_message( &mut self, topic: &str, key: &str, max_num: i32, begin: u64, end: u64, ) -> ClientResult<QueryResult>

Queries messages by key in a time range.

async fn view_message( &mut self, topic: &str, msg_id: &str, ) -> ClientResult<MessageExt>

Views a message by message id.

async fn send_message_back( &mut self, _msg: MessageExt, _delay_level: i32, _broker_name: &str, ) -> ClientResult<()>

async fn fetch_subscribe_message_queues( &mut self, topic: &str, ) -> ClientResult<Vec<MessageQueue>>

async fn search_offset( &mut self, mq: &MessageQueue, timestamp: u64, ) -> ClientResult<i64>

Searches the offset in a queue by store timestamp.

async fn max_offset(&mut self, mq: &MessageQueue) -> ClientResult<i64>

Returns the broker max offset for a queue.

async fn min_offset(&mut self, mq: &MessageQueue) -> ClientResult<i64>

Returns the broker min offset for a queue.

async fn earliest_msg_store_time( &mut self, mq: &MessageQueue, ) -> ClientResult<i64>

Returns the earliest store time for messages in a queue.

async fn send_message_back_to_origin_broker( &mut self, msg: MessageExt, delay_level: i32, ) -> ClientResult<()>

Sends a message back using the broker name carried by the message.

impl MessagePoll for DefaultLitePullConsumer

async fn poll_zero_copy(&self) -> Vec<Arc<MessageExt>>

Zero-copy implementation.

async fn poll_with_timeout_zero_copy( &self, timeout: u64, ) -> Vec<Arc<MessageExt>>

Zero-copy implementation with custom timeout.

async fn poll(&self) -> Vec<MessageExt>

Delegates to zero-copy implementation and creates owned message copies.

async fn poll_with_timeout(&self, timeout: u64) -> Vec<MessageExt>

Delegates to zero-copy implementation with timeout and creates owned message copies.

async fn poll_timeout_millis(&self) -> u64

Returns the default timeout used by poll in milliseconds.

async fn set_poll_timeout_millis(&self, timeout_millis: u64)

Sets the default timeout used by poll in milliseconds.

async fn broker_suspend_max_time_millis(&self) -> u64

Returns the maximum time that the broker may suspend a long-poll pull request.

async fn set_broker_suspend_max_time_millis(&self, timeout_millis: u64)

Sets the maximum time that the broker may suspend a long-poll pull request.

async fn consumer_timeout_millis_when_suspend(&self) -> u64

Returns the consumer-side timeout for suspended long-poll pull requests.

async fn set_consumer_timeout_millis_when_suspend(&self, timeout_millis: u64)

Sets the consumer-side timeout for suspended long-poll pull requests.

async fn consumer_pull_timeout_millis(&self) -> u64

Returns the RPC timeout used by lite pull requests in milliseconds.

async fn set_consumer_pull_timeout_millis(&self, timeout_millis: u64)

Sets the RPC timeout used by lite pull requests in milliseconds.

async fn pull_batch_size(&self) -> i32

Returns the maximum number of messages requested in a single pull.

async fn set_pull_batch_size(&self, pull_batch_size: i32)

Sets the maximum number of messages requested in a single pull.

async fn pull_thread_nums(&self) -> usize

Returns the configured number of pull worker threads.

async fn set_pull_thread_nums(&self, pull_thread_nums: usize)

Sets the configured number of pull worker threads.

async fn pull_threshold_for_all(&self) -> i64

Returns the maximum total number of cached messages across all queues.

async fn set_pull_threshold_for_all(&self, pull_threshold_for_all: i64)

Sets the maximum total number of cached messages across all queues.

async fn pull_threshold_for_queue(&self) -> i64

Returns the maximum cached message count for each queue.

async fn set_pull_threshold_for_queue(&self, pull_threshold_for_queue: i64)

Sets the maximum cached message count for each queue.

async fn pull_threshold_size_for_queue(&self) -> i32

Returns the maximum cached message size in MiB for each queue.

async fn set_pull_threshold_size_for_queue( &self, pull_threshold_size_for_queue: i32, )

Sets the maximum cached message size in MiB for each queue.

async fn consume_max_span(&self) -> i64

Returns the maximum allowed offset span in a cached process queue.

async fn set_consume_max_span(&self, consume_max_span: i64)

Sets the maximum allowed offset span in a cached process queue.

impl SubscriptionControl for DefaultLitePullConsumer

async fn subscribe(&self, topic: &str) -> ClientResult<()>

Subscribes to the specified topic using the default subscription expression.

async fn subscribe_with_expression( &self, topic: &str, sub_expression: &str, ) -> ClientResult<()>

Subscribes to the specified topic with a tag-based or SQL-based filter expression.

async fn subscribe_with_listener<MQL>( &self, topic: &str, sub_expression: &str, listener: MQL, ) -> ClientResult<()>

where MQL: MessageQueueListener + 'static,

Subscribes to the specified topic with a filter expression and a queue-change listener.

async fn subscribe_with_selector( &self, topic: &str, selector: Option<MessageSelector>, ) -> ClientResult<()>

Subscribes to the specified topic using a MessageSelector for server-side filtering.

async fn unsubscribe(&self, topic: &str)

Removes the subscription for the specified topic.

async fn build_subscriptions_for_heartbeat( &self, sub_expression_map: &mut HashMap<String, MessageSelector>, ) -> ClientResult<()>

Populates sub_expression_map with the filter selector for each subscribed topic, providing the subscription metadata required for heartbeat payloads.

async fn subscriptions_for_heartbeat(&self) -> HashSet<SubscriptionData>

Returns the subscriptions currently advertised in heartbeat payloads.

async fn message_model(&self) -> MessageModel

Returns the configured message model.

async fn set_message_model(&self, message_model: MessageModel)

Sets the message model.

async fn consume_from_where(&self) -> ConsumeFromWhere

Returns where consumption starts when no offset exists.

async fn set_consume_from_where( &self, consume_from_where: ConsumeFromWhere, ) -> ClientResult<()>

Sets where consumption starts when no offset exists.

async fn consume_timestamp(&self) -> Option<CheetahString>

Returns the timestamp used by ConsumeFromWhere::ConsumeFromTimestamp.

async fn set_consume_timestamp(&self, consume_timestamp: Option<CheetahString>)

Sets the timestamp used by ConsumeFromWhere::ConsumeFromTimestamp.

async fn allocate_message_queue_strategy( &self, ) -> Arc<dyn AllocateMessageQueueStrategy + Send + Sync>

Returns the message queue allocation strategy used during rebalance.

async fn set_allocate_message_queue_strategy( &self, allocate_message_queue_strategy: Arc<dyn AllocateMessageQueueStrategy + Send + Sync>, )

Sets the message queue allocation strategy used during rebalance.

async fn message_queue_listener(&self) -> Option<ArcMessageQueueListener>

Returns the listener notified when rebalance changes assigned message queues.

async fn set_message_queue_listener( &self, message_queue_listener: Option<ArcMessageQueueListener>, )

Sets the listener notified when rebalance changes assigned message queues.

async fn topic_metadata_check_interval_millis(&self) -> u64

Returns the topic metadata check interval in milliseconds.

async fn set_topic_metadata_check_interval_millis(&self, interval_millis: u64)

Sets the topic metadata check interval in milliseconds.

async fn is_connect_broker_by_user(&self) -> bool

Returns whether pulls always use the configured default broker ID.

async fn set_connect_broker_by_user(&self, connect_broker_by_user: bool)

Sets whether pulls always use the configured default broker ID.

async fn default_broker_id(&self) -> u64

Returns the broker ID used when user-controlled broker selection is enabled.

async fn set_default_broker_id(&self, broker_id: u64)

Sets the broker ID used when user-controlled broker selection is enabled.

async fn is_unit_mode(&self) -> bool

Returns whether the subscription group runs in unit mode.

async fn set_unit_mode(&self, unit_mode: bool)

Sets whether the subscription group runs in unit mode.

async fn update_name_server_address(&self, name_server_address: &str)

Updates the name server address used for topic route discovery.

async fn register_topic_message_queue_change_listener<TL>( &self, topic: &str, listener: TL, ) -> ClientResult<()>

where TL: TopicMessageQueueChangeListener + 'static,

Registers a listener that is notified when the set of MessageQueues for a topic changes.