Struct RedisConsumer 

pub struct RedisConsumer { /* private fields */ }

The Redis Consumer.

Implementations

impl RedisConsumer

pub fn group_id(&self) -> Option<&ConsumerGroup>

Get the assigned group id.

pub fn consumer_id(&self) -> Option<&ConsumerId>

Get the assigned consumer id.

pub fn stream_shards(&self) -> &[(StreamKey, ShardId)]

Return the stream-shards this consumer has been assigned. On create, it will self-assign all shards.

pub async fn seek_to(&mut self, id: MessageId) -> RedisResult<()>

Like Consumer::seek, but with MessageId.

pub fn ack(&self, msg: &SharedMessage) -> RedisResult<()>

Mark a message as read. The ACK will be queued for commit.

pub fn ack_with( &self, (stream_key, shard_id, sequence): &(StreamKey, ShardId, SeqNo), ) -> RedisResult<()>

pub fn commit(&mut self) -> RedisResult<impl Future<Output = RedisResult<()>>>

Commit all pending acks and (optionally) wait for the result.

pub fn commit_asap(&mut self) -> RedisResult<()>

Push a Commit request to the command queue, will be executed on the next cycle

pub async fn end(self) -> RedisResult<()>

Commit all pending acks and end the consumer.

Trait Implementations

impl Consumer for RedisConsumer

type Error = RedisErr

type Message<'a> = SharedMessage

type NextFuture<'a> = NextFuture<'a>

type Stream<'a> = StreamFuture<'a>

async fn seek(&mut self, ts: Timestamp) -> RedisResult<()>

Seek all streams to an arbitrary point in time. It will start consuming from the earliest message with a timestamp later than to.

async fn rewind(&mut self, pos: SeqPos) -> RedisResult<()>

Rewind all streams to a particular sequence number.

fn assign(&mut self, (stream, shard): (StreamKey, ShardId)) -> RedisResult<()>

Assign this consumer to a particular shard. Can be called multiple times to assign to multiple shards. Returns error StreamKeyNotFound if the stream is not currently subscribed.

fn unassign(&mut self, s: (StreamKey, ShardId)) -> RedisResult<()>

Unassign a shard. Returns error StreamKeyNotFound if the stream is not currently subscribed. Returns error StreamKeyEmpty if all streams have been unassigned.

fn next(&self) -> NextFuture<'_>

Poll and receive one message: it awaits until there are new messages. This method can be called from multiple threads.

fn stream<'a, 'b: 'a>(&'b mut self) -> Self::Stream<'a>

Returns an async stream. You cannot create multiple streams from the same consumer, nor perform any operation while streaming.

impl Debug for RedisConsumer

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

Formats the value using the given formatter.