embedded-redis 0.10.0

A no_std Redis client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Abstraction of PING command.
//!
//! For general information about this command, see the [Redis documentation](<https://redis.io/commands/ping/>).
//!
//! # Basic usage (client shorthand)
//! Internally it is checked whether the server answers with PONG. If not, an error is returned.
//! ```
//! # async_std::task::block_on(async {
//!# use core::str::FromStr;
//!# use core::net::SocketAddr;
//!# use std_embedded_nal_async::Stack;
//!# use std_embedded_time::StandardClock;
//!# use embedded_redis::network::ConnectionHandler;
//!#
//! let stack = Stack::default();
//! let clock = StandardClock::default();
//!
//! let mut connection_handler = ConnectionHandler::resp2(SocketAddr::from_str("127.0.0.1:6379").unwrap());
//! let client = connection_handler.connect(&stack, Some(&clock)).await.unwrap();
//!
//! let response = client.ping().await.unwrap();
//! # });
//! ```
//! # Verbose command
//! Sending a `PingCommand` as alternative to client shorthand.
//! ```
//! # async_std::task::block_on(async {
//!# use core::str::FromStr;
//!# use core::net::SocketAddr;
//!# use std_embedded_nal_async::Stack;
//!# use std_embedded_time::StandardClock;
//!# use embedded_redis::commands::ping::PingCommand;
//!# use embedded_redis::network::ConnectionHandler;
//!#
//!# let stack = Stack::default();
//!# let clock = StandardClock::default();
//!#
//!# let mut connection_handler = ConnectionHandler::resp2(SocketAddr::from_str("127.0.0.1:6379").unwrap());
//!# let client = connection_handler.connect(&stack, Some(&clock)).await.unwrap();
//!#
//! let command = PingCommand::new(None);
//! let response = client.send(command).await.unwrap();
//! # });
//! ```
//! # Custom argument
//! Optionally, a user-defined argument can be specified.
//!
//! The abstraction compares the server's response with the argument and returns an error if there is no match.
//! ```
//! # async_std::task::block_on(async {
//!# use core::str::FromStr;
//!# use core::net::SocketAddr;
//!# use std_embedded_nal_async::Stack;
//!# use std_embedded_time::StandardClock;
//!# use embedded_redis::commands::ping::PingCommand;
//!# use embedded_redis::network::ConnectionHandler;
//!#
//!# let stack = Stack::default();
//!# let clock = StandardClock::default();
//!#
//!# let mut connection_handler = ConnectionHandler::resp2(SocketAddr::from_str("127.0.0.1:6379").unwrap());
//!# let client = connection_handler.connect(&stack, Some(&clock)).await.unwrap();
//!#
//! let command = PingCommand::new(Some("hello world".into()));
//! let response = client.send(command).await.unwrap();
//! # });
//! ```
use crate::commands::auth::AuthCommand;
use crate::commands::builder::{CommandBuilder, ToStringOption};
use crate::commands::hello::HelloCommand;
use crate::commands::{Command, ResponseTypeError};
use crate::network::protocol::Protocol;
use crate::network::{Client, CommandErrors};
use bytes::Bytes;
use embedded_io_async::{Read, Write};
use embedded_time::Clock;

/// Abstraction for PING command
pub struct PingCommand {
    argument: Option<Bytes>,
}

impl PingCommand {
    pub fn new(argument: Option<Bytes>) -> Self {
        PingCommand { argument }
    }
}

static PONG: Bytes = Bytes::from_static(b"PONG");

impl<F> Command<F> for PingCommand
where
    F: From<CommandBuilder> + ToStringOption,
{
    type Response = ();

    fn encode(&self) -> F {
        CommandBuilder::new("PING").arg_option(self.argument.as_ref()).into()
    }

    fn eval_response(&self, frame: F) -> Result<Self::Response, ResponseTypeError> {
        let response = frame.to_string_option().ok_or(ResponseTypeError {})?;
        let pong = &PONG;
        let expected = self.argument.as_ref().unwrap_or(pong);

        if response.as_bytes() != expected.as_ref() {
            return Err(ResponseTypeError {});
        }

        Ok(())
    }
}

impl<'a, T: Read + Write, C: Clock, P: Protocol> Client<'a, T, C, P>
where
    AuthCommand: Command<<P as Protocol>::FrameType>,
    HelloCommand: Command<<P as Protocol>::FrameType>,
{
    /// Shorthand for [PingCommand]
    pub async fn ping(&self) -> Result<(), CommandErrors>
    where
        <P as Protocol>::FrameType: ToStringOption,
        <P as Protocol>::FrameType: From<CommandBuilder>,
    {
        self.send(PingCommand::new(None)).await
    }
}