miden_note_transport_node/database/
maintenance.rs1use std::sync::Arc;
2
3use tokio::time::{Duration, sleep};
4use tracing::{error, info};
5
6use super::{Database, DatabaseConfig};
7use crate::Result;
8use crate::metrics::MetricsDatabase;
9
10enum State {
11 Stopped,
12 Running,
13}
14
15pub struct DatabaseMaintenance {
17 database: Arc<Database>,
18 config: DatabaseConfig,
19 state: State,
20 metrics: MetricsDatabase,
21}
22
23impl DatabaseMaintenance {
24 pub fn new(database: Arc<Database>, config: DatabaseConfig, metrics: MetricsDatabase) -> Self {
26 Self {
27 database,
28 config,
29 state: State::Stopped,
30 metrics,
31 }
32 }
33
34 pub async fn entrypoint(mut self) {
36 self.state = State::Running;
37 while self.is_active() {
38 if let Err(e) = self.step().await {
39 error!("Database maintenance error: {e}");
40 }
41 }
42 }
43
44 async fn step(&mut self) -> Result<()> {
45 let timer = self.metrics.db_maintenance_cleanup_notes();
46
47 self.database.cleanup_old_notes(self.config.retention_days).await?;
48 info!("Cleaned up old notes");
49
50 timer.finish("ok");
51
52 sleep(Duration::from_secs(600)).await;
53
54 Ok(())
55 }
56
57 fn is_active(&self) -> bool {
58 matches!(self.state, State::Running)
59 }
60}
61
62#[cfg(test)]
63mod tests {
64 use chrono::Utc;
65 use serial_test::serial;
66
67 use super::*;
68 use crate::metrics::Metrics;
69 use crate::test_utils::test_note_header;
70 use crate::types::StoredNote;
71
72 fn note_at(age: Duration) -> StoredNote {
73 StoredNote {
74 header: test_note_header(),
75 details: vec![1, 2, 3, 4],
76 created_at: Utc::now() - age,
77 }
78 }
79
80 #[tokio::test]
81 #[serial]
82 async fn test_cleanup_old_notes_no_retention() {
83 let config = DatabaseConfig { retention_days: 0, ..Default::default() };
84
85 let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
86 db.store_note(¬e_at(Duration::from_secs(30))).await.unwrap();
87
88 let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
89 tokio::spawn(maintenance.entrypoint());
90 sleep(Duration::from_secs(2)).await;
91
92 let (total_notes, _) = db.get_stats().await.unwrap();
93 assert_eq!(total_notes, 0);
94 }
95
96 #[tokio::test]
97 #[serial]
98 async fn test_cleanup_old_notes_retention() {
99 let config = DatabaseConfig { retention_days: 7, ..Default::default() };
100
101 let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
102 db.store_note(¬e_at(Duration::from_secs(30))).await.unwrap();
103
104 let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
105 tokio::spawn(maintenance.entrypoint());
106 sleep(Duration::from_secs(2)).await;
107
108 let (total_notes, _) = db.get_stats().await.unwrap();
109 assert_eq!(total_notes, 1);
110 }
111
112 #[tokio::test]
113 #[serial]
114 async fn test_cleanup_old_notes_mixed_ages() {
115 let config = DatabaseConfig { retention_days: 1, ..Default::default() };
116
117 let db = Arc::new(Database::connect(config.clone(), Metrics::default().db).await.unwrap());
118 db.store_note(¬e_at(Duration::from_secs(30))).await.unwrap();
119 db.store_note(¬e_at(Duration::from_secs(3600 * 26))).await.unwrap();
120
121 let maintenance = DatabaseMaintenance::new(db.clone(), config, Metrics::default().db);
122 tokio::spawn(maintenance.entrypoint());
123 sleep(Duration::from_secs(2)).await;
124
125 let (total_notes, _) = db.get_stats().await.unwrap();
126 assert_eq!(total_notes, 1);
127 }
128}