Debian Codegraph @

third_party/rust/mls-rs-provider-sqlite/src/group_state.rs

raw
1 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2 // Copyright by contributors to this project.
3 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
4
5 use mls_rs_core::{
6 group::{EpochRecord, GroupState, GroupStateStorage},
7 mls_rs_codec::MlsEncode,
8 };
9 use rusqlite::{params, Connection, OptionalExtension};
10 use std::{
11 fmt::Debug,
12 sync::{Arc, Mutex},
13 };
14
15 use crate::SqLiteDataStorageError;
16
17 pub(crate) const DEFAULT_EPOCH_RETENTION_LIMIT: u64 = 3;
18
19 #[derive(Debug, Clone)]
20 /// SQLite Storage for MLS group states.
21 pub struct SqLiteGroupStateStorage {
22 connection: Arc<Mutex<Connection>>,
23 max_epoch_retention: u64,
24 state_context: Option<Vec<u8>>,
25 }
26
27 impl SqLiteGroupStateStorage {
28 pub(crate) fn new(
29 connection: Connection,
30 state_context: Option<Vec<u8>>,
31 ) -> SqLiteGroupStateStorage {
32 SqLiteGroupStateStorage {
33 connection: Arc::new(Mutex::new(connection)),
34 max_epoch_retention: DEFAULT_EPOCH_RETENTION_LIMIT,
35 state_context,
36 }
37 }
38
39 pub fn with_max_epoch_retention(self, max_epoch_retention: u64) -> Self {
40 Self {
41 connection: self.connection,
42 max_epoch_retention,
43 state_context: self.state_context,
44 }
45 }
46
47 /// List all the group ids for groups that are stored.
48 pub fn group_ids(&self) -> Result<Vec<Vec<u8>>, SqLiteDataStorageError> {
49 let connection = self.connection.lock().unwrap();
50
51 let mut statement = connection
52 .prepare("SELECT group_id FROM mls_group")
53 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
54
55 let res = statement
56 .query_map([], |row| row.get(0))
57 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?
58 .try_fold(Vec::new(), |mut ids, id| {
59 ids.push(id.map_err(|e| SqLiteDataStorageError::DataConversionError(e.into()))?);
60 Ok::<_, SqLiteDataStorageError>(ids)
61 })
62 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
63
64 Ok(res)
65 }
66
67 /// Delete a group from storage.
68 pub fn delete_group(&self, group_id: &[u8]) -> Result<(), SqLiteDataStorageError> {
69 let connection = self.connection.lock().unwrap();
70
71 let alternative_gid = self.alternative_group_id(group_id)?;
72 let group_id = alternative_gid.as_deref().unwrap_or(group_id);
73
74 connection
75 .execute(
76 "DELETE FROM mls_group WHERE group_id = ?",
77 params![group_id],
78 )
79 .map(|_| ())
80 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
81 }
82
83 pub fn max_epoch_retention(&self) -> u64 {
84 self.max_epoch_retention
85 }
86
87 fn get_snapshot_data(
88 &self,
89 group_id: &[u8],
90 ) -> Result<Option<Vec<u8>>, SqLiteDataStorageError> {
91 let connection = self.connection.lock().unwrap();
92
93 let alternative_gid = self.alternative_group_id(group_id)?;
94 let group_id = alternative_gid.as_deref().unwrap_or(group_id);
95
96 // println!("alternative gid get {:?}", group_id);
97
98 connection
99 .query_row(
100 "SELECT snapshot FROM mls_group where group_id = ?",
101 [group_id],
102 |row| row.get::<_, Vec<u8>>(0),
103 )
104 .optional()
105 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
106 }
107
108 fn get_epoch_data(
109 &self,
110 group_id: &[u8],
111 epoch_id: u64,
112 ) -> Result<Option<Vec<u8>>, SqLiteDataStorageError> {
113 let connection = self.connection.lock().unwrap();
114
115 let alternative_gid = self.alternative_group_id(group_id)?;
116 let group_id = alternative_gid.as_deref().unwrap_or(group_id);
117
118 connection
119 .query_row(
120 "SELECT epoch_data FROM epoch where group_id = ? AND epoch_id = ?",
121 params![group_id, epoch_id],
122 |row| row.get::<_, Vec<u8>>(0),
123 )
124 .optional()
125 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
126 }
127
128 fn max_epoch_id(&self, group_id: &[u8]) -> Result<Option<u64>, SqLiteDataStorageError> {
129 let connection = self.connection.lock().unwrap();
130
131 connection
132 .query_row(
133 "SELECT MAX(epoch_id) FROM epoch WHERE group_id = ?",
134 params![group_id],
135 |row| row.get::<_, Option<u64>>(0),
136 )
137 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
138 }
139
140 fn update_group_state(
141 &self,
142 group_id: &[u8],
143 group_snapshot: Vec<u8>,
144 inserts: Vec<EpochRecord>,
145 updates: Vec<EpochRecord>,
146 ) -> Result<(), SqLiteDataStorageError> {
147 let mut max_epoch_id = None;
148
149 // println!("gid {:?}", group_id);
150
151 let alternative_gid = self.alternative_group_id(group_id)?;
152 let group_id = alternative_gid.as_deref().unwrap_or(group_id);
153
154 // println!("alternative gid {:?}", group_id);
155
156 let mut connection = self.connection.lock().unwrap();
157 let transaction = connection
158 .transaction()
159 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
160
161 // Upsert into the group table to set the most recent snapshot
162 transaction.execute(
163 "INSERT INTO mls_group (group_id, snapshot) VALUES (?, ?) ON CONFLICT(group_id) DO UPDATE SET snapshot=excluded.snapshot",
164 params![group_id, group_snapshot],
165 ).map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
166
167 // Insert new epochs as needed
168 for epoch in inserts {
169 max_epoch_id = Some(epoch.id);
170
171 transaction
172 .execute(
173 "INSERT INTO epoch (group_id, epoch_id, epoch_data) VALUES (?, ?, ?)",
174 params![group_id, epoch.id, epoch.data],
175 )
176 .map(|_| ())
177 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
178 }
179
180 // Update existing epochs as needed
181 updates.into_iter().try_for_each(|epoch| {
182 transaction
183 .execute(
184 "UPDATE epoch SET epoch_data = ? WHERE group_id = ? AND epoch_id = ?",
185 params![epoch.data, group_id, epoch.id],
186 )
187 .map(|_| ())
188 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
189 })?;
190
191 // Delete old epochs as needed
192 if let Some(max_epoch_id) = max_epoch_id {
193 if max_epoch_id >= self.max_epoch_retention {
194 let delete_under = max_epoch_id - self.max_epoch_retention;
195
196 transaction
197 .execute(
198 "DELETE FROM epoch WHERE group_id = ? AND epoch_id <= ?",
199 params![group_id, delete_under],
200 )
201 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))?;
202 }
203 }
204
205 // Execute the full transaction
206 transaction
207 .commit()
208 .map_err(|e| SqLiteDataStorageError::SqlEngineError(e.into()))
209 }
210
211 fn alternative_group_id(
212 &self,
213 group_id: &[u8],
214 ) -> Result<Option<Vec<u8>>, SqLiteDataStorageError> {
215 self.state_context
216 .as_ref()
217 .map(|context| {
218 (context, group_id)
219 .mls_encode_to_vec()
220 .map_err(|e| SqLiteDataStorageError::DataConversionError(Box::new(e)))
221 })
222 .transpose()
223 }
224 }
225
226 #[cfg_attr(not(mls_build_async), maybe_async::must_be_sync)]
227 #[cfg_attr(mls_build_async, maybe_async::must_be_async)]
228 impl GroupStateStorage for SqLiteGroupStateStorage {
229 type Error = SqLiteDataStorageError;
230
231 async fn write(
232 &mut self,
233 state: GroupState,
234 inserts: Vec<EpochRecord>,
235 updates: Vec<EpochRecord>,
236 ) -> Result<(), Self::Error> {
237 let group_id = state.id;
238 let snapshot_data = state.data;
239
240 self.update_group_state(&group_id, snapshot_data, inserts, updates)
241 }
242
243 async fn state(&self, group_id: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
244 self.get_snapshot_data(group_id)
245 }
246
247 async fn max_epoch_id(&self, group_id: &[u8]) -> Result<Option<u64>, Self::Error> {
248 self.max_epoch_id(group_id)
249 }
250
251 async fn epoch(&self, group_id: &[u8], epoch_id: u64) -> Result<Option<Vec<u8>>, Self::Error> {
252 self.get_epoch_data(group_id, epoch_id)
253 }
254 }
255
256 #[cfg(test)]
257 mod tests {
258 use crate::{
259 SqLiteDataStorageEngine,
260 {connection_strategy::MemoryStrategy, test_utils::gen_rand_bytes},
261 };
262
263 use super::*;
264
265 fn get_test_storage() -> SqLiteGroupStateStorage {
266 SqLiteDataStorageEngine::new(MemoryStrategy)
267 .unwrap()
268 .group_state_storage()
269 .unwrap()
270 }
271
272 fn test_group_id() -> Vec<u8> {
273 gen_rand_bytes(32)
274 }
275
276 fn test_snapshot() -> Vec<u8> {
277 gen_rand_bytes(1024)
278 }
279
280 fn test_epoch(id: u64) -> EpochRecord {
281 EpochRecord {
282 data: gen_rand_bytes(256),
283 id,
284 }
285 }
286
287 struct TestData {
288 storage: SqLiteGroupStateStorage,
289 snapshot: Vec<u8>,
290 group_id: Vec<u8>,
291 epoch_0: EpochRecord,
292 }
293
294 fn setup_group_storage_test() -> TestData {
295 let test_storage = get_test_storage();
296 let test_group_id = test_group_id();
297 let test_epoch_0 = test_epoch(0);
298 let test_snapshot = test_snapshot();
299
300 test_storage
301 .update_group_state(
302 &test_group_id,
303 test_snapshot.clone(),
304 vec![test_epoch_0.clone()],
305 vec![],
306 )
307 .unwrap();
308
309 TestData {
310 storage: test_storage,
311 group_id: test_group_id,
312 epoch_0: test_epoch_0,
313 snapshot: test_snapshot,
314 }
315 }
316
317 #[test]
318 fn group_can_be_initially_stored() {
319 let test_data = setup_group_storage_test();
320
321 // Attempt to fetch the snapshot
322 let snapshot = test_data
323 .storage
324 .get_snapshot_data(&test_data.group_id)
325 .unwrap();
326 assert_eq!(snapshot.unwrap(), test_data.snapshot);
327
328 // Attempt to fetch the epoch data
329 let epoch = test_data
330 .storage
331 .get_epoch_data(&test_data.group_id, 0)
332 .unwrap();
333 assert_eq!(epoch.unwrap(), test_data.epoch_0.data);
334 }
335
336 #[test]
337 fn snapshot_and_epoch_can_be_updated() {
338 let test_data = setup_group_storage_test();
339 let test_snapshot = test_snapshot();
340
341 let epoch_update = test_epoch(0);
342
343 test_data
344 .storage
345 .update_group_state(
346 &test_data.group_id,
347 test_snapshot.clone(),
348 vec![],
349 vec![epoch_update.clone()],
350 )
351 .unwrap();
352
353 // Attempt to fetch the new snapshot
354 let snapshot = test_data
355 .storage
356 .get_snapshot_data(&test_data.group_id)
357 .unwrap();
358
359 assert_eq!(snapshot.unwrap(), test_snapshot);
360
361 // Attempt to access the epochs
362 assert_eq!(
363 test_data
364 .storage
365 .get_epoch_data(&test_data.group_id, 0)
366 .unwrap()
367 .unwrap(),
368 epoch_update.data
369 );
370 }
371
372 #[test]
373 fn epochs_are_truncated() {
374 test_epochs_are_truncated(9);
375 test_epochs_are_truncated(DEFAULT_EPOCH_RETENTION_LIMIT);
376 }
377
378 fn test_epochs_are_truncated(n: u64) {
379 let test_data = setup_group_storage_test();
380
381 let mut test_epochs = (1..n + 1).map(test_epoch).collect::<Vec<_>>();
382
383 test_data
384 .storage
385 .update_group_state(
386 &test_data.group_id,
387 test_snapshot(),
388 test_epochs.clone(),
389 vec![],
390 )
391 .unwrap();
392
393 test_epochs.insert(0, test_data.epoch_0);
394
395 for epoch in test_epochs {
396 let stored = test_data
397 .storage
398 .get_epoch_data(&test_data.group_id, epoch.id)
399 .unwrap();
400
401 if epoch.id <= n - DEFAULT_EPOCH_RETENTION_LIMIT {
402 assert!(stored.is_none());
403 } else {
404 assert_eq!(stored.unwrap(), epoch.data);
405 }
406 }
407 }
408
409 #[test]
410 fn epoch_insert_update_old_epoch() {
411 let test_data = setup_group_storage_test();
412
413 test_data
414 .storage
415 .update_group_state(
416 &test_data.group_id,
417 test_snapshot(),
418 vec![test_epoch(1)],
419 vec![],
420 )
421 .unwrap();
422
423 let test_epochs = (2..10).map(test_epoch).collect::<Vec<_>>();
424 let new_epoch_1 = test_epoch(1);
425
426 test_data
427 .storage
428 .update_group_state(
429 &test_data.group_id,
430 test_snapshot(),
431 test_epochs.clone(),
432 vec![new_epoch_1.clone()],
433 )
434 .unwrap();
435
436 assert!(test_data
437 .storage
438 .get_epoch_data(&test_data.group_id, 1)
439 .unwrap()
440 .is_none());
441 }
442
443 #[test]
444 fn max_epoch_is_none_for_non_persisted_group() {
445 let storage = get_test_storage();
446
447 let res = storage.max_epoch_id(&[0, 1, 2]).unwrap();
448
449 assert!(res.is_none())
450 }
451
452 #[test]
453 fn max_epoch_is_none_when_no_epochs() {
454 let storage = get_test_storage();
455 let group_id = b"test";
456
457 storage
458 .update_group_state(group_id, vec![0, 1, 2], vec![], vec![])
459 .unwrap();
460
461 let res = storage.max_epoch_id(group_id).unwrap();
462
463 assert!(res.is_none())
464 }
465
466 #[test]
467 fn max_epoch_can_be_calculated() {
468 let test_data = setup_group_storage_test();
469
470 test_data
471 .storage
472 .update_group_state(
473 &test_data.group_id,
474 test_snapshot(),
475 (1..10).map(test_epoch).collect(),
476 vec![],
477 )
478 .unwrap();
479
480 assert_eq!(
481 test_data
482 .storage
483 .max_epoch_id(&test_data.group_id)
484 .unwrap()
485 .unwrap(),
486 9
487 );
488 }
489
490 #[test]
491 fn muiltiple_groups_can_exist() {
492 let test_data = setup_group_storage_test();
493
494 let new_group = test_group_id();
495 let new_group_epoch = test_epoch(0);
496
497 test_data
498 .storage
499 .update_group_state(
500 &new_group,
501 test_snapshot(),
502 vec![new_group_epoch.clone()],
503 vec![],
504 )
505 .unwrap();
506
507 let all_groups = test_data.storage.group_ids().unwrap();
508
509 // Order is not deterministic
510 vec![test_data.group_id.clone(), new_group.clone()]
511 .into_iter()
512 .for_each(|id| {
513 assert!(all_groups.contains(&id));
514 });
515
516 assert_eq!(
517 test_data
518 .storage
519 .get_epoch_data(&new_group, 0)
520 .unwrap()
521 .unwrap(),
522 new_group_epoch.data
523 );
524 }
525
526 #[test]
527 fn delete_group() {
528 let test_data = setup_group_storage_test();
529
530 test_data.storage.delete_group(&test_data.group_id).unwrap();
531
532 assert!(test_data.storage.group_ids().unwrap().is_empty());
533 }
534 }