zebflow 0.10.3

Reactive web automation platform — pipelines, templates, and real-time collaboration in a single binary.
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

//! Placeholder for a future Redis-backed [`StateBus`] implementation.
//!
//! This file exists early so cluster-aware code has a stable module path even before Redis
//! support is implemented. The first clustered release should use `MemStateBus` with pinned
//! single-runner placement.

use serde_json::Value;

use super::interface::{
    StateBus, StateBusCapabilities, StateBusError, StateBusStats, StateSubscription,
};

/// Future Redis-backed state bus.
#[derive(Debug, Clone, Default)]
pub struct RedisStateBus;

impl StateBus for RedisStateBus {
    fn id(&self) -> &'static str {
        "state.redis"
    }

    fn capabilities(&self) -> StateBusCapabilities {
        StateBusCapabilities {
            ttl: true,
            atomic_incr: true,
            pubsub: true,
            durable: false,
            shared_coordination: true,
        }
    }

    fn stats(&self) -> Result<StateBusStats, StateBusError> {
        Err(StateBusError::not_implemented(self.id()))
    }

    fn get(&self, owner: &str, project: &str, key: &str) -> Result<Option<Value>, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn set(
        &self,
        owner: &str,
        project: &str,
        key: &str,
        _value: Value,
        _ttl_secs: Option<u64>,
    ) -> Result<(), StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn exists(&self, owner: &str, project: &str, key: &str) -> Result<bool, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn expire(
        &self,
        owner: &str,
        project: &str,
        key: &str,
        _ttl_secs: Option<u64>,
    ) -> Result<bool, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn incr(
        &self,
        owner: &str,
        project: &str,
        key: &str,
        _amount: i64,
    ) -> Result<i64, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn del(&self, owner: &str, project: &str, key: &str) -> Result<bool, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_key(key)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn publish(
        &self,
        owner: &str,
        project: &str,
        channel: &str,
        _message: Value,
    ) -> Result<usize, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_channel(channel)?;
        Err(StateBusError::not_implemented(self.id()))
    }

    fn subscribe(
        &self,
        owner: &str,
        project: &str,
        channel: &str,
    ) -> Result<StateSubscription, StateBusError> {
        self.validate_namespace(owner, project)?;
        self.validate_channel(channel)?;
        Err(StateBusError::not_implemented(self.id()))
    }
}