Trait PubSubCommands

pub trait PubSubCommands {
    // Required methods
    fn psubscribe<'a, P, PP>(
        &'a mut self,
        patterns: PP,
    ) -> Future<'a, PubSubStream>
       where P: Into<CommandArg> + Send + 'a,
             PP: SingleArgOrCollection<P>;
    fn ssubscribe<'a, C, CC>(
        &'a mut self,
        shardchannels: CC,
    ) -> Future<'a, PubSubStream>
       where C: Into<CommandArg> + Send + 'a,
             CC: SingleArgOrCollection<C>;
    fn subscribe<'a, C, CC>(
        &'a mut self,
        channels: CC,
    ) -> Future<'a, PubSubStream>
       where C: Into<CommandArg> + Send + 'a,
             CC: SingleArgOrCollection<C>;

    // Provided methods
    fn publish<C, M>(
        &mut self,
        channel: C,
        message: M,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             C: Into<CommandArg>,
             M: Into<CommandArg> { ... }
    fn pub_sub_channels<C, CC>(
        &mut self,
        options: PubSubChannelsOptions,
    ) -> PreparedCommand<'_, Self, CC>
       where Self: Sized,
             C: FromValue,
             CC: FromSingleValueArray<C> { ... }
    fn pub_sub_numpat(&mut self) -> PreparedCommand<'_, Self, usize>
       where Self: Sized { ... }
    fn pub_sub_numsub<C, CC, R, RR>(
        &mut self,
        channels: CC,
    ) -> PreparedCommand<'_, Self, RR>
       where Self: Sized,
             C: Into<CommandArg>,
             CC: SingleArgOrCollection<C>,
             R: FromValue,
             RR: FromKeyValueValueArray<R, usize> { ... }
    fn pub_sub_shardchannels<C, CC>(
        &mut self,
        options: PubSubChannelsOptions,
    ) -> PreparedCommand<'_, Self, CC>
       where Self: Sized,
             C: FromValue,
             CC: FromSingleValueArray<C> { ... }
    fn pub_sub_shardnumsub<C, CC, R, RR>(
        &mut self,
        channels: CC,
    ) -> PreparedCommand<'_, Self, RR>
       where Self: Sized,
             C: Into<CommandArg>,
             CC: SingleArgOrCollection<C>,
             R: FromValue,
             RR: FromKeyValueValueArray<R, usize> { ... }
    fn spublish<C, M>(
        &mut self,
        shardchannel: C,
        message: M,
    ) -> PreparedCommand<'_, Self, usize>
       where Self: Sized,
             C: Into<CommandArg>,
             M: Into<CommandArg> { ... }
}

A group of Redis commands related to Pub/Sub

See Also

Redis Pub/Sub Commands

Required Methods

fn psubscribe<'a, P, PP>(&'a mut self, patterns: PP) -> Future<'a, PubSubStream>

where P: Into<CommandArg> + Send + 'a, PP: SingleArgOrCollection<P>,

Subscribes the client to the given patterns.

Example

use redis_driver::{
    resp::cmd, Client, ClientPreparedCommand, FlushingMode,
    PubSubCommands, ServerCommands, Result
};
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<()> {
    let mut pub_sub_client = Client::connect("127.0.0.1:6379").await?;
    let mut regular_client = Client::connect("127.0.0.1:6379").await?;

    regular_client.flushdb(FlushingMode::Sync).await?;

    let mut pub_sub_stream = pub_sub_client.psubscribe("mychannel*").await?;

    regular_client.publish("mychannel1", "mymessage").await?;

    let (pattern, channel, message): (String, String, String) = pub_sub_stream
        .next()
        .await
        .unwrap()?
        .into()?;

    assert_eq!("mychannel*", pattern);
    assert_eq!("mychannel1", channel);
    assert_eq!("mymessage", message);

    pub_sub_stream.close().await?;

    Ok(())
}

See Also

https://redis.io/commands/psubscribe/

fn ssubscribe<'a, C, CC>( &'a mut self, shardchannels: CC, ) -> Future<'a, PubSubStream>

