reductstore 1.20.9

ReductStore is a time series database designed specifically for storing and managing large amounts of blob data.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

// Copyright 2021-2026 ReductSoftware UG
// Licensed under the Apache License, Version 2.0

use crate::lifecycle::ManageLifecycles;
use async_trait::async_trait;
use reduct_base::error::ReductError;
use reduct_base::forbidden;
use reduct_base::msg::lifecycle_api::{
    FullLifecycleInfo, LifecycleInfo, LifecycleMode, LifecycleSettings,
};

pub(super) struct ReadOnlyLifecycleRepository;

impl ReadOnlyLifecycleRepository {
    pub(super) fn new() -> Self {
        Self {}
    }
}

#[async_trait]
impl ManageLifecycles for ReadOnlyLifecycleRepository {
    async fn create_lifecycle(
        &mut self,
        _name: &str,
        _settings: LifecycleSettings,
    ) -> Result<(), ReductError> {
        Err(forbidden!("Cannot create lifecycle in read-only mode"))
    }

    async fn update_lifecycle(
        &mut self,
        _name: &str,
        _settings: LifecycleSettings,
    ) -> Result<(), ReductError> {
        Err(forbidden!("Cannot update lifecycle in read-only mode"))
    }

    async fn lifecycles(&self) -> Result<Vec<LifecycleInfo>, ReductError> {
        Ok(vec![])
    }

    async fn get_info(&self, _name: &str) -> Result<FullLifecycleInfo, ReductError> {
        Err(forbidden!("Cannot get lifecycle info in read-only mode"))
    }

    async fn get_lifecycle_settings(&self, _name: &str) -> Result<LifecycleSettings, ReductError> {
        Err(forbidden!(
            "Cannot get lifecycle settings in read-only mode"
        ))
    }

    async fn is_lifecycle_running(&self, _name: &str) -> Result<bool, ReductError> {
        Err(forbidden!("Cannot get lifecycle in read-only mode"))
    }

    async fn set_mode(&mut self, _name: &str, _mode: LifecycleMode) -> Result<(), ReductError> {
        Err(forbidden!("Cannot set lifecycle mode in read-only mode"))
    }

    async fn set_lifecycle_provisioned(
        &mut self,
        _name: &str,
        _provisioned: bool,
    ) -> Result<(), ReductError> {
        Err(forbidden!(
            "Cannot set lifecycle provisioned state in read-only mode"
        ))
    }

    async fn remove_lifecycle(&mut self, _name: &str) -> Result<(), ReductError> {
        Err(forbidden!("Cannot remove lifecycle in read-only mode"))
    }

    async fn start(&mut self) -> Result<(), ReductError> {
        // No-op
        Ok(())
    }

    async fn stop(&mut self) {
        // No-op
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use reduct_base::forbidden;
    use rstest::{fixture, rstest};

    #[fixture]
    fn repo() -> ReadOnlyLifecycleRepository {
        ReadOnlyLifecycleRepository::new()
    }

    #[rstest]
    #[tokio::test]
    async fn rejects_create(mut repo: ReadOnlyLifecycleRepository) {
        let err = repo
            .create_lifecycle("test", LifecycleSettings::default())
            .await
            .err()
            .unwrap();
        assert_eq!(err, forbidden!("Cannot create lifecycle in read-only mode"));
    }

    #[rstest]
    #[tokio::test]
    async fn rejects_update(mut repo: ReadOnlyLifecycleRepository) {
        let err = repo
            .update_lifecycle("test", LifecycleSettings::default())
            .await
            .err()
            .unwrap();
        assert_eq!(err, forbidden!("Cannot update lifecycle in read-only mode"));
    }

    #[rstest]
    #[tokio::test]
    async fn returns_empty_list(repo: ReadOnlyLifecycleRepository) {
        assert!(repo.lifecycles().await.unwrap().is_empty());
    }

    #[rstest]
    #[tokio::test]
    async fn rejects_getters(repo: ReadOnlyLifecycleRepository) {
        assert_eq!(
            repo.get_info("test").await.err().unwrap(),
            forbidden!("Cannot get lifecycle info in read-only mode")
        );
        assert_eq!(
            repo.get_lifecycle_settings("test").await.err().unwrap(),
            forbidden!("Cannot get lifecycle settings in read-only mode")
        );
        assert_eq!(
            repo.is_lifecycle_running("test").await.err().unwrap(),
            forbidden!("Cannot get lifecycle in read-only mode")
        );
    }

    #[rstest]
    #[tokio::test]
    async fn rejects_mutations(mut repo: ReadOnlyLifecycleRepository) {
        assert_eq!(
            repo.set_lifecycle_provisioned("test", true)
                .await
                .err()
                .unwrap(),
            forbidden!("Cannot set lifecycle provisioned state in read-only mode")
        );
        assert_eq!(
            repo.remove_lifecycle("test").await.err().unwrap(),
            forbidden!("Cannot remove lifecycle in read-only mode")
        );
        assert_eq!(
            repo.set_mode("test", LifecycleMode::Disabled)
                .await
                .err()
                .unwrap(),
            forbidden!("Cannot set lifecycle mode in read-only mode")
        );
    }

    #[rstest]
    #[tokio::test]
    async fn start_and_stop_are_noops(mut repo: ReadOnlyLifecycleRepository) {
        repo.start().await.unwrap();
        repo.stop().await;
    }
}