piperedis 0.1.6

A pipebase plugin using redis rust 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

use crate::client::RedisClient;
use async_trait::async_trait;
use pipebase::{
    common::{ConfigInto, FromConfig, FromPath, LeftRight},
    export::Export,
};
use redis::ToRedisArgs;
use serde::Deserialize;

#[derive(Deserialize)]
pub struct RedisStringWriterConfig {
    // connection parameter: https://docs.rs/redis/0.20.2/redis/#connection-parameters
    url: String,
}

impl FromPath for RedisStringWriterConfig {}

impl ConfigInto<RedisStringWriter> for RedisStringWriterConfig {}

pub struct RedisStringWriter {
    client: RedisClient,
}

#[async_trait]
impl FromConfig<RedisStringWriterConfig> for RedisStringWriter {
    async fn from_config(config: RedisStringWriterConfig) -> anyhow::Result<Self> {
        Ok(RedisStringWriter {
            client: RedisClient::new(config.url)?,
        })
    }
}

#[async_trait]
impl<K, V, P> Export<P, RedisStringWriterConfig> for RedisStringWriter
where
    P: LeftRight<L = K, R = V> + Send + 'static,
    K: ToRedisArgs + Clone + Send + 'static,
    V: ToRedisArgs + Clone + Send + 'static,
{
    async fn export(&mut self, p: P) -> anyhow::Result<()> {
        self.client.set(p)?;
        Ok(())
    }
}

#[derive(Deserialize)]
pub struct RedisPublisherConfig {
    // connection parameter: https://docs.rs/redis/0.20.2/redis/#connection-parameters
    url: String,
}

impl FromPath for RedisPublisherConfig {}

impl ConfigInto<RedisPublisher> for RedisPublisherConfig {}

pub struct RedisPublisher {
    client: RedisClient,
}

#[async_trait]
impl FromConfig<RedisPublisherConfig> for RedisPublisher {
    async fn from_config(config: RedisPublisherConfig) -> anyhow::Result<Self> {
        Ok(RedisPublisher {
            client: RedisClient::new(config.url)?,
        })
    }
}

#[async_trait]
impl<K, V, P> Export<P, RedisPublisherConfig> for RedisPublisher
where
    P: LeftRight<L = K, R = V> + Send + 'static,
    K: ToRedisArgs + Clone + Send + 'static,
    V: ToRedisArgs + Clone + Send + 'static,
{
    async fn export(&mut self, p: P) -> anyhow::Result<()> {
        self.client.publish(p)?;
        Ok(())
    }
}

#[derive(Deserialize)]
pub struct RedisStringBatchWriterConfig {
    // connection parameter: https://docs.rs/redis/0.20.2/redis/#connection-parameters
    url: String,
}

impl FromPath for RedisStringBatchWriterConfig {}

impl ConfigInto<RedisStringBatchWriter> for RedisStringBatchWriterConfig {}

pub struct RedisStringBatchWriter {
    client: RedisClient,
}

#[async_trait]
impl FromConfig<RedisStringBatchWriterConfig> for RedisStringBatchWriter {
    async fn from_config(config: RedisStringBatchWriterConfig) -> anyhow::Result<Self> {
        Ok(RedisStringBatchWriter {
            client: RedisClient::new(config.url)?,
        })
    }
}

#[async_trait]
impl<K, V, P> Export<Vec<P>, RedisStringBatchWriterConfig> for RedisStringBatchWriter
where
    P: LeftRight<L = K, R = V> + Send + 'static,
    K: ToRedisArgs + Clone + Send + 'static,
    V: ToRedisArgs + Clone + Send + 'static,
{
    async fn export(&mut self, entries: Vec<P>) -> anyhow::Result<()> {
        self.client.set_all(entries)?;
        Ok(())
    }
}