miden-note-transport-node 0.4.0

Miden Note Transport Node
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

use std::sync::Arc;

use tokio::time::{Duration, sleep};
use tracing::{error, info};

use super::{Database, DatabaseConfig};
use crate::Result;
use crate::metrics::MetricsDatabase;

enum State {
    Stopped,
    Running,
}

/// Perform periodic maintenance of the database
pub struct DatabaseMaintenance {
    database: Arc<Database>,
    config: DatabaseConfig,
    state: State,
    metrics: MetricsDatabase,
}

impl DatabaseMaintenance {
    /// Main constructor
    pub fn new(database: Arc<Database>, config: DatabaseConfig, metrics: MetricsDatabase) -> Self {
        Self {
            database,
            config,
            state: State::Stopped,
            metrics,
        }
    }

    /// Database maintenance running-task
    pub async fn entrypoint(mut self) {
        self.state = State::Running;
        while self.is_active() {
            if let Err(e) = self.step().await {
                error!("Database maintenance error: {e}");
            }
        }
    }

    async fn step(&mut self) -> Result<()> {
        let timer = self.metrics.db_maintenance_cleanup_notes();

        self.database.cleanup_old_notes(self.config.retention_days).await?;
        info!("Cleaned up old notes");

        timer.finish("ok");

        sleep(Duration::from_secs(600)).await;

        Ok(())
    }

    fn is_active(&self) -> bool {
        matches!(self.state, State::Running)
    }
}

#[cfg(test)]
mod tests {
    use chrono::Utc;
    use serial_test::serial;

    use super::*;
    use crate::metrics::Metrics;
    use crate::test_utils::test_note_header;
    use crate::types::StoredNote;

    fn note_at(age: Duration) -> StoredNote {
        StoredNote {
            header: test_note_header(),
            details: vec![1, 2, 3, 4],
            created_at: Utc::now() - age,
            seq: 0, // ignored on INSERT
        }
    }

    #[tokio::test]
    #[serial]
    async fn test_cleanup_old_notes_no_retention() {
        let config = DatabaseConfig { retention_days: 0, ..Default::default() };

        let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
        db.store_note(&note_at(Duration::from_secs(30))).await.unwrap();

        let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
        tokio::spawn(maintenance.entrypoint());
        sleep(Duration::from_secs(2)).await;

        let (total_notes, _) = db.get_stats().await.unwrap();
        assert_eq!(total_notes, 0);
    }

    #[tokio::test]
    #[serial]
    async fn test_cleanup_old_notes_retention() {
        let config = DatabaseConfig { retention_days: 7, ..Default::default() };

        let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
        db.store_note(&note_at(Duration::from_secs(30))).await.unwrap();

        let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
        tokio::spawn(maintenance.entrypoint());
        sleep(Duration::from_secs(2)).await;

        let (total_notes, _) = db.get_stats().await.unwrap();
        assert_eq!(total_notes, 1);
    }

    #[tokio::test]
    #[serial]
    async fn test_cleanup_old_notes_mixed_ages() {
        let config = DatabaseConfig { retention_days: 1, ..Default::default() };

        let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
        db.store_note(&note_at(Duration::from_secs(30))).await.unwrap();
        db.store_note(&note_at(Duration::from_secs(3600 * 26))).await.unwrap();

        let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
        tokio::spawn(maintenance.entrypoint());
        sleep(Duration::from_secs(2)).await;

        let (total_notes, _) = db.get_stats().await.unwrap();
        assert_eq!(total_notes, 1);
    }
}