simple_redis 0.6.5

Simple and resilient 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

use simple_redis;
use simple_redis::{Interrupts, Message};
use std::{thread, time};

fn main() {
    match simple_redis::create("redis://127.0.0.1:6379/") {
        Ok(mut subscriber) => {
            println!("Created Redis Client");

            // simple subscription to pub_sub_example channel
            subscriber.subscribe("pub_sub_example").unwrap();

            // pattern based subscription
            subscriber.psubscribe("pub_sub_*").unwrap();

            thread::spawn(|| {
                thread::sleep(time::Duration::from_secs(2));

                match simple_redis::create("redis://127.0.0.1:6379/") {
                    Ok(mut publisher) => {
                        publisher
                            .publish("pub_sub_example", "example message")
                            .unwrap();

                        publisher.publish("pub_sub_test", "test message").unwrap();
                    }
                    _ => panic!("test error"),
                };
            });

            // get next two messages, since we subscribed via pattern to same channel
            let mut counter: usize = 0;
            subscriber
                .fetch_messages(
                    &mut |message: Message| -> bool {
                        let payload: String = message.get_payload().unwrap();
                        println!("Read message: {}", payload);
                        assert_eq!(payload, "example message");

                        counter = counter + 1;

                        counter >= 2
                    },
                    &mut || -> Interrupts { Interrupts::new() },
                )
                .unwrap();

            // wait for another message which only comes on the pattern channel
            subscriber
                .fetch_messages(
                    &mut |message: Message| -> bool {
                        let payload: String = message.get_payload().unwrap();
                        println!("Read message: {}", payload);
                        assert_eq!(payload, "test message");

                        true
                    },
                    &mut || -> Interrupts { Interrupts::new() },
                )
                .unwrap();

            subscriber.subscribe("pub_sub_second_run").unwrap();
            subscriber.unsubscribe("pub_sub_example").unwrap();
            subscriber.punsubscribe("pub_sub_*").unwrap();

            thread::spawn(|| {
                thread::sleep(time::Duration::from_secs(2));

                match simple_redis::create("redis://127.0.0.1:6379/") {
                    Ok(mut publisher) => {
                        publisher
                            .publish("pub_sub_example", "example message")
                            .unwrap();

                        publisher
                            .publish("pub_sub_second_run", "second message")
                            .unwrap();
                    }
                    _ => panic!("test error"),
                };
            });

            subscriber
                .fetch_messages(
                    &mut |message: Message| -> bool {
                        let payload: String = message.get_payload().unwrap();
                        println!("Read message: {}", payload);
                        assert_eq!(payload, "second message");

                        true
                    },
                    &mut || -> Interrupts { Interrupts::new() },
                )
                .unwrap();
        }
        Err(error) => println!("Unable to create Redis client: {}", error),
    }
}