where C: Into<CommandArg> + Send + 'a, CC: SingleArgOrCollection<C>,

Subscribes the client to the specified channels.

See Also

https://redis.io/commands/subscribe/

fn subscribe<'a, C, CC>(&'a mut self, channels: CC) -> Future<'a, PubSubStream>

where C: Into<CommandArg> + Send + 'a, CC: SingleArgOrCollection<C>,

Subscribes the client to the specified channels.

Example

use redis_driver::{
    resp::cmd, Client, ClientPreparedCommand, FlushingMode,
    PubSubCommands, ServerCommands, Result
};
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<()> {
    let mut pub_sub_client = Client::connect("127.0.0.1:6379").await?;
    let mut regular_client = Client::connect("127.0.0.1:6379").await?;

    regular_client.flushdb(FlushingMode::Sync).await?;

    let mut pub_sub_stream = pub_sub_client.subscribe("mychannel").await?;

    regular_client.publish("mychannel", "mymessage").await?;

    let (channel, message): (String, String) = pub_sub_stream
        .next()
        .await
        .unwrap()?
        .into()?;

    assert_eq!("mychannel", channel);
    assert_eq!("mymessage", message);

    pub_sub_stream.close().await?;

    Ok(())
}

See Also

https://redis.io/commands/subscribe/

Provided Methods

fn publish<C, M>( &mut self, channel: C, message: M, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, C: Into<CommandArg>, M: Into<CommandArg>,

Posts a message to the given channel.

Return

The number of clients that received the message.

Note that in a Redis Cluster, only clients that are connected to the same node as the publishing client are included in the count.

See Also

https://redis.io/commands/publish/

fn pub_sub_channels<C, CC>( &mut self, options: PubSubChannelsOptions, ) -> PreparedCommand<'_, Self, CC>

where Self: Sized, C: FromValue, CC: FromSingleValueArray<C>,

Lists the currently active channels.

Return

A collection of active channels, optionally matching the specified pattern.

See Also

https://redis.io/commands/pubsub-channels/

fn pub_sub_numpat(&mut self) -> PreparedCommand<'_, Self, usize>

where Self: Sized,

Returns the number of unique patterns that are subscribed to by clients (that are performed using the PSUBSCRIBE command).

Return

The number of patterns all the clients are subscribed to.

See Also

https://redis.io/commands/pubsub-numpat/

fn pub_sub_numsub<C, CC, R, RR>( &mut self, channels: CC, ) -> PreparedCommand<'_, Self, RR>

where Self: Sized, C: Into<CommandArg>, CC: SingleArgOrCollection<C>, R: FromValue, RR: FromKeyValueValueArray<R, usize>,

Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.

Return

A collection of channels and number of subscribers for every channel.

See Also

https://redis.io/commands/pubsub-numsub/

fn pub_sub_shardchannels<C, CC>( &mut self, options: PubSubChannelsOptions, ) -> PreparedCommand<'_, Self, CC>

where Self: Sized, C: FromValue, CC: FromSingleValueArray<C>,

Lists the currently active shard channels.

Return

A collection of active channels, optionally matching the specified pattern.

See Also

https://redis.io/commands/pubsub-shardchannels/

fn pub_sub_shardnumsub<C, CC, R, RR>( &mut self, channels: CC, ) -> PreparedCommand<'_, Self, RR>

where Self: Sized, C: Into<CommandArg>, CC: SingleArgOrCollection<C>, R: FromValue, RR: FromKeyValueValueArray<R, usize>,

Returns the number of subscribers for the specified shard channels.

Return

A collection of channels and number of subscribers for every channel.

See Also

https://redis.io/commands/pubsub-shardnumsub/

fn spublish<C, M>( &mut self, shardchannel: C, message: M, ) -> PreparedCommand<'_, Self, usize>

where Self: Sized, C: Into<CommandArg>, M: Into<CommandArg>,

Posts a message to the given shard channel.

Return

The number of clients that received the message.

See Also

https://redis.io/commands/spublish/

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl PubSubCommands for Client

impl PubSubCommands for MultiplexedClient